From 8fa9ec29622d83c6c4ab1a76e906194be9946997 Mon Sep 17 00:00:00 2001
From: Xiang Gao <xgao@nvidia.com>
Date: Tue, 10 Dec 2024 11:50:14 -0800
Subject: [PATCH] dump-kernel-and-profile

---
 __tmp_kernel_none_f0_c0_r0_g0.cu | 11569 +++++++++++++++++++++++++++++
 nsys-log.txt                     |   221 +
 report1.nsys-rep                 |   Bin 0 -> 284494 bytes
 report1.sqlite                   |   Bin 0 -> 864256 bytes
 4 files changed, 11790 insertions(+)
 create mode 100644 __tmp_kernel_none_f0_c0_r0_g0.cu
 create mode 100644 nsys-log.txt
 create mode 100644 report1.nsys-rep
 create mode 100644 report1.sqlite

diff --git a/__tmp_kernel_none_f0_c0_r0_g0.cu b/__tmp_kernel_none_f0_c0_r0_g0.cu
new file mode 100644
index 00000000000..8aecce536f2
--- /dev/null
+++ b/__tmp_kernel_none_f0_c0_r0_g0.cu
@@ -0,0 +1,11569 @@
+
+#ifdef __NVCC__
+#include <complex>
+#endif // __NVCC__
+namespace {
+
+using int8_t = signed char;
+using uint8_t = unsigned char;
+using int16_t = short int;
+using uint16_t = unsigned short int;
+using int32_t = int;
+using uint32_t = unsigned int;
+using int64_t = long long int;
+using uint64_t = unsigned long long int;
+
+// Modified from cuda.h
+struct TensorMap {
+  alignas(64)
+  uint64_t opaque[16];
+};
+typedef int nvfuser_index_t;
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+#ifdef __NVCC__
+#include <type_traits>
+#else
+// The following namespace std is modified from LLVM, see the following
+// copyright information
+//
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+// copy-pasted from some llvm files:
+// - https://github.com/llvm/llvm-project/blob/main/libcxx/include/type_traits
+// -
+// https://github.com/llvm/llvm-project/blob/main/clang/test/Headers/Inputs/include/type_traits
+namespace std {
+
+template <class _Tp>
+_Tp&& __declval(int);
+template <class _Tp>
+_Tp __declval(long);
+template <class _Tp>
+decltype(__declval<_Tp>(0)) declval() noexcept;
+
+template <class _Tp, _Tp __v>
+struct integral_constant {
+  static const _Tp value = __v;
+  typedef _Tp value_type;
+  typedef integral_constant type;
+};
+
+typedef integral_constant<bool, true> true_type;
+typedef integral_constant<bool, false> false_type;
+
+// is_same, functional
+template <class _Tp, class _Up>
+struct is_same : public false_type {};
+template <class _Tp>
+struct is_same<_Tp, _Tp> : public true_type {};
+template <class T, class U>
+constexpr bool is_same_v = is_same<T, U>::value;
+
+// is_integral, for some types.
+template <class _Tp>
+struct is_integral : public integral_constant<bool, false> {};
+template <>
+struct is_integral<bool> : public integral_constant<bool, true> {};
+template <>
+struct is_integral<char> : public integral_constant<bool, true> {};
+template <>
+struct is_integral<short> : public integral_constant<bool, true> {};
+template <>
+struct is_integral<int> : public integral_constant<bool, true> {};
+template <>
+struct is_integral<long> : public integral_constant<bool, true> {};
+template <>
+struct is_integral<long long> : public integral_constant<bool, true> {};
+
+// enable_if, functional
+template <bool _C, typename _Tp>
+struct enable_if {};
+template <typename _Tp>
+struct enable_if<true, _Tp> {
+  using type = _Tp;
+};
+template <bool b, class T = void>
+using enable_if_t = typename enable_if<b, T>::type;
+
+template <class _Tp>
+struct remove_const {
+  typedef _Tp type;
+};
+template <class _Tp>
+struct remove_const<const _Tp> {
+  typedef _Tp type;
+};
+template <class _Tp>
+using remove_const_t = typename remove_const<_Tp>::type;
+
+template <class _Tp>
+struct remove_volatile {
+  typedef _Tp type;
+};
+template <class _Tp>
+struct remove_volatile<volatile _Tp> {
+  typedef _Tp type;
+};
+template <class _Tp>
+using remove_volatile_t = typename remove_volatile<_Tp>::type;
+
+template <class _Tp>
+struct remove_cv {
+  typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;
+};
+template <class _Tp>
+using remove_cv_t = typename remove_cv<_Tp>::type;
+
+template <class _Tp>
+struct __libcpp_is_floating_point : public false_type {};
+template <>
+struct __libcpp_is_floating_point<float> : public true_type {};
+template <>
+struct __libcpp_is_floating_point<double> : public true_type {};
+template <>
+struct __libcpp_is_floating_point<long double> : public true_type {};
+
+template <class _Tp>
+struct is_floating_point
+    : public __libcpp_is_floating_point<typename remove_cv<_Tp>::type> {};
+
+template <class _Tp>
+struct is_arithmetic
+    : public integral_constant<
+          bool,
+          is_integral<_Tp>::value || is_floating_point<_Tp>::value> {};
+template <class _Tp>
+inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
+
+template <class _Tp>
+struct __numeric_type {
+  static void __test(...);
+  static float __test(float);
+  static double __test(char);
+  static double __test(int);
+  static double __test(unsigned);
+  static double __test(long);
+  static double __test(unsigned long);
+  static double __test(long long);
+  static double __test(unsigned long long);
+  static double __test(double);
+  static long double __test(long double);
+
+  typedef decltype(__test(declval<_Tp>())) type;
+  static const bool value = !is_same<type, void>::value;
+};
+
+template <>
+struct __numeric_type<void> {
+  static const bool value = true;
+};
+
+// __promote
+
+template <
+    class _A1,
+    class _A2 = void,
+    class _A3 = void,
+    bool = __numeric_type<_A1>::value && __numeric_type<_A2>::value &&
+        __numeric_type<_A3>::value>
+class __promote_imp {
+ public:
+  static const bool value = false;
+};
+
+template <class _A1, class _A2, class _A3>
+class __promote_imp<_A1, _A2, _A3, true> {
+ private:
+  typedef typename __promote_imp<_A1>::type __type1;
+  typedef typename __promote_imp<_A2>::type __type2;
+  typedef typename __promote_imp<_A3>::type __type3;
+
+ public:
+  typedef decltype(__type1() + __type2() + __type3()) type;
+  static const bool value = true;
+};
+
+template <class _A1, class _A2>
+class __promote_imp<_A1, _A2, void, true> {
+ private:
+  typedef typename __promote_imp<_A1>::type __type1;
+  typedef typename __promote_imp<_A2>::type __type2;
+
+ public:
+  typedef decltype(__type1() + __type2()) type;
+  static const bool value = true;
+};
+
+template <class _A1>
+class __promote_imp<_A1, void, void, true> {
+ public:
+  typedef typename __numeric_type<_A1>::type type;
+  static const bool value = true;
+};
+
+template <class _A1, class _A2 = void, class _A3 = void>
+class __promote : public __promote_imp<_A1, _A2, _A3> {};
+
+} // namespace std
+#endif
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+#ifdef __NVCC__
+#include <bit>
+#else
+
+namespace std {
+
+template <class To, class From>
+std::enable_if_t<sizeof(To) == sizeof(From), To> bit_cast(
+    const From& src) noexcept {
+  return *reinterpret_cast<const To*>(&src);
+}
+
+} // namespace std
+
+#endif
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+#ifndef __NVCC__
+#define POS_INFINITY __int_as_float(0x7f800000)
+#define INFINITY POS_INFINITY
+#define NEG_INFINITY __int_as_float(0xff800000)
+#define NAN __int_as_float(0x7fffffff)
+//===----------------------------------------------------------------------===//
+// The following namespace std is modified from LLVM, see the following
+// copyright information
+//
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+// copy-pasted from the following llvm file:
+// https://github.com/llvm/llvm-project/blob/main/libcxx/include/complex
+namespace std {
+
+template <class _Tp>
+class complex;
+
+template <class _Tp>
+complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
+template <class _Tp>
+complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
+
+template <class _Tp>
+class complex {
+ public:
+  typedef _Tp value_type;
+
+ private:
+  value_type __re_;
+  value_type __im_;
+
+ public:
+  constexpr complex(
+      const value_type& __re = value_type(),
+      const value_type& __im = value_type())
+      : __re_(__re), __im_(__im) {}
+  template <class _Xp>
+  constexpr complex(const complex<_Xp>& __c)
+      : __re_(__c.real()), __im_(__c.imag()) {}
+
+  constexpr value_type real() const {
+    return __re_;
+  }
+  constexpr value_type imag() const {
+    return __im_;
+  }
+
+  void real(value_type __re) {
+    __re_ = __re;
+  }
+  void imag(value_type __im) {
+    __im_ = __im;
+  }
+
+  constexpr operator bool() const {
+    return real() || imag();
+  }
+
+  complex& operator=(const value_type& __re) {
+    __re_ = __re;
+    __im_ = value_type();
+    return *this;
+  }
+  complex& operator+=(const value_type& __re) {
+    __re_ += __re;
+    return *this;
+  }
+  complex& operator-=(const value_type& __re) {
+    __re_ -= __re;
+    return *this;
+  }
+  complex& operator*=(const value_type& __re) {
+    __re_ *= __re;
+    __im_ *= __re;
+    return *this;
+  }
+  complex& operator/=(const value_type& __re) {
+    __re_ /= __re;
+    __im_ /= __re;
+    return *this;
+  }
+
+  template <class _Xp>
+  complex& operator=(const complex<_Xp>& __c) {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  complex& operator+=(const complex<_Xp>& __c) {
+    __re_ += __c.real();
+    __im_ += __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  complex& operator-=(const complex<_Xp>& __c) {
+    __re_ -= __c.real();
+    __im_ -= __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  complex& operator*=(const complex<_Xp>& __c) {
+    *this = *this * complex(__c.real(), __c.imag());
+    return *this;
+  }
+  template <class _Xp>
+  complex& operator/=(const complex<_Xp>& __c) {
+    *this = *this / complex(__c.real(), __c.imag());
+    return *this;
+  }
+};
+
+template <>
+class complex<double>;
+
+template <>
+class complex<float> {
+  float __re_;
+  float __im_;
+
+ public:
+  typedef float value_type;
+
+  constexpr complex(float __re = 0.0f, float __im = 0.0f)
+      : __re_(__re), __im_(__im) {}
+
+  explicit constexpr complex(const complex<double>& __c);
+
+  // copy volatile to non-volatile
+  constexpr complex(const volatile complex<float>& other)
+      : __re_(other.__re_), __im_(other.__im_) {}
+
+  constexpr complex(const complex<float>& other)
+      : __re_(other.__re_), __im_(other.__im_) {}
+
+  constexpr float real() const {
+    return __re_;
+  }
+  constexpr float imag() const {
+    return __im_;
+  }
+
+  void real(value_type __re) {
+    __re_ = __re;
+  }
+  void imag(value_type __im) {
+    __im_ = __im;
+  }
+
+  constexpr operator bool() const {
+    return real() || imag();
+  }
+
+  complex& operator=(float __re) {
+    __re_ = __re;
+    __im_ = value_type();
+    return *this;
+  }
+  complex& operator+=(float __re) {
+    __re_ += __re;
+    return *this;
+  }
+  complex& operator-=(float __re) {
+    __re_ -= __re;
+    return *this;
+  }
+  complex& operator*=(float __re) {
+    __re_ *= __re;
+    __im_ *= __re;
+    return *this;
+  }
+  complex& operator/=(float __re) {
+    __re_ /= __re;
+    __im_ /= __re;
+    return *this;
+  }
+
+  template <class _Xp>
+  complex& operator=(const complex<_Xp>& __c) {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+
+  // non-volatile to volatile
+  template <class _Xp>
+  volatile complex& operator=(const complex<_Xp>& __c) volatile {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+  // volatile to non-volatile
+  template <class _Xp>
+  complex& operator=(const volatile complex<_Xp>& __c) {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+  // volatile to volatile
+  template <class _Xp>
+  volatile complex& operator=(const volatile complex<_Xp>& __c) volatile {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+
+  template <class _Xp>
+  complex& operator+=(const complex<_Xp>& __c) {
+    __re_ += __c.real();
+    __im_ += __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  complex& operator-=(const complex<_Xp>& __c) {
+    __re_ -= __c.real();
+    __im_ -= __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  complex& operator*=(const complex<_Xp>& __c) {
+    *this = *this * complex(__c.real(), __c.imag());
+    return *this;
+  }
+  template <class _Xp>
+  complex& operator/=(const complex<_Xp>& __c) {
+    *this = *this / complex(__c.real(), __c.imag());
+    return *this;
+  }
+};
+
+template <>
+class complex<double> {
+  double __re_;
+  double __im_;
+
+ public:
+  typedef double value_type;
+
+  constexpr complex(double __re = 0.0, double __im = 0.0)
+      : __re_(__re), __im_(__im) {}
+
+  constexpr complex(const complex<float>& __c);
+
+  // copy volatile to non-volatile
+  constexpr complex(const volatile complex<double>& other)
+      : __re_(other.__re_), __im_(other.__im_) {}
+
+  constexpr complex(const complex<double>& other)
+      : __re_(other.__re_), __im_(other.__im_) {}
+
+  constexpr double real() const {
+    return __re_;
+  }
+  constexpr double imag() const {
+    return __im_;
+  }
+
+  void real(value_type __re) {
+    __re_ = __re;
+  }
+  void imag(value_type __im) {
+    __im_ = __im;
+  }
+
+  constexpr operator bool() const {
+    return real() || imag();
+  }
+
+  complex& operator=(double __re) {
+    __re_ = __re;
+    __im_ = value_type();
+    return *this;
+  }
+  complex& operator+=(double __re) {
+    __re_ += __re;
+    return *this;
+  }
+  complex& operator-=(double __re) {
+    __re_ -= __re;
+    return *this;
+  }
+  complex& operator*=(double __re) {
+    __re_ *= __re;
+    __im_ *= __re;
+    return *this;
+  }
+  complex& operator/=(double __re) {
+    __re_ /= __re;
+    __im_ /= __re;
+    return *this;
+  }
+
+  template <class _Xp>
+  complex& operator=(const complex<_Xp>& __c) {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+
+  // non-volatile to volatile
+  template <class _Xp>
+  volatile complex& operator=(const complex<_Xp>& __c) volatile {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+  // volatile to non-volatile
+  template <class _Xp>
+  complex& operator=(const volatile complex<_Xp>& __c) {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+  // volatile to volatile
+  template <class _Xp>
+  volatile complex& operator=(const volatile complex<_Xp>& __c) volatile {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+
+  template <class _Xp>
+  complex& operator+=(const complex<_Xp>& __c) {
+    __re_ += __c.real();
+    __im_ += __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  complex& operator-=(const complex<_Xp>& __c) {
+    __re_ -= __c.real();
+    __im_ -= __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  complex& operator*=(const complex<_Xp>& __c) {
+    *this = *this * complex(__c.real(), __c.imag());
+    return *this;
+  }
+  template <class _Xp>
+  complex& operator/=(const complex<_Xp>& __c) {
+    *this = *this / complex(__c.real(), __c.imag());
+    return *this;
+  }
+};
+
+inline constexpr complex<float>::complex(const complex<double>& __c)
+    : __re_(__c.real()), __im_(__c.imag()) {}
+
+inline constexpr complex<double>::complex(const complex<float>& __c)
+    : __re_(__c.real()), __im_(__c.imag()) {}
+
+// 26.3.6 operators:
+
+template <class _Tp>
+inline complex<_Tp> operator+(
+    const complex<_Tp>& __x,
+    const complex<_Tp>& __y) {
+  complex<_Tp> __t(__x);
+  __t += __y;
+  return __t;
+}
+
+template <class _Tp>
+inline complex<_Tp> operator+(const complex<_Tp>& __x, const _Tp& __y) {
+  complex<_Tp> __t(__x);
+  __t += __y;
+  return __t;
+}
+
+template <class _Tp>
+inline complex<_Tp> operator+(const _Tp& __x, const complex<_Tp>& __y) {
+  complex<_Tp> __t(__y);
+  __t += __x;
+  return __t;
+}
+
+template <class _Tp>
+inline complex<_Tp> operator-(
+    const complex<_Tp>& __x,
+    const complex<_Tp>& __y) {
+  complex<_Tp> __t(__x);
+  __t -= __y;
+  return __t;
+}
+
+template <class _Tp>
+inline complex<_Tp> operator-(const complex<_Tp>& __x, const _Tp& __y) {
+  complex<_Tp> __t(__x);
+  __t -= __y;
+  return __t;
+}
+
+template <class _Tp>
+inline complex<_Tp> operator-(const _Tp& __x, const complex<_Tp>& __y) {
+  complex<_Tp> __t(-__y);
+  __t += __x;
+  return __t;
+}
+
+template <class _Tp>
+complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w) {
+  _Tp __a = __z.real();
+  _Tp __b = __z.imag();
+  _Tp __c = __w.real();
+  _Tp __d = __w.imag();
+  _Tp __ac = __a * __c;
+  _Tp __bd = __b * __d;
+  _Tp __ad = __a * __d;
+  _Tp __bc = __b * __c;
+  _Tp __x = __ac - __bd;
+  _Tp __y = __ad + __bc;
+  if (isnan(__x) && isnan(__y)) {
+    bool __recalc = false;
+    if (isinf(__a) || isinf(__b)) {
+      __a = copysign(isinf(__a) ? _Tp(1) : _Tp(0), __a);
+      __b = copysign(isinf(__b) ? _Tp(1) : _Tp(0), __b);
+      if (isnan(__c))
+        __c = copysign(_Tp(0), __c);
+      if (isnan(__d))
+        __d = copysign(_Tp(0), __d);
+      __recalc = true;
+    }
+    if (isinf(__c) || isinf(__d)) {
+      __c = copysign(isinf(__c) ? _Tp(1) : _Tp(0), __c);
+      __d = copysign(isinf(__d) ? _Tp(1) : _Tp(0), __d);
+      if (isnan(__a))
+        __a = copysign(_Tp(0), __a);
+      if (isnan(__b))
+        __b = copysign(_Tp(0), __b);
+      __recalc = true;
+    }
+    if (!__recalc &&
+        (isinf(__ac) || isinf(__bd) || isinf(__ad) || isinf(__bc))) {
+      if (isnan(__a))
+        __a = copysign(_Tp(0), __a);
+      if (isnan(__b))
+        __b = copysign(_Tp(0), __b);
+      if (isnan(__c))
+        __c = copysign(_Tp(0), __c);
+      if (isnan(__d))
+        __d = copysign(_Tp(0), __d);
+      __recalc = true;
+    }
+    if (__recalc) {
+      __x = _Tp(INFINITY) * (__a * __c - __b * __d);
+      __y = _Tp(INFINITY) * (__a * __d + __b * __c);
+    }
+  }
+  return complex<_Tp>(__x, __y);
+}
+
+template <class _Tp>
+inline complex<_Tp> operator*(const complex<_Tp>& __x, const _Tp& __y) {
+  complex<_Tp> __t(__x);
+  __t *= __y;
+  return __t;
+}
+
+template <class _Tp>
+inline complex<_Tp> operator*(const _Tp& __x, const complex<_Tp>& __y) {
+  complex<_Tp> __t(__y);
+  __t *= __x;
+  return __t;
+}
+
+template <class _Tp>
+complex<_Tp> operator/(const complex<_Tp>& __z, const complex<_Tp>& __w) {
+  int __ilogbw = 0;
+  _Tp __a = __z.real();
+  _Tp __b = __z.imag();
+  _Tp __c = __w.real();
+  _Tp __d = __w.imag();
+  _Tp __logbw = logb(fmax(fabs(__c), fabs(__d)));
+  if (isfinite(__logbw)) {
+    __ilogbw = static_cast<int>(__logbw);
+    __c = scalbn(__c, -__ilogbw);
+    __d = scalbn(__d, -__ilogbw);
+  }
+  _Tp __denom = __c * __c + __d * __d;
+  _Tp __x = scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
+  _Tp __y = scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
+  if (isnan(__x) && isnan(__y)) {
+    if ((__denom == _Tp(0)) && (!isnan(__a) || !isnan(__b))) {
+      __x = copysign(_Tp(INFINITY), __c) * __a;
+      __y = copysign(_Tp(INFINITY), __c) * __b;
+    } else if ((isinf(__a) || isinf(__b)) && isfinite(__c) && isfinite(__d)) {
+      __a = copysign(isinf(__a) ? _Tp(1) : _Tp(0), __a);
+      __b = copysign(isinf(__b) ? _Tp(1) : _Tp(0), __b);
+      __x = _Tp(INFINITY) * (__a * __c + __b * __d);
+      __y = _Tp(INFINITY) * (__b * __c - __a * __d);
+    } else if (
+        isinf(__logbw) && __logbw > _Tp(0) && isfinite(__a) && isfinite(__b)) {
+      __c = copysign(isinf(__c) ? _Tp(1) : _Tp(0), __c);
+      __d = copysign(isinf(__d) ? _Tp(1) : _Tp(0), __d);
+      __x = _Tp(0) * (__a * __c + __b * __d);
+      __y = _Tp(0) * (__b * __c - __a * __d);
+    }
+  }
+  return complex<_Tp>(__x, __y);
+}
+
+template <class _Tp>
+inline complex<_Tp> operator/(const complex<_Tp>& __x, const _Tp& __y) {
+  return complex<_Tp>(__x.real() / __y, __x.imag() / __y);
+}
+
+template <class _Tp>
+inline complex<_Tp> operator/(const _Tp& __x, const complex<_Tp>& __y) {
+  complex<_Tp> __t(__x);
+  __t /= __y;
+  return __t;
+}
+
+template <class _Tp>
+inline complex<_Tp> operator+(const complex<_Tp>& __x) {
+  return __x;
+}
+
+template <class _Tp>
+inline complex<_Tp> operator-(const complex<_Tp>& __x) {
+  return complex<_Tp>(-__x.real(), -__x.imag());
+}
+
+template <class _Tp>
+inline constexpr bool operator==(
+    const complex<_Tp>& __x,
+    const complex<_Tp>& __y) {
+  return __x.real() == __y.real() && __x.imag() == __y.imag();
+}
+
+template <class _Tp>
+inline constexpr bool operator==(const complex<_Tp>& __x, const _Tp& __y) {
+  return __x.real() == __y && __x.imag() == 0;
+}
+
+template <class _Tp>
+inline constexpr bool operator==(const _Tp& __x, const complex<_Tp>& __y) {
+  return __x == __y.real() && 0 == __y.imag();
+}
+
+template <class _Tp>
+inline constexpr bool operator!=(
+    const complex<_Tp>& __x,
+    const complex<_Tp>& __y) {
+  return !(__x == __y);
+}
+
+template <class _Tp>
+inline constexpr bool operator!=(const complex<_Tp>& __x, const _Tp& __y) {
+  return !(__x == __y);
+}
+
+template <class _Tp>
+inline constexpr bool operator!=(const _Tp& __x, const complex<_Tp>& __y) {
+  return !(__x == __y);
+}
+
+template <class _Tp>
+inline constexpr bool operator&&(
+    const complex<_Tp>& __x,
+    const complex<_Tp>& __y) {
+  return bool(__x) && bool(__y);
+}
+
+template <class _Tp>
+inline constexpr bool isnan(const complex<_Tp>& __x) {
+  return isnan(__x.real()) || isnan(__x.imag());
+}
+
+template <class _Tp>
+inline constexpr bool operator||(
+    const complex<_Tp>& __x,
+    const complex<_Tp>& __y) {
+  return bool(__x) || bool(__y);
+}
+
+// 26.3.7 values:
+
+template <
+    class _Tp,
+    bool = is_integral<_Tp>::value,
+    bool = is_floating_point<_Tp>::value>
+struct __libcpp_complex_overload_traits {};
+
+// Integral Types
+template <class _Tp>
+struct __libcpp_complex_overload_traits<_Tp, true, false> {
+  typedef double _ValueType;
+  typedef complex<double> _ComplexType;
+};
+
+// Floating point types
+template <class _Tp>
+struct __libcpp_complex_overload_traits<_Tp, false, true> {
+  typedef _Tp _ValueType;
+  typedef complex<_Tp> _ComplexType;
+};
+
+// real
+
+template <class _Tp>
+inline constexpr _Tp real(const complex<_Tp>& __c) {
+  return __c.real();
+}
+
+template <class _Tp>
+inline constexpr typename __libcpp_complex_overload_traits<_Tp>::_ValueType real(
+    _Tp __re) {
+  return __re;
+}
+
+// imag
+
+
+template <class _Tp>
+inline constexpr _Tp imag(const complex<_Tp>& __c) {
+  return __c.imag();
+}
+
+template <class _Tp>
+inline constexpr typename __libcpp_complex_overload_traits<_Tp>::_ValueType imag(
+    _Tp) {
+  return 0;
+}
+
+// abs
+
+template <class _Tp>
+inline _Tp abs(const complex<_Tp>& __c) {
+  return hypot(__c.real(), __c.imag());
+}
+
+// arg
+
+template <class _Tp>
+inline _Tp arg(const complex<_Tp>& __c) {
+  return atan2(__c.imag(), __c.real());
+}
+
+template <class _Tp>
+inline typename enable_if<
+    is_integral<_Tp>::value || is_same<_Tp, double>::value,
+    double>::type
+arg(_Tp __re) {
+  return atan2(0., __re);
+}
+
+template <class _Tp>
+inline typename enable_if<is_same<_Tp, float>::value, float>::type arg(
+    _Tp __re) {
+  return atan2f(0.F, __re);
+}
+
+} // namespace std
+
+namespace std {
+
+using ::isfinite;
+using ::isinf;
+using ::isnan;
+using ::signbit;
+
+using ::abs;
+
+using ::acos;
+using ::acosf;
+using ::asin;
+using ::asinf;
+using ::atan;
+using ::atan2;
+using ::atan2f;
+using ::atanf;
+using ::ceil;
+using ::ceilf;
+using ::cos;
+using ::cosf;
+using ::cosh;
+using ::coshf;
+
+using ::exp;
+using ::expf;
+
+using ::fabs;
+using ::fabsf;
+using ::floor;
+using ::floorf;
+
+using ::fmod;
+using ::fmodf;
+
+using ::frexp;
+using ::frexpf;
+using ::ldexp;
+using ::ldexpf;
+
+using ::log;
+using ::logf;
+
+using ::log10;
+using ::log10f;
+using ::modf;
+using ::modff;
+
+using ::pow;
+using ::powf;
+
+using ::sin;
+using ::sinf;
+using ::sinh;
+using ::sinhf;
+
+using ::sqrt;
+using ::sqrtf;
+using ::tan;
+using ::tanf;
+
+using ::tanh;
+using ::tanhf;
+
+using ::acosh;
+using ::acoshf;
+using ::asinh;
+using ::asinhf;
+using ::atanh;
+using ::atanhf;
+using ::cbrt;
+using ::cbrtf;
+
+using ::copysign;
+using ::copysignf;
+
+using ::erf;
+using ::erfc;
+using ::erfcf;
+using ::erff;
+using ::exp2;
+using ::exp2f;
+using ::expm1;
+using ::expm1f;
+using ::fdim;
+using ::fdimf;
+using ::fma;
+using ::fmaf;
+using ::fmax;
+using ::fmaxf;
+using ::fmin;
+using ::fminf;
+using ::hypot;
+using ::hypotf;
+using ::ilogb;
+using ::ilogbf;
+using ::lgamma;
+using ::lgammaf;
+using ::llrint;
+using ::llrintf;
+using ::llround;
+using ::llroundf;
+using ::log1p;
+using ::log1pf;
+using ::log2;
+using ::log2f;
+using ::logb;
+using ::logbf;
+using ::lrint;
+using ::lrintf;
+using ::lround;
+using ::lroundf;
+
+using ::nan;
+using ::nanf;
+
+using ::nearbyint;
+using ::nearbyintf;
+using ::nextafter;
+using ::nextafterf;
+using ::remainder;
+using ::remainderf;
+using ::remquo;
+using ::remquof;
+using ::rint;
+using ::rintf;
+using ::round;
+using ::roundf;
+using ::scalbln;
+using ::scalblnf;
+using ::scalbn;
+using ::scalbnf;
+using ::tgamma;
+using ::tgammaf;
+using ::trunc;
+using ::truncf;
+
+} // namespace std
+
+namespace std {
+
+// norm
+
+template <class _Tp>
+inline _Tp norm(const complex<_Tp>& __c) {
+  if (isinf(__c.real()))
+    return abs(__c.real());
+  if (isinf(__c.imag()))
+    return abs(__c.imag());
+  return __c.real() * __c.real() + __c.imag() * __c.imag();
+}
+
+template <class _Tp>
+inline typename __libcpp_complex_overload_traits<_Tp>::_ValueType norm(
+    _Tp __re) {
+  typedef typename __libcpp_complex_overload_traits<_Tp>::_ValueType _ValueType;
+  return static_cast<_ValueType>(__re) * __re;
+}
+
+// conj
+
+template <class _Tp>
+inline complex<_Tp> conj(const complex<_Tp>& __c) {
+  return complex<_Tp>(__c.real(), -__c.imag());
+}
+
+template <class _Tp>
+inline typename __libcpp_complex_overload_traits<_Tp>::_ComplexType conj(
+    _Tp __re) {
+  typedef
+      typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
+  return _ComplexType(__re);
+}
+
+// proj
+
+template <class _Tp>
+inline complex<_Tp> proj(const complex<_Tp>& __c) {
+  complex<_Tp> __r = __c;
+  if (isinf(__c.real()) || isinf(__c.imag()))
+    __r = complex<_Tp>(INFINITY, copysign(_Tp(0), __c.imag()));
+  return __r;
+}
+
+template <class _Tp>
+inline typename enable_if<
+    is_floating_point<_Tp>::value,
+    typename __libcpp_complex_overload_traits<_Tp>::_ComplexType>::type
+proj(_Tp __re) {
+  if (isinf(__re))
+    __re = abs(__re);
+  return complex<_Tp>(__re);
+}
+
+template <class _Tp>
+inline typename enable_if<
+    is_integral<_Tp>::value,
+    typename __libcpp_complex_overload_traits<_Tp>::_ComplexType>::type
+proj(_Tp __re) {
+  typedef
+      typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
+  return _ComplexType(__re);
+}
+
+// polar
+
+template <class _Tp>
+complex<_Tp> polar(const _Tp& __rho, const _Tp& __theta = _Tp()) {
+  if (isnan(__rho) || signbit(__rho))
+    return complex<_Tp>(_Tp(NAN), _Tp(NAN));
+  if (isnan(__theta)) {
+    if (isinf(__rho))
+      return complex<_Tp>(__rho, __theta);
+    return complex<_Tp>(__theta, __theta);
+  }
+  if (isinf(__theta)) {
+    if (isinf(__rho))
+      return complex<_Tp>(__rho, _Tp(NAN));
+    return complex<_Tp>(_Tp(NAN), _Tp(NAN));
+  }
+  _Tp __x = __rho * cos(__theta);
+  if (isnan(__x))
+    __x = 0;
+  _Tp __y = __rho * sin(__theta);
+  if (isnan(__y))
+    __y = 0;
+  return complex<_Tp>(__x, __y);
+}
+
+// log
+
+template <class _Tp>
+inline complex<_Tp> log(const complex<_Tp>& __x) {
+  return complex<_Tp>(log(abs(__x)), arg(__x));
+}
+
+// log10
+
+template <class _Tp>
+inline complex<_Tp> log10(const complex<_Tp>& __x) {
+  return log(__x) / log(_Tp(10));
+}
+
+// log2
+
+template <class _Tp>
+inline complex<_Tp> log2(const complex<_Tp>& __x) {
+  return log(__x) / log(_Tp(2));
+}
+
+// sqrt
+
+template <class _Tp>
+complex<_Tp> sqrt(const complex<_Tp>& __x) {
+  if (isinf(__x.imag()))
+    return complex<_Tp>(_Tp(INFINITY), __x.imag());
+  if (isinf(__x.real())) {
+    if (__x.real() > _Tp(0))
+      return complex<_Tp>(
+          __x.real(),
+          isnan(__x.imag()) ? __x.imag() : copysign(_Tp(0), __x.imag()));
+    return complex<_Tp>(
+        isnan(__x.imag()) ? __x.imag() : _Tp(0),
+        copysign(__x.real(), __x.imag()));
+  }
+  return polar(sqrt(abs(__x)), arg(__x) / _Tp(2));
+}
+
+// exp
+
+template <class _Tp>
+complex<_Tp> exp(const complex<_Tp>& __x) {
+  _Tp __i = __x.imag();
+  if (__i == 0) {
+    return complex<_Tp>(exp(__x.real()), copysign(_Tp(0), __x.imag()));
+  }
+  if (isinf(__x.real())) {
+    if (__x.real() < _Tp(0)) {
+      if (!isfinite(__i))
+        __i = _Tp(1);
+    } else if (__i == 0 || !isfinite(__i)) {
+      if (isinf(__i))
+        __i = _Tp(NAN);
+      return complex<_Tp>(__x.real(), __i);
+    }
+  }
+  _Tp __e = exp(__x.real());
+  return complex<_Tp>(__e * cos(__i), __e * sin(__i));
+}
+
+// pow
+
+template <class _Tp>
+inline complex<_Tp> pow(const complex<_Tp>& __x, const complex<_Tp>& __y) {
+  return exp(__y * log(__x));
+}
+
+template <class _Tp, class _Up>
+inline complex<typename __promote<_Tp, _Up>::type> pow(
+    const complex<_Tp>& __x,
+    const complex<_Up>& __y) {
+  typedef complex<typename __promote<_Tp, _Up>::type> result_type;
+  return std::pow(result_type(__x), result_type(__y));
+}
+
+template <class _Tp, class _Up>
+inline typename enable_if<
+    is_arithmetic<_Up>::value,
+    complex<typename __promote<_Tp, _Up>::type>>::type
+pow(const complex<_Tp>& __x, const _Up& __y) {
+  typedef complex<typename __promote<_Tp, _Up>::type> result_type;
+  return std::pow(result_type(__x), result_type(__y));
+}
+
+template <class _Tp, class _Up>
+inline typename enable_if<
+    is_arithmetic<_Tp>::value,
+    complex<typename __promote<_Tp, _Up>::type>>::type
+pow(const _Tp& __x, const complex<_Up>& __y) {
+  typedef complex<typename __promote<_Tp, _Up>::type> result_type;
+  return std::pow(result_type(__x), result_type(__y));
+}
+
+// __sqr, computes pow(x, 2)
+
+template <class _Tp>
+inline complex<_Tp> __sqr(const complex<_Tp>& __x) {
+  return complex<_Tp>(
+      (__x.real() - __x.imag()) * (__x.real() + __x.imag()),
+      _Tp(2) * __x.real() * __x.imag());
+}
+
+// asinh
+
+template <class _Tp>
+complex<_Tp> asinh(const complex<_Tp>& __x) {
+  const _Tp __pi(atan2(+0., -0.));
+  if (isinf(__x.real())) {
+    if (isnan(__x.imag()))
+      return __x;
+    if (isinf(__x.imag()))
+      return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
+    return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
+  }
+  if (isnan(__x.real())) {
+    if (isinf(__x.imag()))
+      return complex<_Tp>(__x.imag(), __x.real());
+    if (__x.imag() == 0)
+      return __x;
+    return complex<_Tp>(__x.real(), __x.real());
+  }
+  if (isinf(__x.imag()))
+    return complex<_Tp>(
+        copysign(__x.imag(), __x.real()), copysign(__pi / _Tp(2), __x.imag()));
+  complex<_Tp> __z = log(__x + sqrt(__sqr(__x) + _Tp(1)));
+  return complex<_Tp>(
+      copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
+}
+
+// acosh
+
+template <class _Tp>
+complex<_Tp> acosh(const complex<_Tp>& __x) {
+  const _Tp __pi(atan2(+0., -0.));
+  if (isinf(__x.real())) {
+    if (isnan(__x.imag()))
+      return complex<_Tp>(abs(__x.real()), __x.imag());
+    if (isinf(__x.imag())) {
+      if (__x.real() > 0)
+        return complex<_Tp>(__x.real(), copysign(__pi * _Tp(0.25), __x.imag()));
+      else
+        return complex<_Tp>(
+            -__x.real(), copysign(__pi * _Tp(0.75), __x.imag()));
+    }
+    if (__x.real() < 0)
+      return complex<_Tp>(-__x.real(), copysign(__pi, __x.imag()));
+    return complex<_Tp>(__x.real(), copysign(_Tp(0), __x.imag()));
+  }
+  if (isnan(__x.real())) {
+    if (isinf(__x.imag()))
+      return complex<_Tp>(abs(__x.imag()), __x.real());
+    return complex<_Tp>(__x.real(), __x.real());
+  }
+  if (isinf(__x.imag()))
+    return complex<_Tp>(abs(__x.imag()), copysign(__pi / _Tp(2), __x.imag()));
+  complex<_Tp> __z = log(__x + sqrt(__sqr(__x) - _Tp(1)));
+  return complex<_Tp>(
+      copysign(__z.real(), _Tp(0)), copysign(__z.imag(), __x.imag()));
+}
+
+// atanh
+
+template <class _Tp>
+complex<_Tp> atanh(const complex<_Tp>& __x) {
+  const _Tp __pi(atan2(+0., -0.));
+  if (isinf(__x.imag())) {
+    return complex<_Tp>(
+        copysign(_Tp(0), __x.real()), copysign(__pi / _Tp(2), __x.imag()));
+  }
+  if (isnan(__x.imag())) {
+    if (isinf(__x.real()) || __x.real() == 0)
+      return complex<_Tp>(copysign(_Tp(0), __x.real()), __x.imag());
+    return complex<_Tp>(__x.imag(), __x.imag());
+  }
+  if (isnan(__x.real())) {
+    return complex<_Tp>(__x.real(), __x.real());
+  }
+  if (isinf(__x.real())) {
+    return complex<_Tp>(
+        copysign(_Tp(0), __x.real()), copysign(__pi / _Tp(2), __x.imag()));
+  }
+  if (abs(__x.real()) == _Tp(1) && __x.imag() == _Tp(0)) {
+    return complex<_Tp>(
+        copysign(_Tp(INFINITY), __x.real()), copysign(_Tp(0), __x.imag()));
+  }
+  complex<_Tp> __z = log((_Tp(1) + __x) / (_Tp(1) - __x)) / _Tp(2);
+  return complex<_Tp>(
+      copysign(__z.real(), __x.real()), copysign(__z.imag(), __x.imag()));
+}
+
+// sinh
+
+template <class _Tp>
+complex<_Tp> sinh(const complex<_Tp>& __x) {
+  if (isinf(__x.real()) && !isfinite(__x.imag()))
+    return complex<_Tp>(__x.real(), _Tp(NAN));
+  if (__x.real() == 0 && !isfinite(__x.imag()))
+    return complex<_Tp>(__x.real(), _Tp(NAN));
+  if (__x.imag() == 0 && !isfinite(__x.real()))
+    return __x;
+  return complex<_Tp>(
+      sinh(__x.real()) * cos(__x.imag()), cosh(__x.real()) * sin(__x.imag()));
+}
+
+// cosh
+
+template <class _Tp>
+complex<_Tp> cosh(const complex<_Tp>& __x) {
+  if (isinf(__x.real()) && !isfinite(__x.imag()))
+    return complex<_Tp>(abs(__x.real()), _Tp(NAN));
+  if (__x.real() == 0 && !isfinite(__x.imag()))
+    return complex<_Tp>(_Tp(NAN), __x.real());
+  if (__x.real() == 0 && __x.imag() == 0)
+    return complex<_Tp>(_Tp(1), __x.imag());
+  if (__x.imag() == 0 && !isfinite(__x.real()))
+    return complex<_Tp>(abs(__x.real()), __x.imag());
+  return complex<_Tp>(
+      cosh(__x.real()) * cos(__x.imag()), sinh(__x.real()) * sin(__x.imag()));
+}
+
+// tanh
+
+template <class _Tp>
+complex<_Tp> tanh(const complex<_Tp>& __x) {
+  if (isinf(__x.real())) {
+    if (!isfinite(__x.imag()))
+      return complex<_Tp>(copysign(_Tp(1), __x.real()), _Tp(0));
+    return complex<_Tp>(
+        copysign(_Tp(1), __x.real()),
+        copysign(_Tp(0), sin(_Tp(2) * __x.imag())));
+  }
+  if (isnan(__x.real()) && __x.imag() == 0)
+    return __x;
+  _Tp __2r(_Tp(2) * __x.real());
+  _Tp __2i(_Tp(2) * __x.imag());
+  _Tp __d(cosh(__2r) + cos(__2i));
+  _Tp __2rsh(sinh(__2r));
+  if (isinf(__2rsh) && isinf(__d))
+    return complex<_Tp>(
+        __2rsh > _Tp(0) ? _Tp(1) : _Tp(-1), __2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
+  return complex<_Tp>(__2rsh / __d, sin(__2i) / __d);
+}
+
+// asin
+
+template <class _Tp>
+complex<_Tp> asin(const complex<_Tp>& __x) {
+  complex<_Tp> __z = asinh(complex<_Tp>(-__x.imag(), __x.real()));
+  return complex<_Tp>(__z.imag(), -__z.real());
+}
+
+// acos
+
+template <class _Tp>
+complex<_Tp> acos(const complex<_Tp>& __x) {
+  const _Tp __pi(atan2(+0., -0.));
+  if (isinf(__x.real())) {
+    if (isnan(__x.imag()))
+      return complex<_Tp>(__x.imag(), __x.real());
+    if (isinf(__x.imag())) {
+      if (__x.real() < _Tp(0))
+        return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
+      return complex<_Tp>(_Tp(0.25) * __pi, -__x.imag());
+    }
+    if (__x.real() < _Tp(0))
+      return complex<_Tp>(__pi, signbit(__x.imag()) ? -__x.real() : __x.real());
+    return complex<_Tp>(_Tp(0), signbit(__x.imag()) ? __x.real() : -__x.real());
+  }
+  if (isnan(__x.real())) {
+    if (isinf(__x.imag()))
+      return complex<_Tp>(__x.real(), -__x.imag());
+    return complex<_Tp>(__x.real(), __x.real());
+  }
+  if (isinf(__x.imag()))
+    return complex<_Tp>(__pi / _Tp(2), -__x.imag());
+  if (__x.real() == 0 && (__x.imag() == 0 || isnan(__x.imag())))
+    return complex<_Tp>(__pi / _Tp(2), -__x.imag());
+  complex<_Tp> __z = log(__x + sqrt(__sqr(__x) - _Tp(1)));
+  if (signbit(__x.imag()))
+    return complex<_Tp>(abs(__z.imag()), abs(__z.real()));
+  return complex<_Tp>(abs(__z.imag()), -abs(__z.real()));
+}
+
+// atan
+
+template <class _Tp>
+complex<_Tp> atan(const complex<_Tp>& __x) {
+  complex<_Tp> __z = atanh(complex<_Tp>(-__x.imag(), __x.real()));
+  return complex<_Tp>(__z.imag(), -__z.real());
+}
+
+// sin
+
+template <class _Tp>
+complex<_Tp> sin(const complex<_Tp>& __x) {
+  complex<_Tp> __z = sinh(complex<_Tp>(-__x.imag(), __x.real()));
+  return complex<_Tp>(__z.imag(), -__z.real());
+}
+
+// cos
+
+template <class _Tp>
+inline complex<_Tp> cos(const complex<_Tp>& __x) {
+  return cosh(complex<_Tp>(-__x.imag(), __x.real()));
+}
+
+// tan
+
+template <class _Tp>
+complex<_Tp> tan(const complex<_Tp>& __x) {
+  complex<_Tp> __z = tanh(complex<_Tp>(-__x.imag(), __x.real()));
+  return complex<_Tp>(__z.imag(), -__z.real());
+}
+
+// Literal suffix for complex number literals [complex.literals]
+inline namespace literals {
+inline namespace complex_literals {
+constexpr complex<double> operator""i(long double __im) {
+  return {0.0, static_cast<double>(__im)};
+}
+
+constexpr complex<double> operator""i(unsigned long long __im) {
+  return {0.0, static_cast<double>(__im)};
+}
+
+constexpr complex<float> operator""if(long double __im) {
+  return {0.0f, static_cast<float>(__im)};
+}
+
+constexpr complex<float> operator""if(unsigned long long __im) {
+  return {0.0f, static_cast<float>(__im)};
+}
+} // namespace complex_literals
+} // namespace literals
+
+} // namespace std
+
+__device__ std::complex<double> lerp(
+    std::complex<double> start,
+    std::complex<double> end,
+    std::complex<double> weight) {
+  if (abs(weight) < 0.5) {
+    return start + weight * (end - start);
+  } else {
+    return end - (end - start) * (1.0 - weight);
+  }
+}
+
+__device__ std::complex<float> lerp(
+    std::complex<float> start,
+    std::complex<float> end,
+    std::complex<float> weight) {
+  if (abs(weight) < 0.5f) {
+    return start + weight * (end - start);
+  } else {
+
+    return end - (end - start) * (1.0f - weight);
+  }
+}
+
+__device__ std::complex<double> reciprocal(std::complex<double> x) {
+  return 1.0 / x;
+}
+
+__device__ std::complex<float> reciprocal(std::complex<float> x) {
+  return 1.0f / x;
+}
+
+__device__ std::complex<double> sigmoid(std::complex<double> x) {
+  return 1.0 / (1.0 + exp(-x));
+}
+
+__device__ std::complex<float> sigmoid(std::complex<float> x) {
+  return 1.0f / (1.0f + exp(-x));
+}
+
+// The reciprocal of a complex number z is
+//    1/z = conj(z)/|z|^2.
+// The principal square root of a complex number z can be obtained by [1]
+//    sqrt(z) = sqrt(|z|) (z + |z|) / |z + |z||.
+// Combining these formulas we have
+//    1/sqrt(z) = (conj(z) + |z|) / (sqrt(|z|) |z + |z||).
+// [1] https://math.stackexchange.com/a/44500
+__device__ std::complex<float> rsqrt(std::complex<float> z) {
+  auto a = std::real(z);
+  auto b = std::imag(z);
+  auto absa = ::fabsf(a);
+  auto absb = ::fabsf(b);
+  // scale to avoid precision loss due to underflow/overflow
+  auto scale = fmax(absa, absb);
+  a /= scale;
+  b /= scale;
+  auto a_sq = a * a;
+  auto b_sq = b * b;
+  auto modz_sq = a_sq + b_sq;
+  auto modz = ::sqrtf(modz_sq);
+  auto a_plus_modz = a + modz;
+  auto mod_zplusmodz_sq = a_plus_modz * a_plus_modz + b_sq;
+  auto fac = ::rsqrtf(scale * modz * mod_zplusmodz_sq);
+  return std::complex<float>(a_plus_modz * fac, -b * fac);
+}
+
+__device__ std::complex<double> rsqrt(std::complex<double> z) {
+  auto a = std::real(z);
+  auto b = std::imag(z);
+  auto absa = ::abs(a);
+  auto absb = ::abs(b);
+  // scale to avoid precision loss due to underflow/overflow
+  auto scale = fmax(absa, absb);
+  a /= scale;
+  b /= scale;
+  auto a_sq = a * a;
+  auto b_sq = b * b;
+  auto modz_sq = a_sq + b_sq;
+  auto modz = ::sqrt(modz_sq);
+  auto a_plus_modz = a + modz;
+  auto mod_zplusmodz_sq = a_plus_modz * a_plus_modz + b_sq;
+  auto fac = ::rsqrt(scale * modz * mod_zplusmodz_sq);
+  return std::complex<double>(a_plus_modz * fac, -b * fac);
+}
+
+template <typename T>
+bool isfinite(std::complex<T> x) {
+  return ::isfinite(std::real(x)) && ::isfinite(std::imag(x));
+}
+
+template <typename T>
+bool isinf(std::complex<T> x) {
+  return ::isinf(std::real(x)) || ::isinf(std::imag(x));
+}
+
+template <typename T>
+bool isreal(std::complex<T> x) {
+  return std::imag(x) == 0;
+}
+#endif // __NVCC__
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+
+#define __NVFUSER_HALF_TO_US(var) *(reinterpret_cast<unsigned short*>(&(var)))
+#define __NVFUSER_HALF_TO_CUS(var) \
+  *(reinterpret_cast<const unsigned short*>(&(var)))
+
+struct __half;
+__device__ __inline__ __half __float2half(const float);
+
+struct __align__(2) __half {
+  __half() = default;
+
+  __half(const __half& other) {
+    __x = other.__x;
+  }
+
+  __half(const __half&& other) {
+    __x = other.__x;
+  }
+
+  __half(const volatile __half& other) {
+    __x = other.__x;
+  }
+
+  __half(const volatile __half&& other) {
+    __x = other.__x;
+  }
+
+  // Note: not returning reference for `__half::operator=`
+  // Doing so would requires us to return `volatile __half&` for the volatile
+  // variants, which would trigger a gcc warning `implicit dereference will not
+  // access object of type ‘volatile S’ in statement`
+  __device__ void operator=(const __half& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __half&& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __half& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __half&& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __half& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __half&& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __half& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __half&& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ __half(const float f) {
+    __x = __float2half(f).__x;
+  }
+
+  __device__ uint16_t raw() const {
+    return __x;
+  }
+
+ protected:
+  unsigned short __x;
+};
+
+__device__ __inline__ __half __float2half(const float f) {
+  __half val;
+  asm("{  cvt.rn.f16.f32 %0, %1;}\n"
+      : "=h"(__NVFUSER_HALF_TO_US(val))
+      : "f"(f));
+  return val;
+}
+
+__device__ __inline__ __half __double2half(const double d) {
+  __half val;
+  asm("{  cvt.rn.f16.f64 %0, %1;}\n"
+      : "=h"(__NVFUSER_HALF_TO_US(val))
+      : "d"(d));
+  return val;
+}
+
+__device__ __inline__ __half __int2half(const int i) {
+  __half val;
+  asm("{  cvt.rn.f16.s32 %0, %1;}\n"
+      : "=h"(__NVFUSER_HALF_TO_US(val))
+      : "r"(i));
+  return val;
+}
+
+__device__ __inline__ __half __int2half(const int64_t i64) {
+  __half val;
+  asm("{  cvt.rn.f16.s64 %0, %1;}\n"
+      : "=h"(__NVFUSER_HALF_TO_US(val))
+      : "l"(i64));
+  return val;
+}
+
+__device__ __inline__ __half __int2half(const uint32_t i) {
+  __half val;
+  asm("{  cvt.rn.f16.u32 %0, %1;}\n"
+      : "=h"(__NVFUSER_HALF_TO_US(val))
+      : "r"(i));
+  return val;
+}
+
+__device__ __inline__ __half __int2half(const uint64_t i64) {
+  __half val;
+  asm("{  cvt.rn.f16.u64 %0, %1;}\n"
+      : "=h"(__NVFUSER_HALF_TO_US(val))
+      : "l"(i64));
+  return val;
+}
+
+__device__ __inline__ __half __bool2half(const bool b) {
+  return __int2half((int)b);
+}
+
+__device__ __inline__ float __half2float(const __half h) {
+  float val;
+  asm("{  cvt.f32.f16 %0, %1;}\n" : "=f"(val) : "h"(__NVFUSER_HALF_TO_CUS(h)));
+  return val;
+}
+
+__device__ __inline__ double __half2double(const __half h) {
+  double val;
+  asm("{  cvt.f64.f16 %0, %1;}\n" : "=d"(val) : "h"(__NVFUSER_HALF_TO_CUS(h)));
+  return val;
+}
+
+__device__ int __half2int32(const __half h) {
+  int val;
+  asm("{  cvt.rzi.s32.f16 %0, %1;}\n"
+      : "=r"(val)
+      : "h"(__NVFUSER_HALF_TO_CUS(h)));
+  return val;
+}
+
+__device__ __inline__ int64_t __half2int(const __half h) {
+  int64_t val;
+  asm("{  cvt.rzi.s64.f16 %0, %1;}\n"
+      : "=l"(val)
+      : "h"(__NVFUSER_HALF_TO_CUS(h)));
+  return val;
+}
+
+__device__ int __half2uint32(const __half h) {
+  int val;
+  asm("{  cvt.rzi.u32.f16 %0, %1;}\n"
+      : "=r"(val)
+      : "h"(__NVFUSER_HALF_TO_CUS(h)));
+  return val;
+}
+
+__device__ __inline__ int64_t __half2uint(const __half h) {
+  int64_t val;
+  asm("{  cvt.rzi.u64.f16 %0, %1;}\n"
+      : "=l"(val)
+      : "h"(__NVFUSER_HALF_TO_CUS(h)));
+  return val;
+}
+
+__device__ __inline__ void __half2int(const __half h, int& output) {
+  output = __half2int32(h);
+}
+
+__device__ __inline__ void __half2int(const __half h, int64_t& output) {
+  output = __half2int(h);
+}
+
+__device__ __inline__ void __half2int(const __half h, uint32_t& output) {
+  output = __half2uint32(h);
+}
+
+__device__ __inline__ void __half2int(const __half h, uint64_t& output) {
+  output = __half2uint(h);
+}
+
+__device__ __inline__ nvfuser_index_t __half2index(const __half h) {
+  nvfuser_index_t result;
+  __half2int(h, result);
+  return result;
+}
+
+__device__ __inline__ bool __half2bool(const __half h) {
+  return (bool)__half2float(h) != 0;
+}
+
+__device__ __inline__ __half __real_then_2half(const std::complex<float> c) {
+  return __float2half(std::real(c));
+}
+
+__device__ __inline__ __half __real_then_2half(const std::complex<double> c) {
+  return __double2half(std::real(c));
+}
+
+__device__ __inline__ bool __heq(const __half a, const __half b) {
+  // From cuda_fp16.hpp
+  unsigned short val;
+  asm("{ .reg .pred __$temp3;\n"
+      "  setp.eq.f16  __$temp3, %1, %2;\n"
+      "  selp.u16 %0, 1, 0, __$temp3;}"
+      : "=h"(val)
+      : "h"(__NVFUSER_HALF_TO_CUS(a)), "h"(__NVFUSER_HALF_TO_CUS(b)));
+  return (val != 0U) ? true : false;
+}
+
+__device__ __inline__ __half operator|(const __half x, const __half y) {
+  __half val;
+  asm("{  or.b16 %0, %1, %2;}\n"
+      : "=h"(__NVFUSER_HALF_TO_US(val))
+      : "h"(__NVFUSER_HALF_TO_CUS(x)), "h"(__NVFUSER_HALF_TO_CUS(y)));
+  return val;
+}
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+
+#define __NVFUSER_BFLOAT_TO_US(var) *(reinterpret_cast<unsigned short*>(&(var)))
+#define __NVFUSER_BFLOAT_TO_CUS(var) \
+  *(reinterpret_cast<const unsigned short*>(&(var)))
+
+struct __bfloat;
+__device__ __inline__ __bfloat __float2bfloat(const float);
+
+struct __align__(2) __bfloat {
+  __bfloat() = default;
+
+  __bfloat(const __bfloat& other) {
+    __x = other.__x;
+  }
+
+  __bfloat(const __bfloat&& other) {
+    __x = other.__x;
+  }
+
+  __bfloat(const volatile __bfloat& other) {
+    __x = other.__x;
+  }
+
+  __bfloat(const volatile __bfloat&& other) {
+    __x = other.__x;
+  }
+
+  // Note: not returning reference for `__bfloat::operator=`
+  // Doing so would requires us to return `volatile __bfloat&` for the volatile
+  // variants, which would trigger a gcc warning `implicit dereference will not
+  // access object of type ‘volatile S’ in statement`
+  __device__ void operator=(const __bfloat& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __bfloat&& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __bfloat& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __bfloat&& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __bfloat& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __bfloat&& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __bfloat& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __bfloat&& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ __bfloat(const float f) {
+    __x = __float2bfloat(f).__x;
+  }
+
+  __device__ uint16_t raw() const {
+    return __x;
+  }
+
+ protected:
+  unsigned short __x;
+};
+
+__device__ __inline__ __bfloat __float2bfloat(const float f) {
+  __bfloat val;
+  asm("{  cvt.rn.bf16.f32 %0, %1;}\n"
+      : "=h"(__NVFUSER_BFLOAT_TO_US(val))
+      : "f"(f));
+  return val;
+}
+
+__device__ __inline__ __bfloat __double2bfloat(const double d) {
+#if __CUDA_ARCH__ >= 900
+  __bfloat val;
+  asm("{  cvt.rn.bf16.f64 %0, %1;}\n"
+      : "=h"(__NVFUSER_BFLOAT_TO_US(val))
+      : "d"(d));
+  return val;
+#else
+  return __float2bfloat(static_cast<float>(d));
+#endif
+}
+
+__device__ __inline__ __bfloat __int2bfloat(const int i) {
+#if __CUDA_ARCH__ >= 900
+  __bfloat val;
+  asm("{  cvt.rn.bf16.s32 %0, %1;}\n"
+      : "=h"(__NVFUSER_BFLOAT_TO_US(val))
+      : "r"(i));
+  return val;
+#else
+  return __float2bfloat(static_cast<float>(i));
+#endif
+}
+
+__device__ __inline__ __bfloat __int2bfloat(const int64_t i64) {
+#if __CUDA_ARCH__ >= 900
+  __bfloat val;
+  asm("{  cvt.rn.bf16.s64 %0, %1;}\n"
+      : "=h"(__NVFUSER_BFLOAT_TO_US(val))
+      : "l"(i64));
+  return val;
+#else
+  return __float2bfloat(static_cast<float>(i64));
+#endif
+}
+
+__device__ __inline__ __bfloat __int2bfloat(const uint32_t i) {
+#if __CUDA_ARCH__ >= 900
+  __bfloat val;
+  asm("{  cvt.rn.bf16.u32 %0, %1;}\n"
+      : "=h"(__NVFUSER_BFLOAT_TO_US(val))
+      : "r"(i));
+  return val;
+#else
+  return __float2bfloat(static_cast<float>(i));
+#endif
+}
+
+__device__ __inline__ __bfloat __int2bfloat(const uint64_t i64) {
+#if __CUDA_ARCH__ >= 900
+  __bfloat val;
+  asm("{  cvt.rn.bf16.u64 %0, %1;}\n"
+      : "=h"(__NVFUSER_BFLOAT_TO_US(val))
+      : "l"(i64));
+  return val;
+#else
+  return __float2bfloat(static_cast<float>(i64));
+#endif
+}
+
+__device__ __inline__ __bfloat __bool2bfloat(const bool b) {
+  return __int2bfloat((int)b);
+}
+
+__device__ __inline__ float __bfloat2float(const __bfloat h) {
+  float val;
+  asm("{  mov.b32 %0, {0,%1};}\n"
+      : "=f"(val)
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(h)));
+  return val;
+}
+
+__device__ __inline__ double __bfloat2double(const __bfloat h) {
+#if __CUDA_ARCH__ >= 900
+  double val;
+  asm("{  cvt.f64.bf16 %0, %1;}\n"
+      : "=d"(val)
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(h)));
+  return val;
+#else
+  return static_cast<double>(__bfloat2float(h));
+#endif
+}
+
+__device__ int __bfloat2int32(const __bfloat h) {
+#if __CUDA_ARCH__ >= 900
+  int val;
+  asm("{  cvt.rzi.s32.bf16 %0, %1;}\n"
+      : "=r"(val)
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(h)));
+  return val;
+#else
+  return static_cast<int>(__bfloat2float(h));
+#endif
+}
+
+__device__ __inline__ int64_t __bfloat2int(const __bfloat h) {
+#if __CUDA_ARCH__ >= 900
+  int64_t val;
+  asm("{  cvt.rzi.s64.bf16 %0, %1;}\n"
+      : "=l"(val)
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(h)));
+  return val;
+#else
+  return static_cast<int64_t>(__bfloat2float(h));
+#endif
+}
+
+__device__ int __bfloat2uint32(const __bfloat h) {
+#if __CUDA_ARCH__ >= 900
+  int val;
+  asm("{  cvt.rzi.u32.bf16 %0, %1;}\n"
+      : "=r"(val)
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(h)));
+  return val;
+#else
+  return static_cast<int>(__bfloat2float(h));
+#endif
+}
+
+__device__ __inline__ int64_t __bfloat2uint(const __bfloat h) {
+#if __CUDA_ARCH__ >= 900
+  int64_t val;
+  asm("{  cvt.rzi.u64.bf16 %0, %1;}\n"
+      : "=l"(val)
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(h)));
+  return val;
+#else
+  return static_cast<int64_t>(__bfloat2float(h));
+#endif
+}
+
+__device__ __inline__ void __bfloat2int(const __bfloat h, int& output) {
+  output = __bfloat2int32(h);
+}
+
+__device__ __inline__ void __bfloat2int(const __bfloat h, int64_t& output) {
+  output = __bfloat2int(h);
+}
+
+__device__ __inline__ void __bfloat2int(const __bfloat h, uint32_t& output) {
+  output = __bfloat2uint32(h);
+}
+
+__device__ __inline__ void __bfloat2int(const __bfloat h, uint64_t& output) {
+  output = __bfloat2uint(h);
+}
+
+__device__ __inline__ nvfuser_index_t __bfloat2index(
+    const __bfloat h,
+    bool& output) {
+  nvfuser_index_t result;
+  __bfloat2int(h, result);
+  return result;
+}
+
+__device__ __inline__ bool __bfloat2bool(const __bfloat h) {
+  return (bool)__bfloat2float(h) != 0;
+}
+
+__device__ __inline__ __bfloat __half2bfloat(const __half h) {
+#if __CUDA_ARCH__ >= 900
+  __bfloat val;
+  asm("{  cvt.rn.bf16.f16 %0, %1;}\n"
+      : "=h"(__NVFUSER_BFLOAT_TO_US(val))
+      : "h"(__NVFUSER_HALF_TO_CUS(h)));
+  return val;
+#else
+  return __float2bfloat(__half2float(h));
+#endif
+}
+
+__device__ __inline__ __half __bfloat2half(const __bfloat h) {
+#if __CUDA_ARCH__ >= 900
+  __half val;
+  asm("{  cvt.rn.f16.bf16 %0, %1;}\n"
+      : "=h"(__NVFUSER_HALF_TO_US(val))
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(h)));
+  return val;
+#else
+  return __float2half(__bfloat2float(h));
+#endif
+}
+
+__device__ __inline__ __bfloat __real_then_2bfloat(
+    const std::complex<float> c) {
+  return __float2bfloat(std::real(c));
+}
+
+__device__ __inline__ __bfloat __real_then_2bfloat(
+    const std::complex<double> c) {
+  return __double2bfloat(std::real(c));
+}
+
+__device__ __inline__ bool __heq(const __bfloat a, const __bfloat b) {
+// From cuda_bf16.hpp
+#if __CUDA_ARCH__ >= 900
+  unsigned short val;
+  asm("{ .reg .pred __$temp3;\n"
+      "  setp.eq.bf16  __$temp3, %1, %2;\n"
+      "  selp.u16 %0, 1, 0, __$temp3;}"
+      : "=h"(val)
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(a)), "h"(__NVFUSER_BFLOAT_TO_CUS(b)));
+#else
+  unsigned int val;
+  asm("{.reg .b32 a,b;\n"
+      "  mov.b32 a, {0, %1};\n"
+      "  mov.b32 b, {0, %2};\n"
+      "  set.eq.f32.f32 %0, a, b;}\n"
+      : "=r"(val)
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(a)), "h"(__NVFUSER_BFLOAT_TO_CUS(b)));
+#endif
+  return (val != 0U) ? true : false;
+}
+
+__device__ __inline__ __bfloat operator|(const __bfloat x, const __bfloat y) {
+  __bfloat val;
+  asm("{  or.b16 %0, %1, %2;}\n"
+      : "=h"(__NVFUSER_BFLOAT_TO_US(val))
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(x)), "h"(__NVFUSER_BFLOAT_TO_CUS(y)));
+  return val;
+}
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+
+struct __e4m3;
+__device__ __inline__ __e4m3 __float2e4m3(const float);
+__device__ __inline__ __e4m3 __double2e4m3(const double);
+
+struct __align__(1) __e4m3 {
+  __e4m3() = default;
+
+  __e4m3(const __e4m3& other) {
+    __x = other.__x;
+  }
+
+  __e4m3(const __e4m3&& other) {
+    __x = other.__x;
+  }
+
+  __e4m3(const volatile __e4m3& other) {
+    __x = other.__x;
+  }
+
+  __e4m3(const volatile __e4m3&& other) {
+    __x = other.__x;
+  }
+
+  // Note: not returning reference for `__e4m3::operator=`
+  // Doing so would requires us to return `volatile __e4m3&` for the volatile
+  // variants, which would trigger a gcc warning `implicit dereference will not
+  // access object of type ‘volatile S’ in statement`
+  __device__ void operator=(const __e4m3& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __e4m3&& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __e4m3& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __e4m3&& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __e4m3& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __e4m3&& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __e4m3& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __e4m3&& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ __e4m3(const float f) {
+    __x = __float2e4m3(f).__x;
+  }
+
+  __device__ __e4m3(const double f) {
+    __x = __double2e4m3(f).__x;
+  }
+
+  __device__ __e4m3(const int x) : __x(x) {}
+
+  __device__ __e4m3(const long long x) : __x(x) {}
+
+  __device__ __e4m3(const uint8_t x) : __x(x) {}
+
+  __device__ __e4m3(const uint16_t x) : __x(x) {}
+
+  __device__ uint8_t raw() const {
+    return __x;
+  }
+
+ protected:
+  uint8_t __x;
+};
+
+__device__ __inline__ __e4m3 __double2e4m3(const double f) {
+  unsigned short _tmp_buffer;
+  __e4m3 val;
+  asm("{\n\t"
+      ".reg .b16 buf0;\n\t"
+      ".reg .b32 buf1;\n\t"
+      "cvt.rn.f16.f64 buf0, %1;\n\t"
+      "cvt.u32.u16 buf1, buf0;\n\t"
+      "cvt.rn.satfinite.e4m3x2.f16x2 %0, buf1;\n\t"
+      "}"
+      : "=h"(_tmp_buffer)
+      : "d"(f));
+  memcpy(&val, &_tmp_buffer, sizeof(uint8_t));
+  return val;
+}
+
+__device__ __inline__ double __e4m32double(const __e4m3 h) {
+  unsigned short _tmp_buffer;
+  memcpy(&_tmp_buffer, &h, sizeof(uint8_t));
+  double val;
+  asm("{\n\t"
+      ".reg .b32 buf0;\n\t"
+      "cvt.rn.f16x2.e4m3x2 buf0, %1;\n\t"
+      "cvt.u16.u32 %1, buf0;\n\t"
+      "cvt.f64.f16 %0, %1;"
+      "}"
+      : "=d"(val)
+      : "h"(_tmp_buffer));
+
+  return val;
+}
+
+__device__ __inline__ __e4m3 __float2e4m3(const float f) {
+  constexpr float f_const_zero = 0.f;
+  unsigned short _tmp_buffer;
+  __e4m3 val;
+  asm("{cvt.rn.satfinite.e4m3x2.f32 %0, %1, %2;}"
+      : "=h"(_tmp_buffer)
+      : "f"(f_const_zero), "f"(f));
+  memcpy(&val, &_tmp_buffer, sizeof(uint8_t));
+
+  return val;
+}
+
+__device__ __inline__ float __e4m32float(const __e4m3 h) {
+  unsigned short _tmp_buffer;
+  memcpy(&_tmp_buffer, &h, sizeof(uint8_t));
+  float val;
+  asm("{\n\t"
+      ".reg .b32 buf0;\n\t"
+      "cvt.rn.f16x2.e4m3x2 buf0, %1;\n\t"
+      "cvt.u16.u32 %1, buf0;\n\t"
+      "cvt.f32.f16 %0, %1;\n\t"
+      "}"
+      : "=f"(val)
+      : "h"(_tmp_buffer));
+
+  return val;
+}
+
+__device__ __inline__ __e4m3 __half2e4m3(const __half h) {
+  uint32_t buffer;
+  memcpy(&buffer, &h, sizeof(__half));
+  unsigned short _tmp_buffer;
+  __e4m3 val;
+  asm("{cvt.rn.satfinite.e4m3x2.f16x2 %0, %1;}\n\t"
+      : "=h"(_tmp_buffer)
+      : "r"(buffer));
+  memcpy(&val, &_tmp_buffer, sizeof(uint8_t));
+
+  return val;
+}
+
+__device__ __inline__ __half __e4m32half(const __e4m3 h) {
+  unsigned short _tmp_buffer;
+  memcpy(&_tmp_buffer, &h, sizeof(uint8_t));
+  __half val;
+  asm("{\n\t"
+      ".reg .b32 buf0;\n\t"
+      "cvt.rn.f16x2.e4m3x2 buf0, %1;\n\t"
+      "cvt.u16.u32 %0, buf0;\n\t"
+      "}"
+      : "=h"(__NVFUSER_HALF_TO_US(val))
+      : "h"(_tmp_buffer));
+
+  return val;
+}
+
+__device__ __inline__ __e4m3 __bfloat2e4m3(const __bfloat h) {
+  unsigned short _tmp_buffer;
+  __e4m3 val;
+  asm("{\n\t"
+      ".reg .b32 buf0;\n\t"
+      "cvt.rn.f16.bf16 %1, %1;\n\t"
+      "cvt.u32.u16 buf0, %1;\n\t"
+      "cvt.rn.satfinite.e4m3x2.f16x2 %0, buf0;\n\t"
+      "}"
+      : "=h"(_tmp_buffer)
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(h)));
+  memcpy(&val, &_tmp_buffer, sizeof(uint8_t));
+  return val;
+}
+
+__device__ __inline__ __bfloat __e4m32bfloat(const __e4m3 h) {
+  unsigned short _tmp_buffer;
+  memcpy(&_tmp_buffer, &h, sizeof(uint8_t));
+  __bfloat val;
+  asm("{\n\t"
+      ".reg .b32 buf0;\n\t"
+      "cvt.rn.f16x2.e4m3x2 buf0, %1;\n\t"
+      "cvt.u16.u32 %0, buf0;\n\t"
+      "cvt.bf16.f16 %0, %0;\n\t"
+      "}"
+      : "=h"(__NVFUSER_BFLOAT_TO_US(val))
+      : "h"(_tmp_buffer));
+
+  return val;
+}
+
+__device__ __inline__ __e4m3 operator|(const __e4m3 x, const __e4m3 y) {
+  unsigned short val;
+  unsigned short x_val = x.raw();
+  unsigned short y_val = y.raw();
+  asm("{  or.b16 %0, %1, %2;}\n" : "=h"(val) : "h"(x_val), "h"(y_val));
+  return __e4m3(val);
+}
+
+struct __e5m2;
+__device__ __inline__ __e5m2 __float2e5m2(const float);
+__device__ __inline__ __e5m2 __double2e5m2(const double);
+
+struct __align__(1) __e5m2 {
+  __e5m2() = default;
+
+  __e5m2(const __e5m2& other) {
+    __x = other.__x;
+  }
+
+  __e5m2(const __e5m2&& other) {
+    __x = other.__x;
+  }
+
+  __e5m2(const volatile __e5m2& other) {
+    __x = other.__x;
+  }
+
+  __e5m2(const volatile __e5m2&& other) {
+    __x = other.__x;
+  }
+
+  // Note: not returning reference for `__e5m2::operator=`
+  // Doing so would requires us to return `volatile __e5m2&` for the volatile
+  // variants, which would trigger a gcc warning `implicit dereference will not
+  // access object of type ‘volatile S’ in statement`
+  __device__ void operator=(const __e5m2& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __e5m2&& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __e5m2& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __e5m2&& other) {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __e5m2& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const __e5m2&& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __e5m2& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ void operator=(const volatile __e5m2&& other) volatile {
+    __x = other.__x;
+  }
+
+  __device__ __e5m2(const float f) {
+    __x = __float2e5m2(f).__x;
+  }
+
+  __device__ __e5m2(const double f) {
+    __x = __double2e5m2(f).__x;
+  }
+
+  __device__ __e5m2(const int x) : __x(x) {}
+
+  __device__ __e5m2(const long long x) : __x(x) {}
+
+  __device__ __e5m2(const uint8_t x) : __x(x) {}
+
+  __device__ __e5m2(const uint16_t x) : __x(x) {}
+
+  __device__ uint8_t raw() const {
+    return __x;
+  }
+
+ protected:
+  uint8_t __x;
+};
+
+__device__ __inline__ __e5m2 __double2e5m2(const double f) {
+  unsigned short _tmp_buffer;
+  __e5m2 val;
+  asm("{\n\t"
+      ".reg .b16 buf0;\n\t"
+      ".reg .b32 buf1;\n\t"
+      "cvt.rn.f16.f64 buf0, %1;\n\t"
+      "cvt.u32.u16 buf1, buf0;\n\t"
+      "cvt.rn.satfinite.e5m2x2.f16x2 %0, buf1;\n\t"
+      "}"
+      : "=h"(_tmp_buffer)
+      : "d"(f));
+  memcpy(&val, &_tmp_buffer, sizeof(uint8_t));
+  return val;
+}
+
+__device__ __inline__ double __e5m22double(const __e5m2 h) {
+  unsigned short _tmp_buffer;
+  memcpy(&_tmp_buffer, &h, sizeof(uint8_t));
+  double val;
+  asm("{\n\t"
+      ".reg .b32 buf0;\n\t"
+      "cvt.rn.f16x2.e5m2x2 buf0, %1;\n\t"
+      "cvt.u16.u32 %1, buf0;\n\t"
+      "cvt.f64.f16 %0, %1;"
+      "}"
+      : "=d"(val)
+      : "h"(_tmp_buffer));
+
+  return val;
+}
+
+__device__ __inline__ __e5m2 __float2e5m2(const float f) {
+  constexpr float f_const_zero = 0.f;
+  unsigned short _tmp_buffer;
+  __e5m2 val;
+  asm("{cvt.rn.satfinite.e5m2x2.f32 %0, %1, %2;}"
+      : "=h"(_tmp_buffer)
+      : "f"(f_const_zero), "f"(f));
+  memcpy(&val, &_tmp_buffer, sizeof(uint8_t));
+
+  return val;
+}
+
+__device__ __inline__ float __e5m22float(const __e5m2 h) {
+  unsigned short _tmp_buffer;
+  memcpy(&_tmp_buffer, &h, sizeof(uint8_t));
+  float val;
+  asm("{\n\t"
+      ".reg .b32 buf0;\n\t"
+      "cvt.rn.f16x2.e5m2x2 buf0, %1;\n\t"
+      "cvt.u16.u32 %1, buf0;\n\t"
+      "cvt.f32.f16 %0, %1;\n\t"
+      "}"
+      : "=f"(val)
+      : "h"(_tmp_buffer));
+
+  return val;
+}
+
+__device__ __inline__ __e5m2 __half2e5m2(const __half h) {
+  uint32_t buffer;
+  memcpy(&buffer, &h, sizeof(__half));
+  unsigned short _tmp_buffer;
+  __e5m2 val;
+  asm("{cvt.rn.satfinite.e5m2x2.f16x2 %0, %1;}\n\t"
+      : "=h"(_tmp_buffer)
+      : "r"(buffer));
+  memcpy(&val, &_tmp_buffer, sizeof(uint8_t));
+
+  return val;
+}
+
+__device__ __inline__ __half __e5m22half(const __e5m2 h) {
+  unsigned short _tmp_buffer;
+  memcpy(&_tmp_buffer, &h, sizeof(uint8_t));
+  __half val;
+  asm("{\n\t"
+      ".reg .b32 buf0;\n\t"
+      "cvt.rn.f16x2.e5m2x2 buf0, %1;\n\t"
+      "cvt.u16.u32 %0, buf0;\n\t"
+      "}"
+      : "=h"(__NVFUSER_HALF_TO_US(val))
+      : "h"(_tmp_buffer));
+
+  return val;
+}
+
+__device__ __inline__ __e5m2 __bfloat2e5m2(const __bfloat h) {
+  unsigned short _tmp_buffer;
+  __e5m2 val;
+  asm("{\n\t"
+      ".reg .b32 buf0;\n\t"
+      "cvt.rn.f16.bf16 %1, %1;\n\t"
+      "cvt.u32.u16 buf0, %1;\n\t"
+      "cvt.rn.satfinite.e5m2x2.f16x2 %0, buf0;\n\t"
+      "}"
+      : "=h"(_tmp_buffer)
+      : "h"(__NVFUSER_BFLOAT_TO_CUS(h)));
+  memcpy(&val, &_tmp_buffer, sizeof(uint8_t));
+  return val;
+}
+
+__device__ __inline__ __bfloat __e5m22bfloat(const __e5m2 h) {
+  unsigned short _tmp_buffer;
+  memcpy(&_tmp_buffer, &h, sizeof(uint8_t));
+  __bfloat val;
+  asm("{\n\t"
+      ".reg .b32 buf0;\n\t"
+      "cvt.rn.f16x2.e5m2x2 buf0, %1;\n\t"
+      "cvt.u16.u32 %0, buf0;\n\t"
+      "cvt.bf16.f16 %0, %0;\n\t"
+      "}"
+      : "=h"(__NVFUSER_BFLOAT_TO_US(val))
+      : "h"(_tmp_buffer));
+
+  return val;
+}
+
+__device__ __inline__ __e5m2 operator|(const __e5m2 x, const __e5m2 y) {
+  unsigned short val;
+  unsigned short x_val = x.raw();
+  unsigned short y_val = y.raw();
+  asm("{  or.b16 %0, %1, %2;}\n" : "=h"(val) : "h"(x_val), "h"(y_val));
+  return __e5m2(val);
+}
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+// Type trait utils
+template <typename Type, bool is_volatile>
+struct MaybeVolatile;
+
+template <typename Type>
+struct MaybeVolatile<Type, true> {
+  using type = volatile Type;
+};
+
+template <typename Type>
+struct MaybeVolatile<Type, false> {
+  using type = Type;
+};
+
+template <typename... Types>
+struct TypeList {};
+
+template <int idx, typename T, typename... Types>
+struct TypeSelector {
+  using type = typename TypeSelector<idx - 1, Types...>::type;
+};
+
+template <typename T, typename... Types>
+struct TypeSelector<0, T, Types...> {
+  using type = T;
+};
+
+template <typename T0, typename T1>
+struct IsSameType {
+  static constexpr bool value = false;
+};
+
+template <typename T0>
+struct IsSameType<T0, T0> {
+  static constexpr bool value = true;
+};
+
+template <typename T>
+struct IsPointerType {
+  static constexpr bool value = false;
+};
+
+template <typename T>
+struct IsPointerType<T*> {
+  static constexpr bool value = true;
+};
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+// aligned register array for vectorized load/store
+template <typename scalar_t, int size, int align_size = 1>
+struct alignas(sizeof(scalar_t) * align_size) Array {
+  scalar_t array[size];
+
+  __device__ void set(scalar_t v) {
+#pragma unroll
+    for (int i = 0; i < size; ++i) {
+      array[i] = v;
+    }
+  }
+
+  __device__ scalar_t& operator[](const unsigned int i) {
+    return array[i];
+  }
+
+  __device__ const scalar_t& operator[](const unsigned int i) const {
+    return array[i];
+  }
+
+  Array& operator=(const Array& a) {
+#pragma unroll
+    for (int i = 0; i < size; ++i) {
+      array[i] = a[i];
+    }
+    return *this;
+  }
+};
+
+// Used for vectorized allocations that are not in registers
+template <typename scalar_t, int vec_size>
+__device__ void arraySet(scalar_t* buff, scalar_t val) {
+#pragma unroll
+  for (int i = 0; i < vec_size; ++i) {
+    buff[i] = val;
+  }
+}
+
+template <typename scalar_t, int vec_size>
+__device__ void loadGeneric(scalar_t* to, scalar_t* from) {
+  // It would be really nice to use memcpy here, but one example was failing
+  // with:
+  //
+  //  memcpy(to, from, vec_size * sizeof(scalar_t));
+  //
+  // Yet passing with:
+  //
+  // for(int i = 0; i < vec_size; i++){
+  //   to[i] = from[i];
+  // }
+
+  switch (sizeof(scalar_t) * vec_size) {
+    case 1:
+      *reinterpret_cast<uchar1*>(to) = *reinterpret_cast<uchar1*>(from);
+      break;
+    case 2:
+      *reinterpret_cast<uchar2*>(to) = *reinterpret_cast<uchar2*>(from);
+      break;
+    case 4:
+      *reinterpret_cast<uint1*>(to) = *reinterpret_cast<uint1*>(from);
+      break;
+    case 8:
+      *reinterpret_cast<uint2*>(to) = *reinterpret_cast<uint2*>(from);
+      break;
+    case 12:
+      *reinterpret_cast<uint3*>(to) = *reinterpret_cast<uint3*>(from);
+      break;
+    case 16:
+      *reinterpret_cast<uint4*>(to) = *reinterpret_cast<uint4*>(from);
+      break;
+  }
+}
+
+// Volatile version only works with c++ fundamnetal types
+template <
+    typename scalar_t,
+    int vec_size,
+    bool is_volatile_to,
+    bool is_volatile_from>
+__device__ void loadGenericVolatile(
+    typename MaybeVolatile<scalar_t, is_volatile_to>::type* to,
+    typename MaybeVolatile<scalar_t, is_volatile_from>::type* from) {
+  switch (sizeof(scalar_t) * vec_size) {
+    // Reinterpret cast like this with volatile types only works for C++
+    // fundamental types otherwise the = operator is not defined
+    case 1:
+      *reinterpret_cast<
+          typename MaybeVolatile<unsigned char, is_volatile_to>::type*>(to) =
+          *reinterpret_cast<
+              typename MaybeVolatile<unsigned char, is_volatile_from>::type*>(
+              from);
+      break;
+    case 2:
+      *reinterpret_cast<typename MaybeVolatile<short, is_volatile_to>::type*>(
+          to) =
+          *reinterpret_cast<
+              typename MaybeVolatile<short, is_volatile_from>::type*>(from);
+      break;
+    case 4:
+      *reinterpret_cast<
+          typename MaybeVolatile<unsigned int, is_volatile_to>::type*>(to) =
+          *reinterpret_cast<
+              typename MaybeVolatile<unsigned int, is_volatile_from>::type*>(
+              from);
+      break;
+    case 8:
+      *reinterpret_cast<typename MaybeVolatile<double, is_volatile_to>::type*>(
+          to) =
+          *reinterpret_cast<
+              typename MaybeVolatile<double, is_volatile_from>::type*>(from);
+      break;
+  }
+}
+
+template <typename scalar_t, int vec_size, bool is_volatile>
+__device__ void loadLocalToGlobal(
+    typename MaybeVolatile<scalar_t, is_volatile>::type* to,
+    scalar_t* from) {
+  switch (sizeof(scalar_t) * vec_size) {
+    case 1:
+    case 2:
+    case 4:
+      loadGenericVolatile<scalar_t, vec_size, is_volatile, false>(to, from);
+      break;
+    case 8: {
+      uint2 const& data = *reinterpret_cast<uint2*>(from);
+      if (is_volatile) {
+        asm volatile(
+            "st.volatile.global.v2.s32 [%0], {%1,%2};" ::"l"(
+                (typename MaybeVolatile<uint2, is_volatile>::type*)to),
+            "r"(data.x),
+            "r"(data.y));
+      } else {
+        asm volatile(
+            "st.global.cs.v2.s32 [%0], {%1,%2};" ::"l"(
+                (typename MaybeVolatile<uint2, is_volatile>::type*)to),
+            "r"(data.x),
+            "r"(data.y));
+      }
+      break;
+    }
+    case 16: {
+      uint4 const& data = *reinterpret_cast<uint4*>(from);
+      if (is_volatile) {
+        asm volatile(
+            "st.volatile.global.v4.s32 [%0], {%1,%2,%3,%4};" ::"l"(
+                (typename MaybeVolatile<uint4, is_volatile>::type*)to),
+            "r"(data.x),
+            "r"(data.y),
+            "r"(data.z),
+            "r"(data.w));
+      } else {
+        asm volatile(
+            "st.global.cs.v4.s32 [%0], {%1,%2,%3,%4};" ::"l"(
+                (typename MaybeVolatile<uint4, is_volatile>::type*)to),
+            "r"(data.x),
+            "r"(data.y),
+            "r"(data.z),
+            "r"(data.w));
+      }
+      break;
+    }
+  }
+}
+
+// This is copied from csrc/type.h and should be kept consistent.
+enum class CacheOp {
+  AllLevels,
+  Streaming,
+  Global,
+};
+
+template <typename T, CacheOp cache_op>
+__device__ void loadGlobalToLocalCached(void* to, void* from) {
+  T* typed_to = reinterpret_cast<T*>(to);
+  T* typed_from = reinterpret_cast<T*>(from);
+  switch (cache_op) {
+    case CacheOp::AllLevels:
+      *typed_to = __ldca(typed_from);
+      break;
+    case CacheOp::Streaming:
+      *typed_to = __ldcs(typed_from);
+      break;
+    case CacheOp::Global:
+      *typed_to = __ldcg(typed_from);
+      break;
+  }
+}
+
+// For simplicity, cache_op is only used for non-volatile loads written in
+// inline assembly. Other loads are done with the default cache operator --
+// cache all levels. ld.volatile doesn't accept cache operator anyway.
+template <typename scalar_t, int vec_size, bool is_volatile, CacheOp cache_op>
+__device__ void loadGlobalToLocal(
+    scalar_t* to,
+    typename MaybeVolatile<scalar_t, is_volatile>::type* from) {
+  switch (sizeof(scalar_t) * vec_size) {
+    case 1:
+    case 2:
+    case 4:
+      loadGenericVolatile<scalar_t, vec_size, false, is_volatile>(to, from);
+      break;
+    case 8: {
+      if (is_volatile) {
+        uint2& data = *reinterpret_cast<uint2*>(to);
+        asm volatile("ld.volatile.global.v2.s32 {%0,%1}, [%2];"
+                     : "=r"(data.x), "=r"(data.y)
+                     : "l"((uint2*)from));
+      } else {
+        loadGlobalToLocalCached<uint2, cache_op>(
+            to, const_cast<scalar_t*>(from));
+      }
+      break;
+    }
+    case 16: {
+      if (is_volatile) {
+        uint4& data = *reinterpret_cast<uint4*>(to);
+        asm volatile("ld.volatile.global.v4.s32 {%0,%1,%2,%3}, [%4];"
+                     : "=r"(data.x), "=r"(data.y), "=r"(data.z), "=r"(data.w)
+                     : "l"((uint4*)from));
+      } else {
+        loadGlobalToLocalCached<uint4, cache_op>(
+            to, const_cast<scalar_t*>(from));
+      }
+      break;
+    }
+  }
+}
+
+template <
+    typename scalar_t,
+    int vec_size,
+    bool is_volatile_to,
+    bool is_volatile_from>
+__device__ void loadGlobalToGlobal(
+    typename MaybeVolatile<scalar_t, is_volatile_to>::type* to,
+    typename MaybeVolatile<scalar_t, is_volatile_from>::type* from) {
+  switch (sizeof(scalar_t) * vec_size) {
+    // Reinterpret cast like this with volatile types only works for C++
+    // fundamental types otherwise the = operator is not defined
+    case 1:
+    case 2:
+    case 4:
+    case 8:
+      loadGenericVolatile<scalar_t, vec_size, is_volatile_to, is_volatile_from>(
+          to, from);
+      break;
+    case 12: {
+      uint3 local_intermediate;
+      loadGlobalToLocal<
+          scalar_t,
+          vec_size,
+          is_volatile_from,
+          CacheOp::Streaming>(
+          reinterpret_cast<scalar_t*>(&local_intermediate), from);
+      loadLocalToGlobal<scalar_t, vec_size, is_volatile_to>(
+          to, reinterpret_cast<scalar_t*>(&local_intermediate));
+      break;
+    }
+    case 16: {
+      uint4 local_intermediate;
+      loadGlobalToLocal<
+          scalar_t,
+          vec_size,
+          is_volatile_from,
+          CacheOp::Streaming>(
+          reinterpret_cast<scalar_t*>(&local_intermediate), from);
+      loadLocalToGlobal<scalar_t, vec_size, is_volatile_to>(
+          to, reinterpret_cast<scalar_t*>(&local_intermediate));
+      break;
+    }
+  }
+}
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+template <typename T, int Dims, int AllocDims = Dims>
+struct Tensor {
+  __device__ T& operator[](nvfuser_index_t ind) {
+    return data[ind];
+  };
+
+  T* data;
+  Array<nvfuser_index_t, Dims, 1> logical_size;
+  Array<nvfuser_index_t, AllocDims, 1> alloc_stride;
+};
+
+// Specialization for 0-dim case as it does not need size and stride arrays.
+// They will be an error as well since zero-length arrays are not allowed.
+template <typename T>
+struct Tensor<T, 0> {
+  __device__ T& operator[](nvfuser_index_t i) {
+    return *data;
+  };
+
+  T* data;
+};
+
+// Specialization for 0-dim case that's easy to pass in a CPU based tensor.
+template <typename T>
+struct CpuScalarTensor {
+  __device__ T& operator[](int i) {
+    return data;
+  };
+
+  T data;
+};
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+__device__ unsigned int mulhilo32(
+    unsigned int a,
+    unsigned int b,
+    unsigned int* result_high) {
+  *result_high = __umulhi(a, b);
+  return a * b;
+}
+
+__device__ uint4 single_round(uint4 ctr, uint2 key) {
+  constexpr unsigned long kPhiloxSA = 0xD2511F53;
+  constexpr unsigned long kPhiloxSB = 0xCD9E8D57;
+  unsigned int hi0;
+  unsigned int hi1;
+  unsigned int lo0 = mulhilo32(kPhiloxSA, ctr.x, &hi0);
+  unsigned int lo1 = mulhilo32(kPhiloxSB, ctr.z, &hi1);
+  uint4 ret = {hi1 ^ ctr.y ^ key.x, lo1, hi0 ^ ctr.w ^ key.y, lo0};
+  return ret;
+}
+
+__device__ uint4 philox(
+    unsigned long long seed,
+    unsigned long long subsequence,
+    unsigned long long offset) {
+  constexpr unsigned long kPhilox10A = 0x9E3779B9;
+  constexpr unsigned long kPhilox10B = 0xBB67AE85;
+  uint2 key = {};
+  key.x = (unsigned int)seed;
+  key.y = (unsigned int)(seed >> 32);
+  uint4 counter = make_uint4(0, 0, 0, 0);
+  counter.x = (unsigned int)(offset);
+  counter.y = (unsigned int)(offset >> 32);
+  counter.z = (unsigned int)(subsequence);
+  counter.w = (unsigned int)(subsequence >> 32);
+
+  uint4 output = {};
+  uint2 key_ = key;
+  uint4 counter_ = counter;
+  for (int i = 0; i < 9; i++) {
+    counter_ = single_round(counter_, key_);
+    key_.x += (kPhilox10A);
+    key_.y += (kPhilox10B);
+  }
+  output = single_round(counter_, key_);
+  return output;
+}
+
+// This is a uniform double in the range (0, 1]
+__device__ double raw_uniform_double(unsigned int x, unsigned int y) {
+  constexpr double scale = 1.0 / (double)(1ll << 53);
+  const unsigned long long z =
+      (unsigned long long)x ^ ((unsigned long long)y << (53 - 32));
+  return (double)z * scale + 0.5 * scale;
+}
+
+// This is a uniform float in the range (0, 1]
+__device__ float raw_uniform_float(unsigned int x) {
+  constexpr float scale = (float)(1.0 / (double)(1ll << 32));
+  return (float)x * scale + 0.5f * scale;
+}
+
+__device__ __half uniform_half(unsigned int x) {
+  __half result = __float2half(raw_uniform_float(x));
+  return __heq(result, __float2half(1.0f)) ? __float2half(0.0f) : result;
+}
+
+__device__ __bfloat uniform_bfloat(unsigned int x) {
+  __bfloat result = __float2bfloat(raw_uniform_float(x));
+  return __heq(result, __float2bfloat(1.0f)) ? __float2bfloat(0.0f) : result;
+}
+
+__device__ float uniformf(unsigned int x) {
+  float result = raw_uniform_float(x);
+  return result == 1.0f ? 0.0f : result;
+}
+
+__device__ double uniform(unsigned int x, unsigned int y) {
+  double result = raw_uniform_double(x, y);
+  return result == 1.0 ? 0.0 : result;
+}
+
+__device__ double rng_uniform(const uint4& rng_result, int rng_component) {
+  return uniform(
+      (&rng_result.x)[rng_component * 2],
+      (&rng_result.x)[rng_component * 2 + 1]);
+}
+
+__device__ float rng_uniformf(const uint4& rng_result, int rng_component) {
+  return uniformf((&rng_result.x)[rng_component]);
+}
+
+__device__ __half rng_uniform_half(const uint4& rng_result, int rng_component) {
+  return uniform_half((&rng_result.x)[rng_component]);
+}
+
+__device__ __bfloat
+rng_uniform_bfloat(const uint4& rng_result, int rng_component) {
+  return uniform_bfloat((&rng_result.x)[rng_component]);
+}
+
+__device__ double rng_uniform_range(
+    const uint4& rng_result,
+    int rng_component,
+    double from,
+    double to) {
+  auto range = to - from;
+  auto uniform01 = rng_uniform(rng_result, rng_component);
+  return from + range * uniform01;
+}
+
+__device__ float rng_uniform_rangef(
+    const uint4& rng_result,
+    int rng_component,
+    float from,
+    float to) {
+  auto range = to - from;
+  auto uniform01 = rng_uniformf(rng_result, rng_component);
+  return from + range * uniform01;
+}
+
+__device__ __half rng_uniform_range_half(
+    const uint4& rng_result,
+    int rng_component,
+    float from,
+    float to) {
+  auto range = to - from;
+  float uniform01 = raw_uniform_float((&rng_result.x)[rng_component]);
+  __half result = __float2half(from + range * uniform01);
+  return __heq(result, __float2half(to)) ? __float2half(from) : result;
+}
+
+__device__ __bfloat rng_uniform_range_bfloat(
+    const uint4& rng_result,
+    int rng_component,
+    float from,
+    float to) {
+  auto range = to - from;
+  float uniform01 = raw_uniform_float((&rng_result.x)[rng_component]);
+  __bfloat result = __float2bfloat(from + range * uniform01);
+  return __heq(result, __float2bfloat(to)) ? __float2bfloat(from) : result;
+}
+
+__device__ float normalf(unsigned int x, unsigned int y, int rng_component) {
+  float u = uniformf(x);
+  float v = uniformf(y) * 6.2831855f;
+
+  if (rng_component % 2 == 0) {
+    return sqrtf(-2.0f * logf(u)) * sinf(v);
+  } else {
+    return sqrtf(-2.0f * logf(u)) * cosf(v);
+  }
+}
+
+__device__ double normal(
+    unsigned int x0,
+    unsigned int x1,
+    unsigned int y0,
+    unsigned int y1,
+    int rng_component) {
+  double u = uniform(x0, x1);
+  double v = uniform(y0, y1) * 6.2831853071795860;
+
+  if (rng_component % 2 == 0) {
+    return sqrt(-2.0 * log(u)) * sin(v);
+  } else {
+    return sqrt(-2.0 * log(u)) * cos(v);
+  }
+}
+
+__device__ double rng_normal_standard(
+    const uint4& rng_result,
+    int rng_component) {
+  return normal(
+      rng_result.x, rng_result.y, rng_result.z, rng_result.w, rng_component);
+}
+
+__device__ float rng_normal_standardf(
+    const uint4& rng_result,
+    int rng_component) {
+  return normalf(
+      (&rng_result.x)[rng_component / 2 * 2],
+      (&rng_result.y)[rng_component / 2 * 2],
+      rng_component);
+}
+
+__device__ __half
+rng_normal_standard_half(const uint4& rng_result, int rng_component) {
+  return __float2half(normalf(
+      (&rng_result.x)[rng_component / 2 * 2],
+      (&rng_result.y)[rng_component / 2 * 2],
+      rng_component));
+}
+
+__device__ __bfloat
+rng_normal_standard_bfloat(const uint4& rng_result, int rng_component) {
+  return __float2bfloat(normalf(
+      (&rng_result.x)[rng_component / 2 * 2],
+      (&rng_result.y)[rng_component / 2 * 2],
+      rng_component));
+}
+
+__device__ double rng_normal_general(
+    const uint4& rng_result,
+    int rng_component,
+    double mean,
+    double std) {
+  auto normal01 = rng_normal_standard(rng_result, rng_component);
+  return normal01 * std + mean;
+}
+
+__device__ float rng_normal_generalf(
+    const uint4& rng_result,
+    int rng_component,
+    float mean,
+    float std) {
+  auto normal01 = rng_normal_standardf(rng_result, rng_component);
+  return normal01 * std + mean;
+}
+
+__device__ __half rng_normal_general_half(
+    const uint4& rng_result,
+    int rng_component,
+    float mean,
+    float std) {
+  auto normal01 = normalf(
+      (&rng_result.x)[rng_component / 2 * 2],
+      (&rng_result.y)[rng_component / 2 * 2],
+      rng_component);
+  return __float2half(normal01 * std + mean);
+}
+
+__device__ __bfloat rng_normal_general_bfloat(
+    const uint4& rng_result,
+    int rng_component,
+    float mean,
+    float std) {
+  auto normal01 = normalf(
+      (&rng_result.x)[rng_component / 2 * 2],
+      (&rng_result.y)[rng_component / 2 * 2],
+      rng_component);
+  return __float2bfloat(normal01 * std + mean);
+}
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+#define NVFUSER_DEFINE_MAGIC_ZERO          \
+  __shared__ int nvfuser_zero_s;           \
+  if (threadIdx.x == 0)                    \
+    nvfuser_zero_s = 0;                    \
+  __syncthreads();                         \
+  atomicMin(&nvfuser_zero_s, threadIdx.x); \
+  int nvfuser_zero = nvfuser_zero_s;
+
+#define NVFUSER_UPDATE_MAGIC_ZERO \
+  do {                            \
+    nvfuser_zero <<= 1;           \
+  } while (0);
+
+#ifdef __NVCC__
+#include <assert.h>
+#endif // __NVCC__
+
+__device__ constexpr int ceilDiv(int a, int b) {
+  return (a + b - 1) / b;
+}
+
+__device__ constexpr int64_t ceilDiv(int64_t a, int64_t b) {
+  return (a + b - 1) / b;
+}
+
+__device__ constexpr int64_t ceilDiv(int64_t a, int b) {
+  return ceilDiv(a, (int64_t)b);
+}
+
+__device__ constexpr int64_t ceilDiv(int a, int64_t b) {
+  return ceilDiv((int64_t)a, b);
+}
+
+__device__ constexpr double ceilDiv(double a, double b) {
+  return std::ceil(a / b);
+}
+
+__device__ constexpr double ceilDiv(double a, int64_t b) {
+  return std::ceil(a / b);
+}
+
+__device__ constexpr double ceilDiv(int64_t a, double b) {
+  return std::ceil(a / b);
+}
+
+// Monotonic and precise lerp is described here:
+// https://math.stackexchange.com/a/1798323
+__device__ double lerp(double start, double end, double weight) {
+  if (weight < 0.5) {
+    return start + weight * (end - start);
+  } else {
+    return end - (end - start) * (1.0 - weight);
+  }
+}
+
+__device__ float lerp(float start, float end, float weight) {
+  if (weight < 0.5f) {
+    return start + weight * (end - start);
+  } else {
+    return end - (end - start) * (1.0f - weight);
+  }
+}
+
+__device__ float lerp(float start, float end, double weight) {
+  return lerp(start, end, static_cast<float>(weight));
+}
+
+__device__ constexpr int max(int a, int b) {
+  return a > b ? a : b;
+}
+
+__device__ constexpr int64_t max(int64_t a, int b) {
+  return a > (int64_t)b ? a : (int64_t)b;
+}
+
+__device__ constexpr int64_t max(int a, int64_t b) {
+  return (int64_t)a > b ? (int64_t)a : b;
+}
+
+__device__ constexpr int64_t max(int64_t a, int64_t b) {
+  return a > b ? a : b;
+}
+
+__device__ double fmax(double a, double b) {
+  // check and propagate NaN
+  if (a != a) {
+    return a;
+  } else { // If b is nan, it will be returned in the next line
+    return a > b ? a : b;
+  }
+}
+
+__device__ float fmax(float a, float b) {
+  // check and propagate NaN
+  if (a != a) {
+    return a;
+  } else { // If b is nan, it will be returned in the next line
+    return a > b ? a : b;
+  }
+}
+
+__device__ constexpr int min(int a, int b) {
+  return a > b ? b : a;
+}
+
+__device__ constexpr int64_t min(int64_t a, int b) {
+  return (int64_t)a > b ? b : (int64_t)a;
+}
+
+__device__ constexpr int64_t min(int a, int64_t b) {
+  return a > (int64_t)b ? (int64_t)b : a;
+}
+
+__device__ constexpr int64_t min(int64_t a, int64_t b) {
+  return a > b ? b : a;
+}
+
+__device__ double fmin(double a, double b) {
+  // check and propagate NaN
+  if (b != b) {
+    return b;
+  } else { // If a is nan, it will be returned in the next line
+    return a > b ? b : a;
+  }
+}
+
+__device__ float fmin(float a, float b) {
+  // check and propagate NaN
+  if (b != b) {
+    return b;
+  } else { // If a is nan, it will be returned in the next line
+    return a > b ? b : a;
+  }
+}
+
+__device__ constexpr int alignBufferSize(int buffer, int size) {
+  return (buffer + (size - 1)) & ~(size - 1);
+}
+
+__device__ double clamp(double x, double minv, double maxv) {
+  return fmin(fmax(x, minv), maxv);
+}
+
+__device__ float clamp(float x, double minv, double maxv) {
+  return fmin(fmax((double)x, minv), maxv);
+}
+
+__device__ int clamp(int x, int64_t minv, int64_t maxv) {
+  return min(max((int64_t)x, minv), maxv);
+}
+
+__device__ int64_t clamp(int64_t x, int64_t minv, int64_t maxv) {
+  return min(max(x, minv), maxv);
+}
+
+__device__ double frac(double x) {
+  return x - trunc(x);
+}
+
+__device__ float frac(float x) {
+  return x - trunc(x);
+}
+
+__device__ double reciprocal(double x) {
+  return 1 / x;
+}
+
+__device__ float reciprocal(float x) {
+  return 1 / x;
+}
+
+__device__ double relu(double x) {
+  return x <= 0 ? 0 : x;
+}
+
+__device__ float relu(float x) {
+  return x <= 0 ? 0 : x;
+}
+
+__device__ float relu(int64_t x) {
+  return x <= 0 ? 0 : x;
+}
+
+__device__ float relu(int x) {
+  return x <= 0 ? 0 : x;
+}
+
+__device__ double remainder(double a, double b) {
+  auto mod = ::fmod(a, b);
+  if ((mod != 0) && ((b < 0) != (mod < 0)))
+    mod += b;
+  return mod;
+}
+
+__device__ float remainder(float a, float b) {
+  auto mod = ::fmod(a, b);
+  if ((mod != 0) && ((b < 0) != (mod < 0)))
+    mod += b;
+  return mod;
+}
+
+__device__ double sigmoid(double x) {
+  return 1.0 / (1.0 + exp(-x));
+}
+
+__device__ float sigmoid(float x) {
+  return 1.0f / (1.0f + exp(-x));
+}
+
+__device__ double silu(double x) {
+  return x * sigmoid(x);
+}
+
+__device__ float silu(float x) {
+  return x * sigmoid(x);
+}
+
+__device__ double threshold(double x, double t, double v) {
+  return x <= t ? v : x;
+}
+
+__device__ float threshold(float x, double t, double v) {
+  return x <= t ? v : x;
+}
+
+__device__ int threshold(int x, int64_t t, int64_t v) {
+  return x <= t ? v : x;
+}
+
+__device__ int64_t threshold(int64_t x, int64_t t, int64_t v) {
+  return x <= t ? v : x;
+}
+
+__device__ constexpr int64_t remainder(int64_t a, int64_t b) {
+  auto mod = a % b;
+  if ((mod != 0) && ((b < 0) != (mod < 0)))
+    mod += b;
+  return mod;
+}
+
+__device__ constexpr int remainder(int a, int b) {
+  auto mod = a % b;
+  if ((mod != 0) && ((b < 0) != (mod < 0)))
+    mod += b;
+  return mod;
+}
+
+__device__ constexpr int64_t fmod(int64_t a, int64_t b) {
+  return a % b;
+}
+
+__device__ constexpr int fmod(int a, int b) {
+  return a % b;
+}
+
+__device__ constexpr double fmod(double a, double b) {
+  return ::fmod(a, b);
+}
+
+__device__ constexpr float fmod(float a, float b) {
+  return ::fmod(a, b);
+}
+
+__device__ constexpr double nextafter(double a, double b) {
+  return ::nextafter(a, b);
+}
+
+__device__ constexpr float nextafter(float a, float b) {
+  return ::nextafterf(a, b);
+}
+
+template <typename T>
+__device__ T pow(T a, T b) {
+  if (b < 0) {
+    if (a == 1) {
+      return 1;
+    } else if (a == -1) {
+      auto negative = (-b) % static_cast<T>(2);
+      return negative ? -1 : 1;
+    } else {
+      return 0;
+    }
+  } else {
+    T result = 1;
+    while (b) {
+      if (b & 1) {
+        result *= a;
+      }
+      b /= 2;
+      a *= a;
+    }
+    return result;
+  }
+}
+
+template __device__ int pow<int>(int a, int b);
+template __device__ int64_t pow<int64_t>(int64_t a, int64_t b);
+
+template <>
+__device__ float pow<float>(float a, float b) {
+  return ::pow(a, b);
+}
+
+template <>
+__device__ double pow<double>(double a, double b) {
+  return ::pow(a, b);
+}
+
+__device__ float pow(float a, int b) {
+  return pow(a, (float)b);
+}
+
+__device__ double pow(double a, int b) {
+  return pow(a, (double)b);
+}
+
+__device__ float pow(float a, int64_t b) {
+  return pow(a, (float)b);
+}
+
+__device__ double pow(double a, int64_t b) {
+  return pow(a, (double)b);
+}
+
+__device__ int64_t pow(int64_t a, int b) {
+  return pow(a, (int64_t)b);
+}
+
+__device__ int64_t pow(int a, int64_t b) {
+  return pow((int64_t)a, b);
+}
+
+__device__ double rsqrt(double z) {
+  return ::rsqrt(z);
+}
+
+__device__ float rsqrt(float z) {
+  return ::rsqrtf(z);
+}
+
+__device__ int rsqrt(int z) {
+  return ::rsqrtf((float)z);
+}
+
+__device__ int64_t rsqrt(int64_t z) {
+  return ::rsqrt((double)z);
+}
+
+__device__ double signbit(double a) {
+  return ::signbit(a);
+}
+
+__device__ float signbit(float a) {
+  return ::signbit(a);
+}
+
+__device__ int signbit(int a) {
+  return a < 0;
+}
+
+__device__ int64_t signbit(int64_t a) {
+  return a < 0;
+}
+
+// Reference:
+// https://en.wikipedia.org/wiki/Euclidean_algorithm#Implementations
+// https://github.com/pytorch/pytorch/blob/c9f4f01981fd73fcc7c27676cc50230cd1b5bc22/aten/src/ATen/native/Math.h#L1232
+template <typename T>
+__device__ T gcd(T a, T b) {
+  a = abs(a);
+  b = abs(b);
+  while (b != 0) {
+    auto t = b;
+    b = a % b;
+    a = t;
+  }
+  return a;
+}
+
+template <typename T>
+bool isfinite(T x) {
+  return ::isfinite(x);
+}
+
+// ref:
+// https://github.com/NVIDIA/cutlass/blob/6fbc0d33800008d3180d3fefed4e1a653e5f72a0/include/cutlass/bfloat16.h#L213
+template <>
+bool isfinite<__bfloat>(__bfloat x) {
+  const auto exponent_biased = int((x.raw() >> 7) & 0x0ff);
+  return exponent_biased != 0x0ff;
+}
+
+// ref:
+// https://github.com/NVIDIA/cutlass/blob/6fbc0d33800008d3180d3fefed4e1a653e5f72a0/include/cutlass/half.h#L511
+template <>
+bool isfinite<__half>(__half x) {
+  const auto exponent_biased = int((x.raw() >> 10) & 0x1f);
+  return exponent_biased != 0x1f;
+}
+
+template <typename T>
+bool isinf(T x) {
+  return ::isinf(x);
+}
+
+////////////////////////////////////////////////////////////
+// TODO: the following overloads are only needed for CUDA //
+// 10.2 Please remove when CUDA 10.2 support is dropped   //
+////////////////////////////////////////////////////////////
+
+bool isinf(int64_t x) {
+  return false;
+}
+
+bool isinf(int x) {
+  return false;
+}
+
+bool isinf(short x) {
+  return false;
+}
+
+bool isinf(char x) {
+  return false;
+}
+
+bool isinf(unsigned char x) {
+  return false;
+}
+
+bool isinf(bool x) {
+  return false;
+}
+
+bool isfinite(int64_t x) {
+  return true;
+}
+
+bool isfinite(int x) {
+  return true;
+}
+
+bool isfinite(short x) {
+  return true;
+}
+
+bool isfinite(char x) {
+  return true;
+}
+
+bool isfinite(unsigned char x) {
+  return true;
+}
+
+bool isfinite(bool x) {
+  return true;
+}
+
+////////////////////////////////////////////////////////////
+//                        End TODO                        //
+////////////////////////////////////////////////////////////
+
+template <typename T>
+bool isnan(T x) {
+  return x != x;
+}
+
+template <typename T>
+bool isneginf(T x) {
+  return x < 0 && isinf(x);
+}
+
+template <typename T>
+bool isposinf(T x) {
+  return x > 0 && isinf(x);
+}
+
+template <typename T>
+bool isreal(T x) {
+  return true;
+}
+
+// Return the current value of the cycle counter
+__device__ inline int64_t readCycleCounter() {
+  // Ensures preceding memory operations are completed. Doing this
+  // would make sense for measuring elapsed times enclosed with this
+  // function.
+  __threadfence();
+  return clock64();
+}
+
+__device__ float print_impl(const char* name, float value) {
+  printf(
+      "%s = %f @ threadIdx=(%d,%d,%d), blockIdx=(%d,%d,%d)\n",
+      name,
+      value,
+      (int)threadIdx.x,
+      (int)threadIdx.y,
+      (int)threadIdx.z,
+      (int)blockIdx.x,
+      (int)blockIdx.y,
+      (int)blockIdx.z);
+  return value;
+}
+
+__device__ double print_impl(const char* name, double value) {
+  printf(
+      "%s = %lf @ threadIdx=(%d,%d,%d), blockIdx=(%d,%d,%d)\n",
+      name,
+      value,
+      (int)threadIdx.x,
+      (int)threadIdx.y,
+      (int)threadIdx.z,
+      (int)blockIdx.x,
+      (int)blockIdx.y,
+      (int)blockIdx.z);
+  return value;
+}
+
+__device__ int print_impl(const char* name, int value) {
+  printf(
+      "%s = %d @ threadIdx=(%d,%d,%d), blockIdx=(%d,%d,%d)\n",
+      name,
+      value,
+      (int)threadIdx.x,
+      (int)threadIdx.y,
+      (int)threadIdx.z,
+      (int)blockIdx.x,
+      (int)blockIdx.y,
+      (int)blockIdx.z);
+  return value;
+}
+
+__device__ int64_t print_impl(const char* name, int64_t value) {
+  printf(
+      "%s = %ld @ threadIdx=(%d,%d,%d), blockIdx=(%d,%d,%d)\n",
+      name,
+      value,
+      (int)threadIdx.x,
+      (int)threadIdx.y,
+      (int)threadIdx.z,
+      (int)blockIdx.x,
+      (int)blockIdx.y,
+      (int)blockIdx.z);
+  return value;
+}
+
+__device__ bool print_impl(const char* name, bool value) {
+  printf(
+      "%s = %s @ threadIdx=(%d,%d,%d), blockIdx=(%d,%d,%d)\n",
+      name,
+      value ? "true" : "false",
+      (int)threadIdx.x,
+      (int)threadIdx.y,
+      (int)threadIdx.z,
+      (int)blockIdx.x,
+      (int)blockIdx.y,
+      (int)blockIdx.z);
+  return value;
+}
+
+__device__ __half print_impl(const char* name, __half value) {
+  printf(
+      "%s = %f @ threadIdx=(%d,%d,%d), blockIdx=(%d,%d,%d)\n",
+      name,
+      __half2float(value),
+      (int)threadIdx.x,
+      (int)threadIdx.y,
+      (int)threadIdx.z,
+      (int)blockIdx.x,
+      (int)blockIdx.y,
+      (int)blockIdx.z);
+  return value;
+}
+
+#if __CUDACC_VER_MAJOR__ >= 11
+__device__ __bfloat print_impl(const char* name, __bfloat value) {
+  printf(
+      "%s = %f @ threadIdx=(%d,%d,%d), blockIdx=(%d,%d,%d)\n",
+      name,
+      __bfloat2float(value),
+      (int)threadIdx.x,
+      (int)threadIdx.y,
+      (int)threadIdx.z,
+      (int)blockIdx.x,
+      (int)blockIdx.y,
+      (int)blockIdx.z);
+  return value;
+}
+#endif
+
+#define print(...) print_impl(#__VA_ARGS__, (__VA_ARGS__))
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+namespace index_utils {
+
+// Utility functions
+
+// Total size of provided dimension
+template <typename _dim3>
+__device__ __forceinline__ nvfuser_index_t size(const _dim3& d) {
+  return (nvfuser_index_t)d.x * (nvfuser_index_t)d.y * (nvfuser_index_t)d.z;
+}
+
+// Linearized indexing of idx based on dim, if bool==false that dimension does
+// not participate
+template <bool X, bool Y, bool Z, typename _dim3, typename _dim3_2>
+__device__ nvfuser_index_t maskedOffset(const _dim3& idx, const _dim3_2& dim) {
+  nvfuser_index_t offset = 0;
+  if (Z)
+    offset += idx.z;
+  if (Y)
+    offset = offset * dim.y + idx.y;
+  if (X)
+    offset = offset * dim.x + idx.x;
+  return offset;
+}
+
+// Linearized indexing of idx based on dim. All dimensions participate.
+template <typename _dim3, typename _dim3_2>
+__device__ nvfuser_index_t offset(const _dim3& idx, const _dim3_2& dim) {
+  nvfuser_index_t offset = idx.z;
+  offset = offset * dim.y + idx.y;
+  offset = offset * dim.x + idx.x;
+  return offset;
+}
+
+// Masks the provided dim3, those == false get truncated to 1
+template <bool X, bool Y, bool Z, typename _dim3>
+__device__ dim3 maskedDims(const _dim3& dim) {
+  return dim3{
+      X ? (unsigned)dim.x : 1U,
+      Y ? (unsigned)dim.y : 1U,
+      Z ? (unsigned)dim.z : 1U};
+}
+
+// Provides total size of dim with masking, those dims == false do not
+// participate in the size calculation
+template <bool X_BLOCK, bool Y_BLOCK, bool Z_BLOCK, typename _dim3>
+__device__ nvfuser_index_t maskedSize(const _dim3& dim) {
+  return size(maskedDims<X_BLOCK, Y_BLOCK, Z_BLOCK>(dim));
+}
+
+// Checks if provided idx is zero on those dims == true
+template <bool X, bool Y, bool Z, typename _dim3>
+__device__ bool maskedIsZero(const _dim3& idx) {
+  bool isZero = true;
+  if (X)
+    isZero = isZero && idx.x == 0;
+  if (Y)
+    isZero = isZero && idx.y == 0;
+  if (Z)
+    isZero = isZero && idx.z == 0;
+  return isZero;
+}
+
+// Checks if provided idx is zero on those dims == true
+template <bool X, bool Y, bool Z, typename _dim3, typename _dim3_2>
+__device__ bool maskedIsLast(const _dim3& idx, const _dim3_2& dim) {
+  bool isZero = true;
+  if (X)
+    isZero = isZero && idx.x == dim.x - 1;
+  if (Y)
+    isZero = isZero && idx.y == dim.y - 1;
+  if (Z)
+    isZero = isZero && idx.z == dim.z - 1;
+  return isZero;
+}
+
+} // namespace index_utils
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+// std::tuple-like type
+template <typename... Types>
+struct Tuple;
+
+#define TUPLE_INCREMENT_PTR(idx)                                        \
+  do {                                                                  \
+    static_assert(                                                      \
+        IsPointerType<T##idx>::value, "Invalid for non-pointer types"); \
+    val##idx += offset;                                                 \
+  } while (0)
+
+template <typename T0>
+struct Tuple<T0> {
+  T0 val0;
+
+  Tuple() = default;
+
+  __device__ Tuple(T0 _val0) : val0(_val0) {}
+
+  // Only valid when instantiated for pointer types
+  __device__ void operator+=(nvfuser_index_t offset) {
+    TUPLE_INCREMENT_PTR(0);
+  }
+};
+
+template <typename T0, typename T1>
+struct Tuple<T0, T1> {
+  T0 val0;
+  T1 val1;
+
+  Tuple() = default;
+
+  __device__ Tuple(T0 _val0, T1 _val1) : val0(_val0), val1(_val1) {}
+
+  // Only valid when instantiated for pointer types
+  __device__ void operator+=(nvfuser_index_t offset) {
+    TUPLE_INCREMENT_PTR(0);
+    TUPLE_INCREMENT_PTR(1);
+  }
+};
+
+template <typename T0, typename T1, typename T2>
+struct Tuple<T0, T1, T2> {
+  T0 val0;
+  T1 val1;
+  T2 val2;
+
+  Tuple() = default;
+
+  __device__ Tuple(T0 _val0, T1 _val1, T2 _val2)
+      : val0(_val0), val1(_val1), val2(_val2) {}
+
+  // Only valid when instantiated for pointer types
+  __device__ void operator+=(nvfuser_index_t offset) {
+    TUPLE_INCREMENT_PTR(0);
+    TUPLE_INCREMENT_PTR(1);
+    TUPLE_INCREMENT_PTR(2);
+  }
+};
+
+template <typename T0, typename T1, typename T2, typename T3>
+struct Tuple<T0, T1, T2, T3> {
+  T0 val0;
+  T1 val1;
+  T2 val2;
+  T3 val3;
+
+  Tuple() = default;
+
+  __device__ Tuple(T0 _val0, T1 _val1, T2 _val2, T3 _val3)
+      : val0(_val0), val1(_val1), val2(_val2), val3(_val3) {}
+
+  // Only valid when instantiated for pointer types
+  __device__ void operator+=(nvfuser_index_t offset) {
+    TUPLE_INCREMENT_PTR(0);
+    TUPLE_INCREMENT_PTR(1);
+    TUPLE_INCREMENT_PTR(2);
+    TUPLE_INCREMENT_PTR(3);
+  }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4>
+struct Tuple<T0, T1, T2, T3, T4> {
+  T0 val0;
+  T1 val1;
+  T2 val2;
+  T3 val3;
+  T4 val4;
+
+  Tuple() = default;
+
+  __device__ Tuple(T0 _val0, T1 _val1, T2 _val2, T3 _val3, T4 _val4)
+      : val0(_val0), val1(_val1), val2(_val2), val3(_val3), val4(_val4) {}
+
+  // Only valid when instantiated for pointer types
+  __device__ void operator+=(nvfuser_index_t offset) {
+    TUPLE_INCREMENT_PTR(0);
+    TUPLE_INCREMENT_PTR(1);
+    TUPLE_INCREMENT_PTR(2);
+    TUPLE_INCREMENT_PTR(3);
+    TUPLE_INCREMENT_PTR(4);
+  }
+};
+
+template <
+    typename T0,
+    typename T1,
+    typename T2,
+    typename T3,
+    typename T4,
+    typename T5>
+struct Tuple<T0, T1, T2, T3, T4, T5> {
+  T0 val0;
+  T1 val1;
+  T2 val2;
+  T3 val3;
+  T4 val4;
+  T5 val5;
+
+  Tuple() = default;
+
+  __device__ Tuple(T0 _val0, T1 _val1, T2 _val2, T3 _val3, T4 _val4, T5 _val5)
+      : val0(_val0),
+        val1(_val1),
+        val2(_val2),
+        val3(_val3),
+        val4(_val4),
+        val5(_val5) {}
+
+  // Only valid when instantiated for pointer types
+  __device__ void operator+=(nvfuser_index_t offset) {
+    TUPLE_INCREMENT_PTR(0);
+    TUPLE_INCREMENT_PTR(1);
+    TUPLE_INCREMENT_PTR(2);
+    TUPLE_INCREMENT_PTR(3);
+    TUPLE_INCREMENT_PTR(4);
+    TUPLE_INCREMENT_PTR(5);
+  }
+};
+
+template <
+    typename T0,
+    typename T1,
+    typename T2,
+    typename T3,
+    typename T4,
+    typename T5,
+    typename T6>
+struct Tuple<T0, T1, T2, T3, T4, T5, T6> {
+  T0 val0;
+  T1 val1;
+  T2 val2;
+  T3 val3;
+  T4 val4;
+  T5 val5;
+  T6 val6;
+
+  Tuple() = default;
+
+  __device__ Tuple(
+      T0 _val0,
+      T1 _val1,
+      T2 _val2,
+      T3 _val3,
+      T4 _val4,
+      T5 _val5,
+      T6 _val6)
+      : val0(_val0),
+        val1(_val1),
+        val2(_val2),
+        val3(_val3),
+        val4(_val4),
+        val5(_val5),
+        val6(_val6) {}
+
+  // Only valid when instantiated for pointer types
+  __device__ void operator+=(nvfuser_index_t offset) {
+    TUPLE_INCREMENT_PTR(0);
+    TUPLE_INCREMENT_PTR(1);
+    TUPLE_INCREMENT_PTR(2);
+    TUPLE_INCREMENT_PTR(3);
+    TUPLE_INCREMENT_PTR(4);
+    TUPLE_INCREMENT_PTR(5);
+    TUPLE_INCREMENT_PTR(6);
+  }
+};
+
+template <
+    typename T0,
+    typename T1,
+    typename T2,
+    typename T3,
+    typename T4,
+    typename T5,
+    typename T6,
+    typename T7>
+struct Tuple<T0, T1, T2, T3, T4, T5, T6, T7> {
+  T0 val0;
+  T1 val1;
+  T2 val2;
+  T3 val3;
+  T4 val4;
+  T5 val5;
+  T6 val6;
+  T7 val7;
+
+  Tuple() = default;
+
+  __device__ Tuple(
+      T0 _val0,
+      T1 _val1,
+      T2 _val2,
+      T3 _val3,
+      T4 _val4,
+      T5 _val5,
+      T6 _val6,
+      T7 _val7)
+      : val0(_val0),
+        val1(_val1),
+        val2(_val2),
+        val3(_val3),
+        val4(_val4),
+        val5(_val5),
+        val6(_val6),
+        val7(_val7) {}
+
+  // Only valid when instantiated for pointer types
+  __device__ void operator+=(nvfuser_index_t offset) {
+    TUPLE_INCREMENT_PTR(0);
+    TUPLE_INCREMENT_PTR(1);
+    TUPLE_INCREMENT_PTR(2);
+    TUPLE_INCREMENT_PTR(3);
+    TUPLE_INCREMENT_PTR(4);
+    TUPLE_INCREMENT_PTR(5);
+    TUPLE_INCREMENT_PTR(6);
+    TUPLE_INCREMENT_PTR(7);
+  }
+};
+
+template <
+    typename T0,
+    typename T1,
+    typename T2,
+    typename T3,
+    typename T4,
+    typename T5,
+    typename T6,
+    typename T7,
+    typename T8,
+    typename T9,
+    typename T10,
+    typename T11,
+    typename T12,
+    typename T13,
+    typename T14,
+    typename T15>
+struct Tuple<
+    T0,
+    T1,
+    T2,
+    T3,
+    T4,
+    T5,
+    T6,
+    T7,
+    T8,
+    T9,
+    T10,
+    T11,
+    T12,
+    T13,
+    T14,
+    T15> {
+  T0 val0;
+  T1 val1;
+  T2 val2;
+  T3 val3;
+  T4 val4;
+  T5 val5;
+  T6 val6;
+  T7 val7;
+  T8 val8;
+  T9 val9;
+  T10 val10;
+  T11 val11;
+  T12 val12;
+  T13 val13;
+  T14 val14;
+  T15 val15;
+
+  Tuple() = default;
+
+  __device__ Tuple(
+      T0 _val0,
+      T1 _val1,
+      T2 _val2,
+      T3 _val3,
+      T4 _val4,
+      T5 _val5,
+      T6 _val6,
+      T7 _val7,
+      T8 _val8,
+      T9 _val9,
+      T10 _val10,
+      T11 _val11,
+      T12 _val12,
+      T13 _val13,
+      T14 _val14,
+      T15 _val15)
+      : val0(_val0),
+        val1(_val1),
+        val2(_val2),
+        val3(_val3),
+        val4(_val4),
+        val5(_val5),
+        val6(_val6),
+        val7(_val7),
+        val8(_val8),
+        val9(_val9),
+        val10(_val10),
+        val11(_val11),
+        val12(_val12),
+        val13(_val13),
+        val14(_val14),
+        val15(_val15) {}
+
+  // Only valid when instantiated for pointer types
+  __device__ void operator+=(nvfuser_index_t offset) {
+    TUPLE_INCREMENT_PTR(0);
+    TUPLE_INCREMENT_PTR(1);
+    TUPLE_INCREMENT_PTR(2);
+    TUPLE_INCREMENT_PTR(3);
+    TUPLE_INCREMENT_PTR(4);
+    TUPLE_INCREMENT_PTR(5);
+    TUPLE_INCREMENT_PTR(6);
+    TUPLE_INCREMENT_PTR(7);
+    TUPLE_INCREMENT_PTR(8);
+    TUPLE_INCREMENT_PTR(9);
+    TUPLE_INCREMENT_PTR(10);
+    TUPLE_INCREMENT_PTR(11);
+    TUPLE_INCREMENT_PTR(12);
+    TUPLE_INCREMENT_PTR(13);
+    TUPLE_INCREMENT_PTR(14);
+    TUPLE_INCREMENT_PTR(15);
+  }
+};
+
+#undef TUPLE_INCREMENT_PTR
+
+// Accessor for Tuple
+template <int idx>
+struct get;
+
+#define DEFINE_TUPLE_GET(idx)                              \
+  template <>                                              \
+  struct get<idx> {                                        \
+    template <typename Tuple>                              \
+    __device__ auto& operator()(Tuple& vals) {             \
+      return vals.val##idx;                                \
+    }                                                      \
+    template <typename Tuple>                              \
+    __device__ const auto& operator()(const Tuple& vals) { \
+      return vals.val##idx;                                \
+    }                                                      \
+  };
+
+DEFINE_TUPLE_GET(0);
+DEFINE_TUPLE_GET(1);
+DEFINE_TUPLE_GET(2);
+DEFINE_TUPLE_GET(3);
+DEFINE_TUPLE_GET(4);
+DEFINE_TUPLE_GET(5);
+DEFINE_TUPLE_GET(6);
+DEFINE_TUPLE_GET(7);
+DEFINE_TUPLE_GET(8);
+DEFINE_TUPLE_GET(9);
+DEFINE_TUPLE_GET(10);
+DEFINE_TUPLE_GET(11);
+DEFINE_TUPLE_GET(12);
+DEFINE_TUPLE_GET(13);
+DEFINE_TUPLE_GET(14);
+DEFINE_TUPLE_GET(15);
+#undef DEFINE_TUPLE_GET
+
+template <typename DstType, typename SrcType>
+__inline__ __device__ static void copyTuple(
+    DstType& dst,
+    nvfuser_index_t dst_offset,
+    const SrcType& src,
+    nvfuser_index_t src_offset = 0);
+
+template <typename DstType, typename SrcType>
+__inline__ __device__ static void copyTuple(
+    DstType& dst,
+    const SrcType& src,
+    nvfuser_index_t src_offset = 0);
+
+template <typename DstType>
+__inline__ __device__ static void setTuple(
+    DstType& dst,
+    typename DstType::template ValType<0> src);
+
+template <typename... Types>
+class LocalTuple {
+ public:
+  static constexpr int num_vals = sizeof...(Types);
+  using ValTypes = TypeList<Types...>;
+
+  template <int idx>
+  using ValType = typename TypeSelector<idx, Types...>::type;
+
+  LocalTuple() = default;
+
+  __device__ explicit LocalTuple(Types... args) : vals_(args...) {}
+
+  __device__ LocalTuple(const LocalTuple& other) : vals_(other.vals_) {}
+
+  template <template <typename...> typename TupleType>
+  __device__ LocalTuple(const TupleType<Types...>& other) {
+    copyTuple(*this, other);
+  }
+
+  __device__ LocalTuple& operator=(const LocalTuple<Types...>& other) {
+    copyTuple(*this, other);
+    return *this;
+  }
+
+  template <template <typename...> typename TupleType>
+  __device__ LocalTuple& operator=(const TupleType<Types...>& other) {
+    copyTuple(*this, other);
+    return *this;
+  }
+
+  template <int val_idx>
+  __device__ auto& val(nvfuser_index_t ptr_offset = 0) {
+    static_assert(val_idx < num_vals, "Out-of-range value index");
+    return get<val_idx>()(vals_);
+  }
+
+  template <int val_idx>
+  __device__ const auto& val(nvfuser_index_t ptr_offset = 0) const {
+    static_assert(val_idx < num_vals, "Out-of-range value index");
+    return get<val_idx>()(vals_);
+  }
+
+ private:
+  Tuple<Types...> vals_;
+};
+
+template <bool is_volatile, typename... Types>
+class PtrTupleBase {
+ public:
+  static constexpr int num_vals = sizeof...(Types);
+  using ValTypes = TypeList<Types...>;
+  template <int idx>
+  using ValType = typename TypeSelector<idx, Types...>::type;
+  template <int val_idx>
+  using TypeIMaybeVolatile = typename MaybeVolatile<
+      typename TypeSelector<val_idx, Types...>::type,
+      is_volatile>::type;
+
+  __device__ PtrTupleBase(Types*... args) : vals_(args...) {}
+
+  __device__ PtrTupleBase(const PtrTupleBase& other) : vals_(other.vals_) {}
+
+  // Note: this is a deep copy
+  __device__ PtrTupleBase& operator=(
+      const PtrTupleBase<is_volatile, Types...>& other) {
+    copyTuple(*this, other);
+    return *this;
+  }
+
+  template <template <typename...> typename TupleType>
+  __device__ PtrTupleBase& operator=(const TupleType<Types...>& other) {
+    copyTuple(*this, other);
+    return *this;
+  }
+
+  template <int val_idx>
+  __device__ TypeIMaybeVolatile<val_idx>& val(nvfuser_index_t ptr_offset = 0) {
+    static_assert(val_idx < num_vals, "Out-of-range value index");
+    return ((TypeIMaybeVolatile<val_idx>*)get<val_idx>()(vals_))[ptr_offset];
+  }
+
+  template <int val_idx>
+  __device__ const TypeIMaybeVolatile<val_idx>& val(
+      nvfuser_index_t ptr_offset = 0) const {
+    static_assert(val_idx < num_vals, "Out-of-range value index");
+    return ((TypeIMaybeVolatile<val_idx>*)get<val_idx>()(vals_))[ptr_offset];
+  }
+
+  __device__ void operator+=(nvfuser_index_t ptr_offset) {
+    vals_ += ptr_offset;
+  }
+
+ private:
+  Tuple<Types*...> vals_;
+};
+
+template <typename... Types>
+class RefTuple {
+ public:
+  static constexpr int num_vals = sizeof...(Types);
+  using ValTypes = TypeList<Types...>;
+  template <int idx>
+  using ValType = typename TypeSelector<idx, Types...>::type;
+
+  __device__ RefTuple(Types&... args) : vals_(args...) {}
+
+  __device__ RefTuple(const RefTuple& other) : vals_(other.vals_) {}
+
+  template <template <typename...> typename TupleType>
+  __device__ RefTuple(const TupleType<Types...>& other) {
+    copyTuple(*this, other);
+  }
+
+  __device__ RefTuple& operator=(const RefTuple<Types...>& other) {
+    copyTuple(*this, other);
+    return *this;
+  }
+
+  template <template <typename...> typename TupleType>
+  __device__ RefTuple& operator=(const TupleType<Types...>& other) {
+    copyTuple(*this, other);
+    return *this;
+  }
+
+  template <int val_idx>
+  __device__ auto& val(nvfuser_index_t ptr_offset = 0) {
+    static_assert(val_idx < num_vals, "Out-of-range value index");
+    return get<val_idx>()(vals_);
+  }
+
+  template <int val_idx>
+  __device__ const auto& val(nvfuser_index_t ptr_offset = 0) const {
+    static_assert(val_idx < num_vals, "Out-of-range value index");
+    return get<val_idx>()(vals_);
+  }
+
+ private:
+  Tuple<Types&...> vals_;
+};
+
+template <typename DstType, typename SrcType, int num_vals>
+struct TupleCopy {
+  __inline__ __device__ static void copy(
+      DstType& dst,
+      nvfuser_index_t dst_offset,
+      const SrcType& src,
+      nvfuser_index_t src_offset) {
+    static_assert(
+        IsSameType<typename DstType::ValTypes, typename SrcType::ValTypes>::
+            value,
+        "Invalid value types");
+    TupleCopy<DstType, SrcType, num_vals - 1>::copy(
+        dst, dst_offset, src, src_offset);
+    dst.val<num_vals - 1>(dst_offset) = src.val<num_vals - 1>(src_offset);
+  }
+};
+
+template <typename DstType, typename SrcType>
+struct TupleCopy<DstType, SrcType, 0> {
+  __inline__ __device__ static void copy(
+      DstType& dst,
+      nvfuser_index_t dst_offset,
+      const SrcType& src,
+      nvfuser_index_t src_offset) {}
+};
+
+template <typename DstType, typename SrcType>
+__inline__ __device__ static void copyTuple(
+    DstType& dst,
+    nvfuser_index_t dst_offset,
+    const SrcType& src,
+    nvfuser_index_t src_offset) {
+  static_assert(
+      IsSameType<typename DstType::ValTypes, typename SrcType::ValTypes>::value,
+      "Invalid value types");
+  TupleCopy<DstType, SrcType, DstType::num_vals>::copy(
+      dst, dst_offset, src, src_offset);
+};
+
+template <typename DstType, typename SrcType>
+__inline__ __device__ static void copyTuple(
+    DstType& dst,
+    const SrcType& src,
+    nvfuser_index_t src_offset) {
+  copyTuple<DstType, SrcType>(dst, 0, src, src_offset);
+};
+
+template <typename DstType, int num_vals>
+struct TupleSet {
+  __inline__ __device__ static void set(
+      DstType& dst,
+      nvfuser_index_t dst_offset,
+      typename DstType::template ValType<0> src) {
+    static_assert(
+        IsSameType<
+            typename DstType::template ValType<num_vals - 1>,
+            typename DstType::template ValType<0>>::value,
+        "Invalid value types");
+    TupleSet<DstType, num_vals - 1>::set(dst, dst_offset, src);
+    dst.val<num_vals - 1>(dst_offset) = src;
+  }
+};
+
+template <typename DstType>
+struct TupleSet<DstType, 0> {
+  __inline__ __device__ static void set(
+      DstType& dst,
+      nvfuser_index_t dst_offset,
+      typename DstType::template ValType<0> src) {}
+};
+
+template <typename DstType>
+__inline__ __device__ static void setTuple(
+    DstType& dst,
+    nvfuser_index_t dst_offset,
+    typename DstType::template ValType<0> src) {
+  TupleSet<DstType, DstType::num_vals>::set(dst, dst_offset, src);
+};
+
+
+template <typename DstType>
+__inline__ __device__ static void setTuple(
+    DstType& dst,
+    typename DstType::template ValType<0> src) {
+  setTuple(dst, 0, src);
+};
+
+template <typename DstType, typename SrcType, typename PredType, int num_vals>
+struct PredicatedTupleCopy {
+  __inline__ __device__ static void copy(
+      DstType& dst,
+      nvfuser_index_t dst_offset,
+      const SrcType& src,
+      nvfuser_index_t src_offset,
+      const PredType& pred) {
+    static_assert(
+        IsSameType<typename PredType::template ValType<num_vals - 1>, bool>::
+            value,
+        "Invalid predicate type");
+    PredicatedTupleCopy<DstType, SrcType, PredType, num_vals - 1>::copy(
+        dst, dst_offset, src, src_offset, pred);
+    if (pred.val<num_vals - 1>(0)) {
+      dst.val<num_vals - 1>(dst_offset) = src.val<num_vals - 1>(src_offset);
+    }
+  }
+};
+
+template <typename DstType, typename SrcType, typename PredType>
+struct PredicatedTupleCopy<DstType, SrcType, PredType, 0> {
+  __inline__ __device__ static void copy(
+      DstType& dst,
+      nvfuser_index_t dst_offset,
+      const SrcType& src,
+      nvfuser_index_t src_offset,
+      const PredType& pred) {}
+};
+
+template <typename DstType, typename SrcType, typename PredType>
+__inline__ __device__ static void copyTupleIf(
+    DstType& dst,
+    nvfuser_index_t dst_offset,
+    const SrcType& src,
+    nvfuser_index_t src_offset,
+    const PredType& pred) {
+  static_assert(
+      IsSameType<typename DstType::ValTypes, typename SrcType::ValTypes>::value,
+      "Invalid value types");
+  static_assert(
+      PredType::num_vals == DstType::num_vals, "Invalid predicate type");
+  PredicatedTupleCopy<DstType, SrcType, PredType, DstType::num_vals>::copy(
+      dst, dst_offset, src, src_offset, pred);
+};
+
+template <typename DstType, typename SrcType, typename PredType>
+__inline__ __device__ static void copyTupleIf(
+    DstType& dst,
+    const SrcType& src,
+    nvfuser_index_t src_offset,
+    const PredType& pred) {
+  copyTupleIf(dst, 0, src, src_offset, pred);
+};
+
+template <typename DstType, typename SrcType, typename PredType>
+__inline__ __device__ static void copyTupleIf(
+    DstType& dst,
+    const SrcType& src,
+    const PredType& pred) {
+  copyTupleIf(dst, 0, src, 0, pred);
+};
+
+// Can a generic const and non-const RefTupe be defined?
+template <typename... Types>
+class ConstRefTuple {
+ public:
+  static constexpr int num_vals = sizeof...(Types);
+  using ValTypes = TypeList<Types...>;
+
+  __device__ ConstRefTuple(const Types&... args) : vals_(args...) {}
+
+  __device__ ConstRefTuple(const ConstRefTuple& other) : vals_(other.vals_) {}
+
+  template <template <typename...> typename TupleType>
+  __device__ ConstRefTuple(const TupleType<Types...>& other) {
+    copyTuple(*this, other);
+  }
+
+  template <int val_idx>
+  __device__ const auto& val(nvfuser_index_t ptr_offset = 0) const {
+    static_assert(val_idx < num_vals, "Out-of-range value index");
+    return get<val_idx>()(vals_);
+  }
+
+ private:
+  Tuple<const Types&...> vals_;
+};
+
+template <typename... Types>
+using PtrTuple = PtrTupleBase<false, Types...>;
+
+template <typename... Types>
+using VolatilePtrTuple = PtrTupleBase<true, Types...>;
+
+// Define a LocalTuple of NumVals values of type Type
+template <int NumVals, typename Type>
+struct MakeLocalTuple;
+
+template <typename Type>
+struct MakeLocalTuple<1, Type> {
+  using type = LocalTuple<Type>;
+};
+
+template <typename Type>
+struct MakeLocalTuple<2, Type> {
+  using type = LocalTuple<Type, Type>;
+};
+
+template <typename Type>
+struct MakeLocalTuple<3, Type> {
+  using type = LocalTuple<Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeLocalTuple<4, Type> {
+  using type = LocalTuple<Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeLocalTuple<5, Type> {
+  using type = LocalTuple<Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeLocalTuple<6, Type> {
+  using type = LocalTuple<Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeLocalTuple<7, Type> {
+  using type = LocalTuple<Type, Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeLocalTuple<8, Type> {
+  using type = LocalTuple<Type, Type, Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeLocalTuple<16, Type> {
+  using type = LocalTuple<
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type>;
+};
+
+template <int NumVals, typename Type>
+struct MakeRefTuple;
+
+template <typename Type>
+struct MakeRefTuple<1, Type> {
+  using type = RefTuple<Type>;
+};
+
+template <typename Type>
+struct MakeRefTuple<2, Type> {
+  using type = RefTuple<Type, Type>;
+};
+
+template <typename Type>
+struct MakeRefTuple<3, Type> {
+  using type = RefTuple<Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeRefTuple<4, Type> {
+  using type = RefTuple<Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeRefTuple<5, Type> {
+  using type = RefTuple<Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeRefTuple<6, Type> {
+  using type = RefTuple<Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeRefTuple<7, Type> {
+  using type = RefTuple<Type, Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeRefTuple<8, Type> {
+  using type = RefTuple<Type, Type, Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeRefTuple<16, Type> {
+  using type = RefTuple<
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type>;
+};
+
+template <int NumVals, typename Type>
+struct MakeConstRefTuple;
+
+template <typename Type>
+struct MakeConstRefTuple<1, Type> {
+  using type = ConstRefTuple<Type>;
+};
+
+template <typename Type>
+struct MakeConstRefTuple<2, Type> {
+  using type = ConstRefTuple<Type, Type>;
+};
+
+template <typename Type>
+struct MakeConstRefTuple<3, Type> {
+  using type = ConstRefTuple<Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeConstRefTuple<4, Type> {
+  using type = ConstRefTuple<Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeConstRefTuple<5, Type> {
+  using type = ConstRefTuple<Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeConstRefTuple<6, Type> {
+  using type = ConstRefTuple<Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeConstRefTuple<7, Type> {
+  using type = ConstRefTuple<Type, Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeConstRefTuple<8, Type> {
+  using type = ConstRefTuple<Type, Type, Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeConstRefTuple<16, Type> {
+  using type = ConstRefTuple<
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type>;
+};
+
+template <int NumVals, typename Type>
+struct MakeVolatilePtrTuple;
+
+template <typename Type>
+struct MakeVolatilePtrTuple<1, Type> {
+  using type = VolatilePtrTuple<Type>;
+};
+
+template <typename Type>
+struct MakeVolatilePtrTuple<2, Type> {
+  using type = VolatilePtrTuple<Type, Type>;
+};
+
+template <typename Type>
+struct MakeVolatilePtrTuple<3, Type> {
+  using type = VolatilePtrTuple<Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeVolatilePtrTuple<4, Type> {
+  using type = VolatilePtrTuple<Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeVolatilePtrTuple<5, Type> {
+  using type = VolatilePtrTuple<Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeVolatilePtrTuple<6, Type> {
+  using type = VolatilePtrTuple<Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeVolatilePtrTuple<7, Type> {
+  using type = VolatilePtrTuple<Type, Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeVolatilePtrTuple<8, Type> {
+  using type = VolatilePtrTuple<Type, Type, Type, Type, Type, Type, Type, Type>;
+};
+
+template <typename Type>
+struct MakeVolatilePtrTuple<16, Type> {
+  using type = VolatilePtrTuple<
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type,
+      Type>;
+};
+
+// Utility definitions. Currently only used with LocalTuple
+
+template <int idx, typename BinaryFunc, typename... DataTypes>
+struct TupleBinaryOp {
+  static __inline__ __device__ void apply(
+      BinaryFunc func,
+      const LocalTuple<DataTypes...>& lhs,
+      const LocalTuple<DataTypes...>& rhs,
+      LocalTuple<DataTypes...>& result) {
+    TupleBinaryOp<idx - 1, BinaryFunc, DataTypes...>::apply(
+        func, lhs, rhs, result);
+    result.val<idx - 1>(0) = func(lhs.val<idx - 1>(0), rhs.val<idx - 1>(0));
+  }
+};
+
+template <typename BinaryFunc, typename... DataTypes>
+struct TupleBinaryOp<0, BinaryFunc, DataTypes...> {
+  static __inline__ __device__ void apply(
+      BinaryFunc func,
+      const LocalTuple<DataTypes...>& lhs,
+      const LocalTuple<DataTypes...>& rhs,
+      LocalTuple<DataTypes...>& result) {}
+};
+
+template <typename BinaryFunc, typename... DataTypes>
+__inline__ __device__ LocalTuple<DataTypes...> apply(
+    BinaryFunc func,
+    const LocalTuple<DataTypes...>& lhs,
+    const LocalTuple<DataTypes...>& rhs) {
+  LocalTuple<DataTypes...> result = lhs;
+  TupleBinaryOp<sizeof...(DataTypes), BinaryFunc, DataTypes...>::apply(
+      func, result, rhs, result);
+  return result;
+}
+
+template <typename... BoolTypes>
+__inline__ __device__ LocalTuple<BoolTypes...> operator&&(
+    const LocalTuple<BoolTypes...>& lhs,
+    const LocalTuple<BoolTypes...>& rhs) {
+  return apply([](bool x, bool y) { return x && y; }, lhs, rhs);
+}
+
+template <typename... BoolTypes>
+__inline__ __device__ LocalTuple<BoolTypes...> operator&&(
+    bool lhs,
+    const LocalTuple<BoolTypes...>& rhs) {
+  LocalTuple<BoolTypes...> lhs_tuple;
+  setTuple(lhs_tuple, lhs);
+  return lhs_tuple && rhs;
+}
+
+template <typename... BoolTypes>
+__inline__ __device__ LocalTuple<BoolTypes...> operator&&(
+    const LocalTuple<BoolTypes...>& lhs,
+    bool rhs) {
+  LocalTuple<BoolTypes...> rhs_tuple;
+  setTuple(rhs_tuple, rhs);
+  return lhs && rhs_tuple;
+}
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+
+// Basically just blockDim, but wrapped as a struct so that we have a mechanism
+// to know at compile time that whether we are just using blockDim or some
+// custom value. For a kernel without warp specialization, we just use blockDim,
+// but for a kernel with warp specialization, we use a custom block_dim whose
+// dimension are the dimensions of the compute warps.
+struct DefaultBlockDim {
+  const uint32_t x, y, z;
+  __device__ DefaultBlockDim() : x(blockDim.x), y(blockDim.y), z(blockDim.z) {}
+  __device__ operator dim3() const {
+    return blockDim;
+  }
+};
+
+// Default block synchronization. Just use __barrier_sync
+namespace block_sync {
+
+__forceinline__ __device__ void init() {}
+
+// Thread-block synchronization
+template <bool aligned, typename BlockDimT>
+__forceinline__ __device__ void sync(BlockDimT block_dim) {
+  if constexpr (aligned) {
+    __syncthreads();
+  } else if constexpr (std::is_same_v<BlockDimT, DefaultBlockDim>) {
+    __barrier_sync(0);
+  } else {
+    uint32_t num_threads = block_dim.x * block_dim.y * block_dim.z;
+    asm volatile("bar.sync 0, %0;" : : "r"(num_threads) : "memory");
+  }
+}
+
+} // namespace block_sync
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+namespace grid_sync {
+
+// Get the first bit in a 64 bit integer
+#define FIRST_UINT64_BIT ((uint64_t)1 << (sizeof(uint64_t) * 8 - 1))
+
+template <typename T>
+__device__ T globalAsVolatile(volatile T& global_val) {
+  return global_val;
+}
+
+// A grid synchronization that can be called multiple times in a kernel assuming
+// all the blocks fit on device at once. The semaphore is an integer semaphore
+// assumed to be initialized to 0 before launching the kernel. The persistent
+// option should be envoked if this sync will be called multiple times in one
+// kernel (i.e. having a grid reduce within a loop). Having multiple grid syncs
+// called once in the same kernel does not require persistent mode. Segment size
+// is the number of blocks participating in the sync in the dimensions marked by
+// [X,Y,Z]_BLOCK. The granularity of this sync are those dimensions. I.E.
+// Marking X and Y but not Z means there should be Z semaphores of size X*Y.
+template <
+    bool X_BLOCK,
+    bool Y_BLOCK,
+    bool Z_BLOCK,
+    bool PERSISTENT,
+    bool Aligned,
+    typename BlockDimT>
+__device__ void sync(
+    int64_t& semaphore,
+    const uint64_t& segment_size,
+    const bool last_block,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  // Finish all global memory transactions before synchronizing
+  __threadfence();
+
+  // Synchronize all threads in a block before synchronizing blocks
+  block_sync::sync<Aligned>(block_dim);
+
+  // Only allow linear_tid == 0 to participate in the synchronization
+  if (threadIdx.x == 0 && threadIdx.y == 0 && threadIdx.z == 0) {
+    // Get increment value, only want a single block to have the large
+    // increment, doesn't really matter which one, the goal is to flip/flop the
+    // first bit of a uint64_t value, since our semaphores are actualy int64_t
+    // we will just reinterpret_cast it to act as a uint64_t
+    uint64_t semaphore_increment = 1;
+
+    // Makes the assumption that blocks are in increasing order, this is not
+    // guaranteed by CUDA but this is the current behavior, and unlikely to
+    // change.
+    if (last_block) {
+      semaphore_increment = FIRST_UINT64_BIT - (segment_size - 1);
+    }
+
+    uint64_t oldArrive =
+        atomicAdd(reinterpret_cast<uint64_t*>(&semaphore), semaphore_increment);
+
+    // If for persistent kernels, lock all blocks until the semaphore has been
+    // reached. Make sure we access semaphore as a volatile address so we get
+    // the global memory updates.
+    unsigned int ns = 8;
+    while ((PERSISTENT || last_block) &&
+           ((oldArrive ^ globalAsVolatile(semaphore)) & FIRST_UINT64_BIT) ==
+               0) {
+      // Put a sleep here so we have some breaks in probing the global
+      // semaphore, giving a better chance for other warps/blocks to catch up.
+#if __CUDA_ARCH__ >= 700
+      // __nanosleep only available on compute capability 7.0 or higher
+      __nanosleep(ns); // avoids busy waiting
+      if (ns < 256) {
+        ns *= 2;
+      }
+#endif
+    }
+  }
+
+  // Sync block to make sure all other threads are waiting on the sync
+  block_sync::sync<Aligned>(block_dim);
+}
+
+template <
+    bool X_BLOCK,
+    bool Y_BLOCK,
+    bool Z_BLOCK,
+    bool PERSISTENT,
+    bool Aligned,
+    typename BlockDimT>
+__device__ void sync(
+    int64_t& semaphore,
+    const uint64_t& segment_size,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT, Aligned>(
+      semaphore,
+      segment_size,
+      index_utils::maskedIsLast<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim),
+      block_dim);
+}
+
+// Grid sync that can be called multiple times in the same kernel without all
+// blocks being resident on device. This allows grid sync to be called multiple
+// times as long as it's not broadcasted on the parallel axis it was reduced on.
+//
+// n_entrances is how many times every block is expected to enter into this
+// function. All blocks must enter n_entrances times. The last block is only
+// allowed to proceed once all other blocks have entered n_entrance
+// times.
+//
+// Note that this is not currently used by grid and welford reduction
+// as they use a separate sync flag for each each grid sync call.
+template <
+    bool X_BLOCK,
+    bool Y_BLOCK,
+    bool Z_BLOCK,
+    bool Aligned,
+    typename BlockDimT>
+__device__ void sync(
+    int64_t& semaphore,
+    const uint64_t& segment_size,
+    const nvfuser_index_t n_entrances,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  // Finish all global memory transactions before synchronizing
+  __threadfence();
+
+  // Synchronize all threads in a block before synchronizing blocks
+  block_sync::sync<Aligned>(block_dim);
+
+  // Only allow linear_tid == 0 to participate in the synchronization
+  if (threadIdx.x == 0 && threadIdx.y == 0 && threadIdx.z == 0) {
+    // Makes the assumption that blocks are in increasing order, this is not
+    // guaranteed by CUDA but this is the current behavior, and unlikely to
+    // change.
+    bool last_block =
+        index_utils::maskedIsLast<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim);
+    if (last_block) {
+      int64_t finished_val =
+          ((int64_t)(index_utils::maskedSize<X_BLOCK, Y_BLOCK, Z_BLOCK>(
+                         gridDim) -
+                     1)) *
+          ((int64_t)n_entrances);
+
+      unsigned int ns = 8;
+      // Last block needs to wait for all other blocks to finish
+      while (globalAsVolatile(semaphore) < finished_val) {
+#if __CUDA_ARCH__ >= 700
+        // __nanosleep only available on compute capability 7.0 or higher
+        __nanosleep(ns); // avoids busy waiting
+        if (ns < 256) {
+          ns *= 2;
+        }
+#endif
+      }
+    } else {
+      auto old = atomicAdd(reinterpret_cast<uint64_t*>(&semaphore), 1);
+    }
+  }
+
+  // Sync block to make sure all other threads are waiting on the sync
+  block_sync::sync<Aligned>(block_dim);
+}
+
+// Non-blocking function to read the semaphore value in each calling thread
+__device__ int64_t semaphoreFetch(int64_t* semaphore) {
+  int64_t state;
+  // NOTE: acquire/release operations require sm_70 or higher
+  // https://docs.nvidia.com/cuda/archive/12.3.0/parallel-thread-execution/index.html#scopes-and-applicability
+  asm volatile("ld.global.acquire.gpu.b64 %0, [%1];\n"
+               : "=l"(state)
+               : "l"(semaphore));
+  return state;
+}
+
+// Non-blocking function to set semaphore to new_value
+__device__ void semaphoreRelease(int64_t* semaphore, int64_t new_value) {
+  if (threadIdx.x == 0 && threadIdx.y == 0 && threadIdx.z == 0) {
+    // NOTE: acquire/release operations require sm_70 or higher
+    // https://docs.nvidia.com/cuda/archive/12.3.0/parallel-thread-execution/index.html#scopes-and-applicability
+    asm volatile("st.global.release.gpu.b64 [%0], %1;\n"
+                 :
+                 : "l"(semaphore), "l"(new_value));
+  }
+}
+
+// First thread waits until fetched semaphore value matches trigger
+__device__ void semaphoreWait(int64_t* semaphore, int64_t trigger_value) {
+  int64_t status = -1;
+  // Cutlass uses a loop like this, and has a facility where any thread can
+  // fetch the semaphore value ahead of waiting. This could reduce the wait
+  // time potentially but requires placement of the early fetch.
+  // https://github.com/NVIDIA/cutlass/blob/main/include/cutlass/semaphore.h
+  // while (__syncthreads_and(status != trigger_value)) {
+  // As soon as any thread in the block observes the trigger then it is
+  // safe to proceed
+  // Instead, we simply use the first thread in the block to do busy waiting.
+  if (threadIdx.x == 0 && threadIdx.y == 0 && threadIdx.z == 0) {
+    while (status != trigger_value) {
+      status = semaphoreFetch(semaphore);
+    }
+  }
+}
+
+// Serialize blocks in segments indicated by the [XYZ]_BLOCK template arguments.
+// This should be called at the beginning of the section to be serialized.
+// Assumes semaphore is initialized to zero. This function always synchronizes
+// the thread block.
+template <bool X_BLOCK, bool Y_BLOCK, bool Z_BLOCK>
+__device__ void blockSerializeWait(int64_t* semaphore) {
+  int segment_size =
+      index_utils::maskedSize<X_BLOCK, Y_BLOCK, Z_BLOCK>(gridDim);
+  int block_idx_in_segment =
+      index_utils::maskedOffset<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim);
+
+  if (block_idx_in_segment > 0) {
+    semaphoreWait(semaphore, block_idx_in_segment);
+  }
+  __syncthreads();
+}
+
+// Serialize blocks in segments indicated by the [XYZ]_BLOCK template arguments.
+// This should be called at the end of the section to be serialized.
+// This function always cleans up the semaphore; i.e. the last block writes the
+// value 0 to the semaphore when complete. This function always synchronizes
+// the thread block.
+template <bool X_BLOCK, bool Y_BLOCK, bool Z_BLOCK>
+__device__ void blockSerializeRelease(int64_t* semaphore) {
+  int segment_size =
+      index_utils::maskedSize<X_BLOCK, Y_BLOCK, Z_BLOCK>(gridDim);
+  int block_idx_in_segment =
+      index_utils::maskedOffset<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim);
+  bool last_block = block_idx_in_segment == segment_size - 1;
+
+  // Block until writes from all threads in this block are visible to all other
+  // blocks before releasing semaphore using thread 0.
+  //
+  // Consider this simple example using two blocks:
+  //
+  //   1. Block 1 acquires lock using blockSerializeWait
+  //   2. Block 1 writes values to tensor T3
+  //   3. Block 1 releases lock using blockSerializeRelease
+  //   4. Block 2 acquires lock using blockSerializeWait
+  //   5. Block 2 uses values in tensor T3 to compute new values and writes them
+  //      back to T3.
+  //   6. Block 2 releases lock using blockSerializeRelease
+  //
+  // Without a global thread fence, the writes to T3 from Block 1 in step 2
+  // might not be visible to Block 2 at step 5, meaning Block 2 would compute
+  // an invalid update.
+  //
+  // We use __syncthreads also, which implies a __threadfence_block but that
+  // only guarantees that all writes are visible to threads _within the same
+  // block_, so the __threadfence is still needed.
+  __threadfence();
+  __syncthreads();
+
+  semaphoreRelease(semaphore, last_block ? 0 : block_idx_in_segment + 1);
+}
+
+} // namespace grid_sync
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+
+// Reference:
+// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#asynchronous-barrier
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#parallel-synchronization-and-communication-instructions-mbarrier
+// https://github.com/NVIDIA/cutlass/blob/main/include/cute/arch/copy_sm90_desc.hpp
+
+#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 800))
+
+namespace mbarrier {
+
+__device__ inline void init(
+    uint32_t smem_barrier_ptr,
+    uint32_t thread_count = 1) {
+  asm volatile(
+      "mbarrier.init.shared.b64 [%0], %1;\n" ::"r"(smem_barrier_ptr),
+      "r"(thread_count));
+}
+
+__device__ inline void inval(uint32_t smem_barrier_ptr) {
+  asm volatile("mbarrier.inval.shared.b64 [%0];\n" ::"r"(smem_barrier_ptr));
+}
+
+__device__ inline uint64_t arrive(uint32_t smem_barrier_ptr) {
+  volatile uint64_t state;
+  asm volatile("mbarrier.arrive.shared.b64 %0, [%1];\n"
+               : "=l"(state)
+               : "r"(smem_barrier_ptr));
+  return state;
+}
+
+#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 900))
+__device__ inline uint64_t arriveExpectTX(
+    uint32_t smem_barrier_ptr,
+    uint32_t tx_count) {
+  volatile uint64_t state;
+  asm volatile("mbarrier.arrive.expect_tx.shared.b64 %0, [%1], %2;\n"
+               : "=l"(state)
+               : "r"(smem_barrier_ptr), "r"(tx_count));
+  return state;
+}
+#endif
+
+__device__ inline void wait(uint32_t smem_barrier_ptr, uint64_t state) {
+#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 900))
+  asm volatile(
+      "{\n"
+      ".reg .pred                complete;\n"
+      "waitLoop:\n"
+      "mbarrier.try_wait.shared.b64 complete, [%0], %1;\n"
+      "@!complete bra waitLoop;\n"
+      "}\n" ::"r"(smem_barrier_ptr),
+      "l"(state));
+#else
+  asm volatile(
+      "{\n"
+      ".reg .pred                P1;\n"
+      "LAB_WAIT:\n"
+      "mbarrier.test_wait.shared.b64 P1, [%0], %1;\n"
+      "@P1                       bra.uni DONE;\n"
+      "nanosleep.u32 20;\n"
+      "bra.uni                   LAB_WAIT;\n"
+      "DONE:\n"
+      "}\n" ::"r"(smem_barrier_ptr),
+      "l"(state));
+#endif
+}
+
+__device__ inline void waitParity(uint32_t smem_barrier_ptr, uint32_t parity) {
+#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 900))
+  asm volatile(
+      "{\n"
+      ".reg .pred                complete;\n"
+      "waitLoop:\n"
+      "mbarrier.try_wait.parity.shared.b64 complete, [%0], %1;\n"
+      "@!complete bra waitLoop;\n"
+      "}\n" ::"r"(smem_barrier_ptr),
+      "r"(parity));
+#else
+  asm volatile(
+      "{\n"
+      ".reg .pred                P1;\n"
+      "LAB_WAIT:\n"
+      "mbarrier.test_wait.parity.shared.b64 P1, [%0], %1;\n"
+      "@P1                       bra.uni DONE;\n"
+      "nanosleep.u32 20;\n"
+      "bra.uni                   LAB_WAIT;\n"
+      "DONE:\n"
+      "}\n" ::"r"(smem_barrier_ptr),
+      "r"(parity));
+#endif
+}
+
+} // namespace mbarrier
+
+#endif // (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 800))
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+// [Z,Y,X]_THREADS is the number of participating threads in the z, y, x
+// dimension of the block. If set to false the dimension doesn't
+// participate in the reduction. We could start with warp reductions, then
+// reduce the warps, this could save some shared memory, but could be slower in
+// some instances.
+//
+//  EXAMPLE USAGE:
+//  blockReduceSum<X_THREADS, Y_THREADS, Z_THREADS>
+//    (output[output_index], inputs[input_index],
+//      [] __device__ (T& a, const T b) { a += b; });
+template <
+    bool X_REDUCE,
+    bool Y_REDUCE,
+    bool Z_REDUCE,
+    bool Aligned,
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void blockReduce(
+    T& out,
+    const T& inp_val,
+    Func reduction_op,
+    T* shared_mem,
+    bool read_pred,
+    bool write_pred,
+    T init_val,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  // If this thread will output a final result
+  bool should_write =
+      index_utils::maskedIsZero<X_REDUCE, Y_REDUCE, Z_REDUCE>(threadIdx);
+
+  // Size of the reduction segments
+  unsigned int reduction_size =
+      index_utils::maskedSize<X_REDUCE, Y_REDUCE, Z_REDUCE>(block_dim);
+
+  // Index into the reduction segment
+  unsigned int reduction_tid =
+      index_utils::maskedOffset<X_REDUCE, Y_REDUCE, Z_REDUCE>(
+          threadIdx, block_dim);
+
+  // Index of the reduction segment
+  unsigned int reduction_idx =
+      index_utils::maskedOffset<!X_REDUCE, !Y_REDUCE, !Z_REDUCE>(
+          threadIdx, block_dim);
+
+  // number of reductions per block
+  unsigned int reduction_num =
+      index_utils::maskedSize<!X_REDUCE, !Y_REDUCE, !Z_REDUCE>(block_dim);
+
+  // smem_offset is the offset into shared memory for the current thread.
+  // To ensure coalesced access to shared memory, we need to ensure
+  // each transaction is accessing a contiguous block of 128 bytes.
+  // For outer reduction where TIDy is in the reduction dimension and TIDx
+  // is in the iteration dimension and TIDz is not used. We have
+  // reduction_tid = TIDy and reduction_idx = TIDx. If we directly use the
+  // offset based on reduction_tid and reduction_idx, we will have stride
+  // access to shared memory. For example:
+  // offset = reduction_idx * reduction_size + reduction_tid
+  //        = TIDx * blockDim.y + TIDy
+  // To avoid this, we should always use the offset based on the indexing of
+  // threads within a block.
+  // Offset into smem for the current thread
+  unsigned int smem_offset = threadIdx.x + threadIdx.y * block_dim.x +
+      threadIdx.z * block_dim.x * block_dim.y;
+
+  // The peer stride represents the distance between the current element and its
+  // nearest reduction peer. It depends on the reduction dimension. A reduction
+  // peer refers to elements that belong to the same reduction segment. For
+  // example, if the reduction is across TIDy, all the elements in the same
+  // column (with the same TIDx) are considered peers of each other. The
+  // distance between an element and its nearest peer is block_dim.x.
+  constexpr int num_redu_dims = (int)X_REDUCE + (int)Y_REDUCE + (int)Z_REDUCE;
+  constexpr bool xz_reduce = (num_redu_dims == 2 && !Y_REDUCE);
+  // reduction in 3 dimensions, XYZ, stride is 1
+  unsigned int peer_stride = 1;
+  if (num_redu_dims == 1) {
+    // Reduction only in 1 dimension, X or Y or Z
+    // e.g. inner or outer reduction
+    // If X_REDUCE, reducing in neighbor cols in smem, peer_stride is 1
+    // If Y_REDUCE, reducing in neighbor rows in smem, peer_stride is
+    // block_dim.x If Z_REDUCE, reducing in neighbor planes in smem, peer_stride
+    // is block_dim.x * block_dim.y
+    peer_stride = X_REDUCE ? 1
+        : Y_REDUCE         ? block_dim.x
+                           : block_dim.x * block_dim.y;
+  } else if (num_redu_dims == 2) {
+    // Reduction in 2 dimensions, only one dimension is not reduced, !X, !Y, !Z
+    // If !Z_REDUCE, merge XY, reducing neighbor cols, peer_stride is 1
+    // If !X_REDUCE, merge ZY, reducing neighbor rows, peer_stride is
+    // block_dim.x If !Y_REDUCE, if block_dim.y == 1, merge XZ, peer_stride
+    // is 1. otherwise, needs carefully calculate offset to the reduction peer:
+    // (1) redu_offset = reduction_tid + tree_fold_factor
+    // (2) idz = redu_offset / block_dim.x
+    // (3) idx = redu_offset % block_dim.x
+    // (4) smem_offset = idx + threadIdx.y * block_dim.x + idz * block_dim.x *
+    // block_dim.y
+    if (!Y_REDUCE) {
+      peer_stride = 1;
+    } else {
+      peer_stride = !Z_REDUCE ? 1 : block_dim.x;
+    }
+  }
+
+  // Initialize shared memory
+  if (read_pred) {
+    shared_mem[smem_offset] = inp_val;
+  } else {
+    shared_mem[smem_offset] = init_val;
+  }
+  block_sync::sync<Aligned>(block_dim);
+
+  // Reduce down to nearest power of 2 for the tree reduction:
+  int np2 = 1 << (31 - __clz(reduction_size));
+  if (reduction_tid < np2 && reduction_tid + np2 < reduction_size) {
+    int peer_offset = smem_offset + np2 * peer_stride;
+    if constexpr (xz_reduce) {
+      if (block_dim.y > 1) {
+        int redu_offset = reduction_tid + np2;
+        int idz = redu_offset / block_dim.x;
+        int idx = redu_offset % block_dim.x;
+        peer_offset =
+            idx + threadIdx.y * block_dim.x + idz * block_dim.x * block_dim.y;
+      }
+    }
+    reduction_op(shared_mem[smem_offset], shared_mem[peer_offset]);
+  }
+  block_sync::sync<Aligned>(block_dim);
+
+  // loop peel the final iteration to save one syncthread for the end
+  for (int factor = np2 / 2; factor > 1; factor >>= 1) {
+    if (reduction_tid < factor) {
+      int peer_offset = smem_offset + factor * peer_stride;
+      if constexpr (xz_reduce) {
+        if (block_dim.y > 1) {
+          int redu_offset = reduction_tid + factor;
+          int idz = redu_offset / block_dim.x;
+          int idx = redu_offset % block_dim.x;
+          peer_offset =
+              idx + threadIdx.y * block_dim.x + idz * block_dim.x * block_dim.y;
+        }
+      }
+      reduction_op(shared_mem[smem_offset], shared_mem[peer_offset]);
+    }
+    block_sync::sync<Aligned>(block_dim);
+  }
+
+  if (should_write && write_pred) {
+    T result = out;
+    reduction_op(result, shared_mem[smem_offset]);
+    if (reduction_size > 1) {
+      reduction_op(result, shared_mem[smem_offset + peer_stride]);
+    }
+    out = result;
+  }
+  block_sync::sync<Aligned>(block_dim);
+}
+
+// Use the same pred for both reads and writes
+template <
+    bool X_REDUCE,
+    bool Y_REDUCE,
+    bool Z_REDUCE,
+    bool Aligned,
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void blockReduce(
+    T& out,
+    const T& inp_val,
+    Func reduction_op,
+    T* shared_mem,
+    bool read_write_pred,
+    T init_val,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  blockReduce<X_REDUCE, Y_REDUCE, Z_REDUCE, Aligned, T, Func>(
+      out,
+      inp_val,
+      reduction_op,
+      shared_mem,
+      read_write_pred,
+      read_write_pred,
+      init_val,
+      block_dim);
+}
+
+// Each thread in the iteration dimension processes N elements
+// Typical usage is in outer reduction where the iteration dimension
+// is parallelized by vectorized loads, bidmx. The reduction dimension
+// is parallelized by bdimy. This function works as follows:
+// (1) Each thread vectorized loads N elements from input register array to
+// smem. (2) do N * bdimx parallel reductions in smem.
+template <
+    bool Aligned,
+    int N, // Number of elements per input array
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void blockIterGroupedYdimReduce(
+    T out[N],
+    const T inp_val[N],
+    Func reduction_op,
+    T* shared_mem,
+    bool read_pred,
+    bool write_pred,
+    T init_val,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  // N should be a valid vectorization factor
+  static_assert(
+      N == 2 || N == 4 || N == 8 || N == 16,
+      "N should be a valid vectorization factor, one of (2, 4, 8, 16)!");
+
+  bool should_write = threadIdx.y == 0;
+  unsigned int reduction_size = block_dim.y;
+  unsigned int reduction_tid = threadIdx.y;
+
+  // In shared memory, each row has 128 bytes, if sizeof(T) * N = 32 bytes, each
+  // row has 128 / 32 = 4 threads. Each transaction can only load data from one
+  // row, with a max of 16 bytes per thread. So the total bytes per transaction
+  // is 4 x 16 = 64 bytes which is only half of the maximum 128 bytes per
+  // transaction. we should change the layout from [TIDy, TIDx, N] to [N/4,
+  // TIDy, TIDx, 4]
+  constexpr unsigned int array_bytes = sizeof(T) * N;
+  constexpr unsigned int total_loads =
+      array_bytes / 16 > 1 ? array_bytes / 16 : 1;
+  constexpr unsigned int elements_per_load =
+      16 / sizeof(T) > N ? N : 16 / sizeof(T);
+  constexpr unsigned int align_size = array_bytes > 16 ? 16 : array_bytes;
+
+  // assume TIDy is the reduction dimension, TIDx is the iteration dimension
+  // TIDz is not used
+  unsigned int peer_stride = elements_per_load * block_dim.x;
+
+  unsigned int smem_offset_inter =
+      block_dim.x * block_dim.y * elements_per_load;
+  unsigned int smem_offset_intra =
+      (threadIdx.y * block_dim.x + threadIdx.x) * elements_per_load;
+
+// load to [total_loads] sections of shared memory
+#pragma unroll
+  for (unsigned int i = 0; i < total_loads; ++i) {
+    loadGeneric<T, elements_per_load>(
+        shared_mem + smem_offset_inter * i + smem_offset_intra,
+        const_cast<T*>(inp_val) + i * elements_per_load);
+  }
+  block_sync::sync<Aligned>(block_dim);
+
+  // Reduce down to nearest power of 2 for the tree reduction:
+  // Perform parallel reduction for each element in the array
+  int np2 = 1 << (31 - __clz(reduction_size));
+  if (reduction_tid < np2 && reduction_tid + np2 < reduction_size) {
+    // vectorized load from smem to regs
+    __align__(align_size) T self[N];
+    __align__(align_size) T peer[N];
+#pragma unroll
+    for (unsigned int i = 0; i < total_loads; ++i) {
+      int self_offset = smem_offset_inter * i + smem_offset_intra;
+      int peer_offset = self_offset + np2 * peer_stride;
+      loadGeneric<T, elements_per_load>(
+          self + i * elements_per_load, shared_mem + self_offset);
+      loadGeneric<T, elements_per_load>(
+          peer + i * elements_per_load, shared_mem + peer_offset);
+    }
+// reduction
+#pragma unroll
+    for (int i = 0; i < N; ++i) {
+      reduction_op(self[i], peer[i]);
+    }
+// write self back to smem
+#pragma unroll
+    for (unsigned int i = 0; i < total_loads; ++i) {
+      int self_offset = smem_offset_inter * i + smem_offset_intra;
+      loadGeneric<T, elements_per_load>(
+          shared_mem + self_offset, self + i * elements_per_load);
+    }
+  }
+  block_sync::sync<Aligned>(block_dim);
+
+  // Tree reduction
+  for (int factor = np2 / 2; factor > 1; factor >>= 1) {
+    if (reduction_tid < factor) {
+      // vectorized load from smem to regs
+      __align__(align_size) T self[N];
+      __align__(align_size) T peer[N];
+#pragma unroll
+      for (unsigned int i = 0; i < total_loads; ++i) {
+        int self_offset = smem_offset_inter * i + smem_offset_intra;
+        int peer_offset = self_offset + factor * peer_stride;
+        loadGeneric<T, elements_per_load>(
+            self + i * elements_per_load, shared_mem + self_offset);
+        loadGeneric<T, elements_per_load>(
+            peer + i * elements_per_load, shared_mem + peer_offset);
+      }
+// reduction
+#pragma unroll
+      for (int i = 0; i < N; ++i) {
+        reduction_op(self[i], peer[i]);
+      }
+// write self back to smem
+#pragma unroll
+      for (unsigned int i = 0; i < total_loads; ++i) {
+        int self_offset = smem_offset_inter * i + smem_offset_intra;
+        loadGeneric<T, elements_per_load>(
+            shared_mem + self_offset, self + i * elements_per_load);
+      }
+    }
+    block_sync::sync<Aligned>(block_dim);
+  }
+
+  // last reduction
+  if (should_write && write_pred) {
+    // init result
+    __align__(align_size) T result[N];
+#pragma unroll
+    for (int i = 0; i < N; ++i) {
+      result[i] = out[i];
+    }
+
+    // copy first element to result
+    __align__(align_size) T self[N];
+#pragma unroll
+    for (unsigned int i = 0; i < total_loads; ++i) {
+      int self_offset = smem_offset_inter * i + smem_offset_intra;
+      loadGeneric<T, elements_per_load>(
+          self + i * elements_per_load, shared_mem + self_offset);
+    }
+#pragma unroll
+    for (int i = 0; i < N; ++i) {
+      reduction_op(result[i], self[i]);
+    }
+
+    // reduction of the 2nd last element
+    if (reduction_size > 1) {
+      __align__(align_size) T peer[N];
+#pragma unroll
+      for (unsigned int i = 0; i < total_loads; ++i) {
+        int peer_offset =
+            smem_offset_inter * i + smem_offset_intra + peer_stride;
+        loadGeneric<T, elements_per_load>(
+            peer + i * elements_per_load, shared_mem + peer_offset);
+      }
+#pragma unroll
+      for (int i = 0; i < N; ++i) {
+        reduction_op(result[i], peer[i]);
+      }
+    }
+#pragma unroll
+    for (int i = 0; i < N; ++i) {
+      out[i] = result[i];
+    }
+  }
+  block_sync::sync<Aligned>(block_dim);
+}
+
+// Use the same pred for both reads and writes
+template <
+    bool Aligned,
+    int N, // Number of elements per input array
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void blockIterGroupedYdimReduce(
+    T out[N],
+    const T inp_val[N],
+    Func reduction_op,
+    T* shared_mem,
+    bool read_write_pred,
+    T init_val,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  blockIterGroupedYdimReduce<Aligned, N, T, Func>(
+      out,
+      inp_val,
+      reduction_op,
+      shared_mem,
+      read_write_pred,
+      read_write_pred,
+      init_val,
+      block_dim);
+}
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+// Inter-block reduction.
+//
+// The gridReduce function performs point-wise reductions of scalars across
+// thread blocks. Thread blocks are disjointly partitioned into groups,
+// "reduction segments", that are collectively defined by boolean template
+// parameters, X_BLOCK, Y_BLOCK and Z_BLOCK. Each of X/Y/Z_BLOCK determines
+// whether thread blocks along the dimension should be grouped into the same
+// reduction segment. Cross-block reducitons are independently done within each
+// segment and generates distinctive results per segment. For instance, if all
+// of X/Y/Z_BLOCK are true, reductions will be done across all thread blocks
+// since there will be just a single segment consisting of all thread blocks. If
+// none of them are true, each thread block will become a segment by itself, so
+// no reduction will be performed.
+//
+// The input scalars to reduce within each segment are a certain subset of
+// thread-private scalars provided as part of the gridReduce function
+// parameters. Boolean template parameters, X_THREAD, Y_THREAD and Z_THREAD,
+// determine which subset of the scalars should be used for inter-block
+// reductions. Specifically, all the input scalars of threads along each
+// dimension will be used when X/Y/Z_THREAD are true. Otherwise, only the value
+// held at offset 0 of each dimension will be used. Thus, for example, if all of
+// X/Y/Z_THREAD are true, the scalars of all threads in each block will
+// participate in inter-block reductions. If all of them are false, only one
+// scalar of the thread at threadIdx.x == threadIdx.y == threadIdx.z == 0 will
+// be used. In the code below, we call the subset of threads a "reduction
+// block". "Participating" thread dimensions here are similar to the
+// "non-participating" block dimensions. They come from a block dimension that
+// has not been reduced before hitting this grid reduction.
+//
+// Inter-block reductions perform point-wise reductions of scalars of reduction
+// blocks within each reduction segment. More specifically, let rb be a
+// reduction block and rs be a reduction segment. Let IN(thread_idx, block_idx)
+// denote the input scalar of thread at thread_idx and block_idx. The result of
+// each reduction segment, OUT(thread_idx, block_idx_out), is defined only for
+// each thread_idx in thread block block_idx_out in the segment as follows:
+//
+//   OUT(thread_idx, block_idx_out) =
+//     Reduction of IN(thread_idx, block_idx) for
+//       all block_idx in a reduction segment
+//
+// OUT is not given for all threads that are not in block_idx_out and the
+// reduction block.
+//
+// See also the function comment of gridReduce.
+
+namespace reduction {
+
+// Reduces all the reduction blocks in each reduction segment. This is the
+// "cleanup" stage of a grid reduction.
+//
+// This is only called by one thread block per reduction segment. The input
+// reduction blocks of the segment are stored in an intermediate buffer pointed
+// by parameter in. Template parameters X/Y/Z_THREAD denote how the reduction
+// block is formed.
+//
+// The size of a reduction block is by definition smaller or equal to the size
+// of a thread block. We use the remaining threads to parallelize reductions
+// across reduction blocks. For example, when X/Y/Z_THREAD = {true, false,
+// false}, we use blockDim.y*blockDim.z threads for each output value. This is
+// done first by loading the input values in parallel and then by reducing
+// across threads of dimensions whose XYZ_THREAD are false.
+//
+// Note that what is done here after the loading from global memory is similar
+// to what the existing blockReduce function does.
+template <
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool Aligned,
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void gridReduceLastBlock(
+    T& out,
+    const volatile T* in,
+    const nvfuser_index_t
+        grid_reduction_segment_size, // Number of reductions across
+                                     // grid reduce dimensions
+    const nvfuser_index_t
+        block_reduction_segment_size, // Number of reductions across the block
+    Func reduction_op,
+    T* shared_buf,
+    bool write_pred,
+    T init_val,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  // We have to do num_reductions across reduction_size. The reductions are
+  // contiguous, but offset by reduction_size. There is an entry in "in" for
+  // every block, and every thread marked as true. Threads in dimensions marked
+  // as false can be used to parallelize the reduction.
+
+  // Find the reduction id of the participating threads
+  const auto block_reduction_segment_idx =
+      index_utils::maskedOffset<X_THREAD, Y_THREAD, Z_THREAD>(
+          threadIdx, block_dim);
+
+  // Find an id associated within a reduction segment for all
+  // "non-participating" threads, which will parallelize the reductions for the
+  // "participating" threads
+  const auto id_in_block_segment =
+      index_utils::maskedOffset<!X_THREAD, !Y_THREAD, !Z_THREAD>(
+          threadIdx, block_dim);
+
+  // Stride by the "non-participating" threads
+  const auto input_stride_for_thread_in_segment =
+      index_utils::maskedSize<!X_THREAD, !Y_THREAD, !Z_THREAD>(block_dim);
+
+  T inp = init_val;
+
+  // Block stride across the reduction until we only have one value per thread
+  for (nvfuser_index_t reduction_i = id_in_block_segment;
+       reduction_i < grid_reduction_segment_size;
+       reduction_i += input_stride_for_thread_in_segment) {
+    auto work_buf_offset = reduction_i * block_reduction_segment_size +
+        block_reduction_segment_idx;
+    reduction_op(inp, in[work_buf_offset]);
+  }
+
+  // Block reduce the per thread values into per "participating" thread values
+  T inp_tmp = init_val;
+  blockReduce<!X_THREAD, !Y_THREAD, !Z_THREAD, Aligned>(
+      inp_tmp, inp, reduction_op, shared_buf, true, init_val, block_dim);
+  const bool should_write = (X_THREAD || threadIdx.x == 0) &&
+      (Y_THREAD || threadIdx.y == 0) && (Z_THREAD || threadIdx.z == 0);
+  if (should_write && write_pred) {
+    reduction_op(out, inp_tmp);
+  }
+}
+
+// Reduces per-thread values across threads and thread blocks.
+//
+// Function parameters:
+// - out: Per-thread output location
+// - inp_val: Per-thread input value
+// - reduction_op: Scalar reduction function
+// - work_buf: Temporary buffer for cross-block reductions
+// - sync_flags: A vector of integers for synchronizations
+// - shared_buf: Shared memory buffer for intra-block reduction
+//
+// Thread has valid results based on if it's the last block in the grid
+// reduction dimension
+//
+// Template parameters:
+// - X/Y/Z_BLOCK/THREAD: When true, reduces across thread blocks along the X/Y/Z
+//   dimensions
+// - PERSISTENT_REDUCTION: Indicates grid reduction will be called in a loop, or
+//   the result of the grid reduction will be broadcasted and used across the
+//   grid. These requires cross grid communication and the grid synchronizations
+//   here to actually synchronize across the entire grid. When false the grid is
+//   not synchronized, the last block just waits for everyone else to finish and
+//   the other blocks can exit early.
+// - T: Scalar data type of input/output data
+// - Func: Type of scalara reduction function
+//
+// Template parameters X/Y/Z_BLOCK define a group of thread blocks that are
+// reduced together. We call it a reduction segment. Some examples are:
+//
+// Case 1: X/Y/Z_BLOCK == true/true/true -> There is only one segment, which
+// includes all thread blocks. It is effecively the same as the grid.
+//
+// Case 2: X/Y/Z_BLOCK == false/false/false -> Each thread block comprises an
+// individual segment by itself.
+//
+// Case 3: X/Y/Z_BLOCK == true/false/false -> Each segment contains thread
+// blocks that have the same blockDim.x. There will be blockDim.y*blockDim.z
+// such segments.
+//
+// X/Y/Z_THREAD also works similarly as X/Y/Z_BLOCK and defines a
+// group of threads that are reduced togather.
+//
+// After the function completes, only one thread block per reduction segment
+// gets valid reduction results. There is no guarantee which particular block
+// gets the final results.
+//
+// entrance_ind and n_entrances are allowed when PERSISTENT_REDUCTION = false.
+// If a grid reduction call is only called once per thread, entrance_ind == 0
+// and n_entrances == 1. However, grid reduction can be called in a loop in a
+// thread, in that case entrance_ind is the count of times the function has been
+// called, and n_entrances is the total number of times it will be called.
+template <
+    bool X_BLOCK,
+    bool Y_BLOCK,
+    bool Z_BLOCK,
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool Aligned,
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void gridReduce(
+    T& out,
+    const T& inp_val,
+    Func reduction_op,
+    volatile T* work_buf,
+    int64_t* sync_flags,
+    T* shared_buf,
+    bool read_pred,
+    bool write_pred,
+    T init_val,
+    const nvfuser_index_t entrance_ind,
+    const nvfuser_index_t n_entrances,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  T block_reduction_val = init_val;
+
+  // Do block reduction when required
+  if (X_THREAD || Y_THREAD || Z_THREAD) {
+    blockReduce<X_THREAD, Y_THREAD, Z_THREAD, Aligned>(
+        block_reduction_val,
+        inp_val,
+        reduction_op,
+        shared_buf,
+        read_pred,
+        true,
+        init_val,
+        block_dim);
+  } else if (read_pred) {
+    block_reduction_val = inp_val;
+  }
+
+  // Number of values to reduce in the reduction segment
+  const auto grid_reduction_segment_size =
+      index_utils::maskedSize<X_BLOCK, Y_BLOCK, Z_BLOCK>(gridDim);
+
+  // Index of the reduction we're performing out of the
+  // grid_reduction_segment_size
+  const auto idx_in_grid_segment =
+      index_utils::maskedOffset<!X_BLOCK, !Y_BLOCK, !Z_BLOCK>(
+          blockIdx, gridDim);
+
+  // Number of threads we can use in final reduction, Seems to assume all
+  // threads in the block participate
+  const auto block_reduction_segment_size =
+      index_utils::maskedSize<!X_THREAD, !Y_THREAD, !Z_THREAD>(block_dim);
+
+  // Number of reductions in the grid
+  const nvfuser_index_t grid_segment_size = PERSISTENT_REDUCTION
+      ? 1
+      : index_utils::maskedSize<!X_BLOCK, !Y_BLOCK, !Z_BLOCK>(gridDim);
+
+  // advance to the offset for this segment
+  // index of reduction * size of the reduction * size of threads
+  work_buf += (entrance_ind * grid_segment_size + idx_in_grid_segment) *
+      grid_reduction_segment_size * block_reduction_segment_size;
+
+  if ((!X_THREAD || threadIdx.x == 0) && (!Y_THREAD || threadIdx.y == 0) &&
+      (!Z_THREAD || threadIdx.z == 0)) {
+    auto block_offset =
+        index_utils::maskedOffset<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim);
+    auto thread_offset =
+        index_utils::maskedOffset<!X_THREAD, !Y_THREAD, !Z_THREAD>(
+            threadIdx, block_dim);
+    auto work_buf_offset =
+        block_offset * block_reduction_segment_size + thread_offset;
+    work_buf[work_buf_offset] = block_reduction_val;
+  }
+  if (PERSISTENT_REDUCTION) {
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+
+  } else {
+    // Use a different sync flag for each call
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[entrance_ind * grid_segment_size + idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+  }
+
+  bool last_block =
+      index_utils::maskedIsLast<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim);
+
+  if (last_block) {
+    // Cleanup with block reduction
+    gridReduceLastBlock<!X_THREAD, !Y_THREAD, !Z_THREAD, Aligned>(
+        out,
+        (T*)work_buf,
+        grid_reduction_segment_size,
+        block_reduction_segment_size,
+        reduction_op,
+        shared_buf,
+        write_pred,
+        init_val,
+        block_dim);
+  }
+
+  if (PERSISTENT_REDUCTION) {
+    // Make sure we're done with global memory before we allow the kernel to
+    // continue
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+  }
+}
+
+// This is just a wrapper of the above grid reduction routine to
+// measure the elapsed cycles. The measurement must be done just by
+// one thread, and in this case it should be done by one of the
+// threads in the last thread block.
+#ifdef NVFUSER_PROFILE_KERNEL
+template <
+    bool X_BLOCK,
+    bool Y_BLOCK,
+    bool Z_BLOCK,
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool Aligned,
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void gridReduce(
+    T& out,
+    const T& inp_val,
+    Func reduction_op,
+    volatile T* work_buf,
+    int64_t* sync_flags,
+    T* shared_buf,
+    bool read_pred,
+    bool write_pred,
+    T init_val,
+    const nvfuser_index_t entrance_ind,
+    const nvfuser_index_t n_entrances,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim,
+    int64_t& cycles,
+    int64_t& count) {
+  int64_t start_counter = 0;
+
+  if (index_utils::maskedIsLast<true, true, true>(blockIdx, gridDim) &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    start_counter = readCycleCounter();
+  }
+
+  gridReduce<
+      X_BLOCK,
+      Y_BLOCK,
+      Z_BLOCK,
+      X_THREAD,
+      Y_THREAD,
+      Z_THREAD,
+      PERSISTENT_REDUCTION,
+      Aligned,
+      T,
+      Func>(
+      out,
+      inp_val,
+      reduction_op,
+      work_buf,
+      sync_flags,
+      shared_buf,
+      read_pred,
+      write_pred,
+      init_val,
+      entrance_ind,
+      n_entrances,
+      block_dim);
+
+  if (index_utils::maskedIsLast<true, true, true>(blockIdx, gridDim) &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    cycles += readCycleCounter() - start_counter;
+    ++count;
+  }
+}
+#endif // NVFUSER_PROFILE_KERNEL
+
+template <
+    bool X_BLOCK,
+    bool Y_BLOCK,
+    bool Z_BLOCK,
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool Aligned,
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void gridReduce2PartialReduction(
+    const T& inp_val,
+    T init_val,
+    Func reduction_op,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim,
+    volatile T* work_buf,
+    T* shared_buf,
+    bool read_pred,
+    nvfuser_index_t grid_reduction_segment_size,
+    nvfuser_index_t idx_in_grid_segment,
+    nvfuser_index_t block_reduction_segment_size) {
+  T block_reduction_val = init_val;
+
+  // Do block reduction when required
+
+  if (X_THREAD || Y_THREAD || Z_THREAD) {
+    blockReduce<X_THREAD, Y_THREAD, Z_THREAD, Aligned>(
+        block_reduction_val,
+        inp_val,
+        reduction_op,
+        shared_buf,
+        read_pred,
+        true,
+        init_val,
+        block_dim);
+  } else if (read_pred) {
+    block_reduction_val = inp_val;
+  }
+
+  if ((!X_THREAD || threadIdx.x == 0) && (!Y_THREAD || threadIdx.y == 0) &&
+      (!Z_THREAD || threadIdx.z == 0)) {
+    auto block_offset =
+        index_utils::maskedOffset<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim);
+    auto thread_offset =
+        index_utils::maskedOffset<!X_THREAD, !Y_THREAD, !Z_THREAD>(
+            threadIdx, block_dim);
+    auto work_buf_offset =
+        block_offset * block_reduction_segment_size + thread_offset;
+    work_buf[work_buf_offset] = block_reduction_val;
+  }
+}
+
+// 2-way horizontally fused grid reduction
+template <
+    bool X_BLOCK,
+    bool Y_BLOCK,
+    bool Z_BLOCK,
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool Aligned,
+    typename T1,
+    typename Func1,
+    typename T2,
+    typename Func2,
+    typename BlockDimT>
+__device__ void gridReduceGroup(
+    T1& out1,
+    const T1& inp_val1,
+    T1 init_val1,
+    Func1 reduction_op1,
+    volatile T1* work_buf1,
+    T2& out2,
+    const T2& inp_val2,
+    T2 init_val2,
+    Func2 reduction_op2,
+    volatile T2* work_buf2,
+    int64_t* sync_flags,
+    void* shared_buf,
+    bool read_pred,
+    bool write_pred,
+    const nvfuser_index_t entrance_ind,
+    const nvfuser_index_t n_entrances,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  // Number of values to reduce in the reduction segment
+  const auto grid_reduction_segment_size =
+      index_utils::maskedSize<X_BLOCK, Y_BLOCK, Z_BLOCK>(gridDim);
+
+  // Index of the reduction we're performing out of the
+  // grid_reduction_segment_size
+  const auto idx_in_grid_segment =
+      index_utils::maskedOffset<!X_BLOCK, !Y_BLOCK, !Z_BLOCK>(
+          blockIdx, gridDim);
+
+  // Number of threads we can use in final reduction, Seems to assume all
+  // threads in the block participate
+  const auto block_reduction_segment_size =
+      index_utils::maskedSize<!X_THREAD, !Y_THREAD, !Z_THREAD>(block_dim);
+
+  // Number of reductions in the grid
+  const nvfuser_index_t grid_segment_size = PERSISTENT_REDUCTION
+      ? 1
+      : index_utils::maskedSize<!X_BLOCK, !Y_BLOCK, !Z_BLOCK>(gridDim);
+
+  // advance to the offset for this segment
+  // index of reduction * size of the reduction * size of threads
+  work_buf1 += (entrance_ind * grid_segment_size + idx_in_grid_segment) *
+      grid_reduction_segment_size * block_reduction_segment_size;
+
+  work_buf2 += (entrance_ind * grid_segment_size + idx_in_grid_segment) *
+      grid_reduction_segment_size * block_reduction_segment_size;
+
+  gridReduce2PartialReduction<
+      X_BLOCK,
+      Y_BLOCK,
+      Z_BLOCK,
+      X_THREAD,
+      Y_THREAD,
+      Z_THREAD,
+      Aligned>(
+      inp_val1,
+      init_val1,
+      reduction_op1,
+      block_dim,
+      work_buf1,
+      (T1*)shared_buf,
+      read_pred,
+      grid_reduction_segment_size,
+      idx_in_grid_segment,
+      block_reduction_segment_size);
+
+  gridReduce2PartialReduction<
+      X_BLOCK,
+      Y_BLOCK,
+      Z_BLOCK,
+      X_THREAD,
+      Y_THREAD,
+      Z_THREAD,
+      Aligned>(
+      inp_val2,
+      init_val2,
+      reduction_op2,
+      block_dim,
+      work_buf2,
+      (T2*)shared_buf,
+      read_pred,
+      grid_reduction_segment_size,
+      idx_in_grid_segment,
+      block_reduction_segment_size);
+
+  if (PERSISTENT_REDUCTION) {
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+  } else {
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[entrance_ind * grid_segment_size + idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+  }
+
+  bool last_block =
+      index_utils::maskedIsLast<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim);
+
+  if (last_block) {
+    // Cleanup with block reduction
+    gridReduceLastBlock<!X_THREAD, !Y_THREAD, !Z_THREAD, Aligned>(
+        out1,
+        work_buf1,
+        grid_reduction_segment_size,
+        block_reduction_segment_size,
+        reduction_op1,
+        (T1*)shared_buf,
+        write_pred,
+        init_val1,
+        block_dim);
+    gridReduceLastBlock<!X_THREAD, !Y_THREAD, !Z_THREAD, Aligned>(
+        out2,
+        work_buf2,
+        grid_reduction_segment_size,
+        block_reduction_segment_size,
+        reduction_op2,
+        (T2*)shared_buf,
+        write_pred,
+        init_val2,
+        block_dim);
+  }
+
+  if (PERSISTENT_REDUCTION) {
+    // Make sure we're done with global memory before we allow the kernel to
+    // continue
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+  }
+}
+
+#ifdef NVFUSER_PROFILE_KERNEL
+template <
+    bool X_BLOCK,
+    bool Y_BLOCK,
+    bool Z_BLOCK,
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool Aligned,
+    typename T1,
+    typename Func1,
+    typename T2,
+    typename Func2,
+    typename BlockDimT>
+__device__ void gridReduceGroup(
+    T1& out1,
+    const T1& inp_val1,
+    T1 init_val1,
+    Func1 reduction_op1,
+    volatile T1* work_buf1,
+    T2& out2,
+    const T2& inp_val2,
+    T2 init_val2,
+    Func2 reduction_op2,
+    volatile T2* work_buf2,
+    int64_t* sync_flags,
+    void* shared_buf,
+    bool read_pred,
+    bool write_pred,
+    const nvfuser_index_t entrance_ind,
+    const nvfuser_index_t n_entrances,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim,
+    int64_t& cycles,
+    int64_t& count) {
+  int64_t start_counter = 0;
+
+  if (index_utils::maskedIsLast<true, true, true>(blockIdx, gridDim) &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    start_counter = readCycleCounter();
+  }
+
+  gridReduceGroup<
+      X_BLOCK,
+      Y_BLOCK,
+      Z_BLOCK,
+      X_THREAD,
+      Y_THREAD,
+      Z_THREAD,
+      PERSISTENT_REDUCTION,
+      Aligned,
+      T1,
+      Func1,
+      T2,
+      Func2>(
+      out1,
+      inp_val1,
+      init_val1,
+      reduction_op1,
+      work_buf1,
+      out2,
+      inp_val2,
+      init_val2,
+      reduction_op2,
+      work_buf2,
+      sync_flags,
+      shared_buf,
+      read_pred,
+      write_pred,
+      entrance_ind,
+      n_entrances,
+      block_dim);
+
+  if (index_utils::maskedIsLast<true, true, true>(blockIdx, gridDim) &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    cycles += readCycleCounter() - start_counter;
+    ++count;
+  }
+}
+#endif // NVFUSER_PROFILE_KERNEL
+
+// This performs a single reduction step, combining a single element "in" with
+// a previous value "work". For a serial grid reduction, "work" resides in
+// global memory, while "in" and "out" are in registers.
+//
+// If the write predicate is false, this function returns early (noop). If the
+// read predicate is false, "init" is used in place of "in".
+//
+// If first_step is false, "work" will be read and reduction_op will be called.
+// The result will be written back to "work" unless last_step is true.
+template <int64_t vec_size, typename T, typename Func>
+__device__ void serialReductionStep(
+    T* out,
+    T* in,
+    T init,
+    volatile T* work,
+    Func reduction_op,
+    bool first_step,
+    bool last_step,
+    bool read_pred,
+    bool write_pred) {
+  if (!write_pred) {
+    return;
+  }
+  if (read_pred) {
+    loadGeneric<T, vec_size>(out, in);
+  } else {
+#pragma unroll
+    for (int i = 0; i < vec_size; ++i) {
+      out[i] = init;
+    }
+  }
+  if (!first_step) {
+    T work_reg[vec_size];
+    loadGlobalToLocal<T, vec_size, true, CacheOp::Global>(work_reg, work);
+#pragma unroll
+    for (int i = 0; i < vec_size; ++i) {
+      reduction_op(out[i], work_reg[i]);
+    }
+  }
+  if (!last_step) {
+    loadLocalToGlobal<T, vec_size, true>(work, out);
+  }
+}
+
+// check required transactions based on data type and vectorization factor
+// ensure each thread in each transaction has no more than 16 bytes which
+// is the maximum allowed vectorization width.
+template <typename T, int vec_size>
+constexpr __device__ int getTransactions() {
+  constexpr int total_bytes = vec_size * sizeof(T);
+  return total_bytes <= 16 ? 1 : total_bytes / 16;
+}
+
+template <typename T, int vec_size>
+constexpr __device__ int getElementsPerTransaction() {
+  return vec_size * sizeof(T) <= 16 ? vec_size : 16 / sizeof(T);
+}
+
+// calculate elements per section
+__inline__ __device__ nvfuser_index_t getElementsPerSection(
+    nvfuser_index_t row_len,
+    nvfuser_index_t col_len,
+    nvfuser_index_t elements_per_thread) {
+  return row_len * col_len * elements_per_thread;
+}
+
+// calculate offset within a section
+__inline__ __device__ nvfuser_index_t getOffsetWithinSection(
+    nvfuser_index_t row_len,
+    nvfuser_index_t row_id,
+    nvfuser_index_t col_id,
+    nvfuser_index_t elements_per_thread) {
+  return (row_id * row_len + col_id) * elements_per_thread;
+}
+// vectorized reduction
+template <
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool Aligned,
+    int vec_size,
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void iterGroupedGridReduceLastBlock(
+    T* out,
+    const volatile T* in,
+    const nvfuser_index_t
+        grid_reduction_segment_size, // Number of reductions across
+                                     // grid reduce dimensions
+    const nvfuser_index_t
+        block_segment_size, // Number of reductions across the block
+    Func reduction_op,
+    T* shared_buf,
+    bool write_pred,
+    T init_val,
+    const nvfuser_index_t grid_segment_size,
+    const nvfuser_index_t idx_in_grid_segment,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  // We have to do num_reductions across reduction_size. The reductions are
+  // contiguous, but offset by reduction_size. There is an entry in "in" for
+  // every block, and every thread marked as true. Threads in dimensions marked
+  // as false can be used to parallelize the reduction.
+
+  // Find the reduction id of the participating threads
+  const auto block_reduction_segment_idx =
+      index_utils::maskedOffset<X_THREAD, Y_THREAD, Z_THREAD>(
+          threadIdx, block_dim);
+
+  // Find an id associated within a reduction segment for all
+  // "non-participating" threads, which will parallelize the reductions for the
+  // "participating" threads
+  const auto id_in_block_segment =
+      index_utils::maskedOffset<!X_THREAD, !Y_THREAD, !Z_THREAD>(
+          threadIdx, block_dim);
+
+  // index into iteration dim.
+  // Its calculation is same to that in [iterGroupedGridReduce]. Becuase when
+  // [iterGroupedGridReduceLastBlock] is called from [iterGroupedGridReduce],
+  // X_THREAD, Y_THREAD, Z_THREAD are flipped.
+  const auto thread_offset =
+      index_utils::maskedOffset<X_THREAD, Y_THREAD, Z_THREAD>(
+          threadIdx, block_dim);
+
+  // Stride by the "non-participating" threads
+  const auto input_stride_for_thread_in_segment =
+      index_utils::maskedSize<!X_THREAD, !Y_THREAD, !Z_THREAD>(block_dim);
+
+  constexpr unsigned int max_align_bytes = 16;
+  constexpr unsigned int vec_bytes = sizeof(T) * vec_size;
+  constexpr unsigned int align_bytes =
+      vec_bytes > max_align_bytes ? max_align_bytes : vec_bytes;
+  // Ensure alignment for vectorized load/store to smem in grouped block
+  // reduction
+  __align__(align_bytes) T inp[vec_size];
+#pragma unroll
+  for (int i = 0; i < vec_size; i++) {
+    inp[i] = init_val;
+  }
+
+  // Max vectorized load/store size is 16 bytes, if each thread has more than
+  // 16 bytes, split into multiple sections to ensure each thread occupies only
+  // 16 bytes at most. For example, if each thread has 8 fp32 which occupies 32
+  // bytes, split into 2 sections, in each secdtion each thread holds 4 fp32 or
+  // 16 bytes. Thread-0 processes elements [0,7], the first 4 elements [0,3] are
+  // stored in the first section and the last 4 elements [4,7] are stored in the
+  // 2nd section. The data layout in gmem is:
+  //         |-----------section 1-----------|-----------section 2-----------|
+  // TIDx:   |000|001|002|003|004|005|006|007|000|001|002|003|004|005|006|007|
+  // GMEM:   |000|016|032|048|064|080|096|112|128|144|160|176|192|208|224|240|
+  // Element:|000|008|016|024|032|040|048|056|004|012|020|028|036|044|052|060|
+  // This layout ensures coalesced access to gmem and each transaction loads 128
+  // bytes.
+  constexpr auto n_transactions = getTransactions<T, vec_size>();
+  constexpr auto n_elements_per_transaction =
+      getElementsPerTransaction<T, vec_size>();
+  const auto elements_per_section = getElementsPerSection(
+      block_segment_size * grid_segment_size, // row len
+      grid_reduction_segment_size, // col len
+      n_elements_per_transaction);
+  // Block stride across the reduction until we only have one value per thread
+  for (nvfuser_index_t reduction_i = id_in_block_segment;
+       reduction_i < grid_reduction_segment_size;
+       reduction_i += input_stride_for_thread_in_segment) {
+    auto offset_in_section = getOffsetWithinSection(
+        block_segment_size * grid_segment_size, // row len
+        reduction_i, // row id
+        block_segment_size * idx_in_grid_segment + thread_offset, // col id
+        n_elements_per_transaction);
+
+#pragma unroll
+    for (auto i = 0; i < n_transactions; i++) {
+      auto i_offset = i * n_elements_per_transaction;
+      T in_reg[n_elements_per_transaction];
+      loadGlobalToLocal<T, n_elements_per_transaction, true, CacheOp::Global>(
+          &in_reg[0],
+          const_cast<T*>(in + elements_per_section * i + offset_in_section));
+#pragma unroll
+      for (auto j = 0; j < n_elements_per_transaction; j++) {
+        reduction_op(inp[i_offset + j], in_reg[j]);
+      }
+    }
+  }
+
+  // Block reduce the per thread values into per "participating" thread values.
+  // inp_tmp stores output results, not being vectorized loaded to smem, no need
+  // to enforce alignment.
+  T inp_tmp[vec_size];
+#pragma unroll
+  for (int i = 0; i < vec_size; i++) {
+    inp_tmp[i] = init_val;
+  }
+  blockIterGroupedYdimReduce<Aligned, vec_size>(
+      inp_tmp, inp, reduction_op, shared_buf, true, init_val, block_dim);
+  const bool should_write = (X_THREAD || threadIdx.x == 0) &&
+      (Y_THREAD || threadIdx.y == 0) && (Z_THREAD || threadIdx.z == 0);
+  if (should_write && write_pred) {
+#pragma unroll
+    for (int i = 0; i < vec_size; i++) {
+      reduction_op(out[i], inp_tmp[i]);
+    }
+  }
+}
+
+// Main algorithm is same to gridReduce: start with block reduce then write
+// results to gmem, the last block load from gmem and finalize with a block
+// reduction. Main differences:
+// (1) each thread in the iter dim does [vec_size] reductions instead of 1.
+// (2) using [blockIterGroupedYdimReduce] instead of [blockReduce].
+
+// (3) ensures vectorized load/store to gmem.
+// Specifically, the new para [vec_size] is the vecotrization factor in the
+// iteration dimension. It is used in outer reduction to reduce calling this
+// grid reduction from [vec_size] times to only 1 time. Its value is limited
+// to 1, 2, 4, 8, 16 based on the hardware support and input data type.
+template <
+    bool X_BLOCK,
+    bool Y_BLOCK,
+    bool Z_BLOCK,
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool Aligned,
+    int vec_size,
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void iterGroupedGridReduce(
+    T* out,
+    const T* inp_val,
+    Func reduction_op,
+    volatile T* work_buf,
+    int64_t* sync_flags,
+    T* shared_buf,
+    bool read_pred,
+    bool write_pred,
+    T init_val,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  // inp or block reduction results
+  T block_reduction_val[vec_size];
+
+  // Do block reduction when required
+  if (X_THREAD || Y_THREAD || Z_THREAD) {
+#pragma unroll
+    for (int i = 0; i < vec_size; i++) {
+      block_reduction_val[i] = init_val;
+    }
+    blockIterGroupedYdimReduce<Aligned, vec_size>(
+        block_reduction_val,
+        inp_val,
+        reduction_op,
+        shared_buf,
+        read_pred,
+        true,
+        init_val,
+        block_dim);
+  } else if (read_pred) {
+#pragma unroll
+    for (int i = 0; i < vec_size; i++) {
+      block_reduction_val[i] = inp_val[i];
+    }
+  }
+
+  // Number of values to reduce in the reduction segment
+  const auto grid_reduction_segment_size =
+      index_utils::maskedSize<X_BLOCK, Y_BLOCK, Z_BLOCK>(gridDim);
+
+  // Index of the reduction we're performing out of the
+  // grid_reduction_segment_size
+  const auto idx_in_grid_segment =
+      index_utils::maskedOffset<!X_BLOCK, !Y_BLOCK, !Z_BLOCK>(
+          blockIdx, gridDim);
+
+  // Number of reductions in each block
+  const auto block_segment_size =
+      index_utils::maskedSize<!X_THREAD, !Y_THREAD, !Z_THREAD>(block_dim);
+
+  // Number of reductions in the grid
+  const nvfuser_index_t grid_segment_size = PERSISTENT_REDUCTION
+      ? 1
+      : index_utils::maskedSize<!X_BLOCK, !Y_BLOCK, !Z_BLOCK>(gridDim);
+
+  // advance to the offset for this segment
+  // index of reduction * size of the reduction * size of threads
+  if ((!X_THREAD || threadIdx.x == 0) && (!Y_THREAD || threadIdx.y == 0) &&
+      (!Z_THREAD || threadIdx.z == 0)) {
+    auto block_offset =
+        index_utils::maskedOffset<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim);
+    auto thread_offset =
+        index_utils::maskedOffset<!X_THREAD, !Y_THREAD, !Z_THREAD>(
+            threadIdx, block_dim);
+
+    // Max vectorized load/store size is 16 bytes, if each thread has more than
+    // 16 bytes, split into multiple sections to ensure each thread occupies
+    // only 16 bytes at most. For example, if each thread has 8 fp32 which
+    // occupies 32 bytes, split into 2 sections, in each secdtion each thread
+    // holds 4 fp32 or 16 bytes. Thread-0 processes elements [0,7], the first 4
+    // elements [0,3] are stored in the first section and the last 4 elements
+    // [4,7] are stored in the 2nd section. The data layout in gmem is:
+    //         |-----------section 1-----------|-----------section 2-----------|
+    // TIDx:   |000|001|002|003|004|005|006|007|000|001|002|003|004|005|006|007|
+    // GMEM:   |000|016|032|048|064|080|096|112|128|144|160|176|192|208|224|240|
+    // Element:|000|008|016|024|032|040|048|056|004|012|020|028|036|044|052|060|
+    // This layout ensures coalesced access to gmem and each transaction loads
+    // 128 bytes.
+    constexpr auto n_transactions = getTransactions<T, vec_size>();
+    constexpr auto n_elements_per_transaction =
+        getElementsPerTransaction<T, vec_size>();
+
+    // get elements per section, used to offset between different sections
+    // number of elements in each thread: [n_elements_per_transaction]
+    // number of threads in each row: [block_segment_size] * [grid_segment_size]
+    // number of rows in each section: [grid_reduction_segment_size]
+    auto elements_per_section = getElementsPerSection(
+        block_segment_size * grid_segment_size, // row len
+        grid_reduction_segment_size, // col len
+        n_elements_per_transaction);
+
+    // index to the right position in [work_buf] to store block reduction
+    // results. Consider a typical outer reduction case where iteration dim is
+    // TIDx and BIDx and reduction dim is TIDy and BIDy. block_offset = BIDy
+    // block_segment_size = blockDim.x
+    // grid_segment_size = gridDim.x
+    // idx_in_grid_segment = BIDx
+    // thread_offset = TIDx
+    auto offset_in_section = getOffsetWithinSection(
+        block_segment_size * grid_segment_size, // row len
+        block_offset, // row id
+        block_segment_size * idx_in_grid_segment + thread_offset, // col id
+        n_elements_per_transaction);
+
+#pragma unroll
+    for (int i = 0; i < n_transactions; i++) {
+      loadLocalToGlobal<T, n_elements_per_transaction, true>(
+          &work_buf[elements_per_section * i + offset_in_section],
+          &block_reduction_val[i * n_elements_per_transaction]);
+    }
+  }
+
+  if (PERSISTENT_REDUCTION) {
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+
+  } else {
+    // there is only one vectorized call
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+  }
+
+  bool last_block =
+      index_utils::maskedIsLast<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim);
+
+  if (last_block) {
+    // Cleanup with block reduction
+    iterGroupedGridReduceLastBlock<
+        !X_THREAD,
+        !Y_THREAD,
+        !Z_THREAD,
+        Aligned,
+        vec_size>(
+        out,
+        (T*)work_buf,
+        grid_reduction_segment_size,
+        block_segment_size,
+        reduction_op,
+        shared_buf,
+        write_pred,
+        init_val,
+        grid_segment_size,
+        idx_in_grid_segment,
+        block_dim);
+  }
+
+  if (PERSISTENT_REDUCTION) {
+    // Make sure we're done with global memory before we allow the kernel to
+    // continue
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+  }
+}
+} // namespace reduction
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+namespace grid_broadcast {
+
+// Broadcasts per-thread values across threads and blocks.
+//
+// Function parameters:
+// - out: Per-thread output location
+// - inp_val: Per-thread input value
+// - work_buf: Temporary buffer for communication across threads/blocks
+// - sync_flags: A vector of integers for synchronizations
+//
+// Template parameters:
+// - X/Y/Z_BLOCK: When true, broadcasts across thread blocks along the X/Y/Z
+//   dimensions
+// - X/Y/Z_THREAD: When true, broadcasts across threads along the X/Y/Z
+//   dimensions
+template <
+    bool X_BLOCK,
+    bool Y_BLOCK,
+    bool Z_BLOCK,
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool Aligned,
+    typename T,
+    typename BlockDimT>
+__device__ void broadcast(
+    T& out,
+    const T& inp_val,
+    volatile T* work_buf,
+    Tensor<int64_t, 1> sync_flags,
+    bool read_write_pred,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  // Number of values broadcasted in the grid dimensions
+  const auto grid_seg_size =
+      index_utils::maskedSize<X_BLOCK, Y_BLOCK, Z_BLOCK>(gridDim);
+
+  // Index of the broadcast we're performing out of the grid_seg_size
+  const auto grid_seg_idx =
+      index_utils::maskedOffset<!X_BLOCK, !Y_BLOCK, !Z_BLOCK>(
+          blockIdx, gridDim);
+
+  // Number of threads not participating in a broadcast dimension, this is the
+  // number of thread entries to expect in the work buffer, therefore a striding
+  const auto block_stride =
+      index_utils::maskedSize<!X_THREAD, !Y_THREAD, !Z_THREAD>(block_dim);
+
+  // Which broadcast in the block this is to line up the entry with the work
+  // buffer
+  const auto thread_offset =
+      index_utils::maskedOffset<!X_THREAD, !Y_THREAD, !Z_THREAD>(
+          threadIdx, block_dim);
+
+  const bool has_valid_data = (!X_BLOCK || blockIdx.x == gridDim.x - 1) &&
+      (!Y_BLOCK || blockIdx.y == gridDim.y - 1) &&
+      (!Z_BLOCK || blockIdx.z == gridDim.z - 1) &&
+      (!X_THREAD || threadIdx.x == 0) && (!Y_THREAD || threadIdx.y == 0) &&
+      (!Z_THREAD || threadIdx.z == 0);
+
+  if (has_valid_data && read_write_pred) {
+    work_buf[grid_seg_idx * block_stride + thread_offset] = inp_val;
+    __threadfence();
+  }
+
+  grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, true, Aligned>(
+      sync_flags[grid_seg_idx], grid_seg_size, block_dim);
+
+  if (read_write_pred) {
+    out = work_buf[grid_seg_idx * block_stride + thread_offset];
+  }
+
+  // Make sure everyone has read from the buffer before continuing the kernel
+  // and potentially overwriting
+  grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, true, Aligned>(
+      sync_flags[grid_seg_idx], grid_seg_size, block_dim);
+}
+} // namespace grid_broadcast
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+
+namespace broadcast {
+// Broadcasts within partitioned groups of threads.
+//
+// X_THREAD: Broadcast from threadIdx.x == 0 if true
+// Y_THREAD: Broadcast from threadIdx.y == 0 if true
+// Z_THREAD: Broadcast from threadIdx.z == 0 if true
+// Aligned: Called from aligned threads if true
+// inp_val: Per-thread source value. Only valid when the thread is a source.
+// out: Per-thread output location
+//
+template <
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool Aligned,
+    typename T,
+    typename BlockDimT>
+__device__ void blockBroadcast(
+    T& out,
+    const T& inp_val,
+    T* shared_mem,
+    bool read_write_pred,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  const bool has_valid_data = (!X_THREAD || threadIdx.x == 0) &&
+      (!Y_THREAD || threadIdx.y == 0) && (!Z_THREAD || threadIdx.z == 0);
+
+  const auto shared_offset =
+      index_utils::maskedOffset<!X_THREAD, !Y_THREAD, !Z_THREAD>(
+          threadIdx, block_dim);
+
+  if (has_valid_data && read_write_pred) {
+    shared_mem[shared_offset] = inp_val;
+  }
+
+  block_sync::sync<Aligned>(block_dim);
+
+  if (read_write_pred) {
+    out = shared_mem[shared_offset];
+  }
+
+  block_sync::sync<Aligned>(block_dim);
+}
+
+} // namespace broadcast
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+template <typename DataType>
+struct WelfordTriplet {
+  DataType avg;
+  DataType var;
+  nvfuser_index_t N;
+};
+
+template <typename DataType>
+__inline__ __device__ void copyTriplet(
+    DataType* dst_avg,
+    DataType* dst_var,
+    nvfuser_index_t* dst_N,
+    const WelfordTriplet<DataType>& src) {
+  *dst_avg = src.avg;
+  *dst_var = src.var;
+  *dst_N = src.N;
+}
+
+template <typename DataType>
+__inline__ __device__ void copyTriplet(
+    WelfordTriplet<DataType>& dst,
+    const DataType* src_avg,
+    const DataType* src_var,
+    const nvfuser_index_t* src_N) {
+  dst.avg = *src_avg;
+  dst.var = *src_var;
+  dst.N = *src_N;
+}
+
+template <typename DataType>
+__inline__ __device__ void copyTriplet(
+    WelfordTriplet<DataType>& dst,
+    const WelfordTriplet<DataType>& src) {
+  dst.avg = src.avg;
+  dst.var = src.var;
+  dst.N = src.N;
+}
+
+// -----------------------------------------------------------------------------------------------
+//  Block Welford Primitives
+// -----------------------------------------------------------------------------------------------
+// Basic utility for welford update. Can be used to scan one value, or two merge
+// two welford results
+template <typename T, typename TN>
+__inline__ __device__ void welfordCombine(
+    T& a_avg,
+    T& a_M2,
+    TN& a_N,
+    const T b_avg,
+    const T b_M2,
+    TN b_N) {
+  if (b_N == 0) {
+    return;
+  }
+  TN ab_N = a_N + b_N;
+  T b_N_div_ab_N = ((T)(nvfuser_index_t)(b_N)) / ((T)(nvfuser_index_t)(ab_N));
+  T delta = b_avg - a_avg;
+  a_avg += delta * b_N_div_ab_N;
+  a_M2 += b_M2 + delta * delta * ((T)(nvfuser_index_t)(a_N)) * b_N_div_ab_N;
+  a_N = ab_N;
+}
+
+template <typename T, bool OutputGmem>
+__inline__ __device__ void welfordVectorized(
+    T& a_avg,
+    T& a_M2,
+    nvfuser_index_t& a_N,
+    const T b_avg,
+    const T b_N_div_ab_N,
+    const nvfuser_index_t ab_N,
+    const bool pred) {
+  // Want only predicated statements and don't want to have
+  // "if", but for gmem output writes can be illegal, so needs to
+  // bail out here.
+  if (OutputGmem && !pred) {
+    return;
+  }
+  T predicated_b_avg = pred ? b_avg : a_avg;
+  T delta0 = predicated_b_avg - a_avg;
+  a_avg += delta0 * b_N_div_ab_N;
+  T delta1 = predicated_b_avg - a_avg;
+  a_M2 += delta0 * delta1;
+  a_N = ab_N;
+}
+
+// Non predicated version
+template <typename T>
+__inline__ __device__ void welfordVectorized(
+    T& a_avg,
+    T& a_M2,
+    nvfuser_index_t& a_N,
+    const T b_avg,
+    const T b_N_div_ab_N,
+    const nvfuser_index_t ab_N) {
+  T delta0 = b_avg - a_avg;
+  a_avg += delta0 * b_N_div_ab_N;
+  T delta1 = b_avg - a_avg;
+  a_M2 += delta0 * delta1;
+  a_N = ab_N;
+}
+
+// [Z,Y,X]_THREADS is the number of participating threads in the z, y, x
+// dimension of the block.
+template <
+    bool X_REDUCE,
+    bool Y_REDUCE,
+    bool Z_REDUCE,
+    bool Aligned,
+    typename T,
+    typename TN,
+    typename BlockDimT>
+__inline__ __device__ void blockWelford(
+    T& out_avg,
+    T& out_M2,
+    TN& out_N,
+    const T& in_avg,
+    const T& in_M2,
+    const TN& in_N,
+    T* shared_mem_avg,
+    T* shared_mem_M2,
+    TN* shared_mem_N,
+    bool read_pred,
+    bool write_pred,
+    T init_val,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  // If this thread will output a final result
+  bool should_write =
+      index_utils::maskedIsZero<X_REDUCE, Y_REDUCE, Z_REDUCE>(threadIdx);
+
+  // Size of the reduction segments
+  unsigned int reduction_size =
+      index_utils::maskedSize<X_REDUCE, Y_REDUCE, Z_REDUCE>(block_dim);
+
+  // Index into the reduction segment
+  unsigned int reduction_tid =
+      index_utils::maskedOffset<X_REDUCE, Y_REDUCE, Z_REDUCE>(
+          threadIdx, block_dim);
+
+  // Index of the reduction segment
+  unsigned int reduction_idx =
+      index_utils::maskedOffset<!X_REDUCE, !Y_REDUCE, !Z_REDUCE>(
+          threadIdx, block_dim);
+
+  // Offset into smem for the current thread
+  unsigned int smem_offset = reduction_idx * reduction_size + reduction_tid;
+
+  if (read_pred) {
+    shared_mem_avg[smem_offset] = in_avg;
+    shared_mem_M2[smem_offset] = in_M2;
+    shared_mem_N[smem_offset] = in_N;
+  } else {
+    shared_mem_avg[smem_offset] = init_val;
+    shared_mem_M2[smem_offset] = init_val;
+    shared_mem_N[smem_offset] = 0;
+  }
+
+  block_sync::sync<Aligned>(block_dim);
+  // Reduce down to nearest power of 2:
+  int np2 = 1 << (31 - __clz(reduction_size));
+
+  if (reduction_tid < np2 && reduction_tid + np2 < reduction_size) {
+    welfordCombine(
+        shared_mem_avg[smem_offset],
+        shared_mem_M2[smem_offset],
+        shared_mem_N[smem_offset],
+        shared_mem_avg[smem_offset + np2],
+        shared_mem_M2[smem_offset + np2],
+        shared_mem_N[smem_offset + np2]);
+  }
+  block_sync::sync<Aligned>(block_dim);
+
+  // loop peel the final iteration to save one syncthread for the end
+  for (int factor = np2 / 2; factor > 1; factor >>= 1) {
+    if (reduction_tid < factor) {
+      welfordCombine(
+          shared_mem_avg[smem_offset],
+          shared_mem_M2[smem_offset],
+          shared_mem_N[smem_offset],
+          shared_mem_avg[smem_offset + factor],
+          shared_mem_M2[smem_offset + factor],
+          shared_mem_N[smem_offset + factor]);
+    }
+    block_sync::sync<Aligned>(block_dim);
+  }
+
+  if (should_write && write_pred) {
+    T res_avg = out_avg;
+    T res_M2 = out_M2;
+    TN res_N = out_N;
+    welfordCombine(
+        res_avg,
+        res_M2,
+        res_N,
+        shared_mem_avg[smem_offset],
+        shared_mem_M2[smem_offset],
+        shared_mem_N[smem_offset]);
+    if (reduction_size > 1) {
+      welfordCombine(
+          res_avg,
+          res_M2,
+          res_N,
+          shared_mem_avg[smem_offset + 1],
+          shared_mem_M2[smem_offset + 1],
+          shared_mem_N[smem_offset + 1]);
+    }
+    out_avg = res_avg;
+    out_M2 = res_M2;
+    out_N = res_N;
+  }
+  block_sync::sync<Aligned>(block_dim);
+}
+
+// Use the same pred for both reads and writes
+template <
+    bool X_REDUCE,
+    bool Y_REDUCE,
+    bool Z_REDUCE,
+    bool Aligned,
+    typename T,
+    typename TN,
+    typename BlockDimT>
+__inline__ __device__ void blockWelford(
+    T& out_avg,
+    T& out_M2,
+    TN& out_N,
+    const T& in_avg,
+    const T& in_M2,
+    const TN& in_N,
+    T* shared_mem_avg,
+    T* shared_mem_M2,
+    TN* shared_mem_N,
+    bool read_write_pred,
+    T init_val,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  blockWelford<X_REDUCE, Y_REDUCE, Z_REDUCE, Aligned, T, TN>(
+      out_avg,
+      out_M2,
+      out_N,
+      in_avg,
+      in_M2,
+      in_N,
+      shared_mem_avg,
+      shared_mem_M2,
+      shared_mem_N,
+      read_write_pred,
+      read_write_pred,
+      init_val,
+      block_dim);
+}
+// -----------------------------------------------------------------------------------------------
+//  Grid Welford Prototype
+// -----------------------------------------------------------------------------------------------
+namespace welford {
+
+template <
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool Aligned,
+    typename T,
+    typename TN,
+    typename BlockDimT>
+__device__ void gridWelfordLastBlock(
+    T& out_avg,
+    T& out_M2,
+    TN& out_N,
+    const volatile T* in_avg,
+    const volatile T* in_M2,
+    const volatile TN* in_N,
+    const nvfuser_index_t
+        grid_reduction_segment_size, // Number of reductions across
+                                     // grid reduce dimensions
+    const nvfuser_index_t block_reduction_segment_size,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim,
+    T* shared_buf_avg,
+    T* shared_buf_M2,
+    TN* shared_buf_N,
+    bool write_pred,
+    T init_val) {
+  // We have to do num_reductions across reduction_size. The reductions are
+  // contiguous, but offset by reduction_size. There is an entry in "in" for
+  // every block, and every thread marked as true. Threads in dimensions marked
+  // as false can be used to parallelize the reduction.
+
+  // Find the reduction id of the participating threads
+  const auto block_reduction_segment_idx =
+      index_utils::maskedOffset<X_THREAD, Y_THREAD, Z_THREAD>(
+          threadIdx, block_dim);
+
+  // Find an id associated within a reduction segment for all
+  // "non-participating" threads, which will parallelize the reductions for the
+  // "participating" threads
+  const auto id_in_block_segment =
+      index_utils::maskedOffset<!X_THREAD, !Y_THREAD, !Z_THREAD>(
+          threadIdx, block_dim);
+
+  // Stride by the "non-participating" threads
+  const auto input_stride_for_thread_in_segment =
+      index_utils::maskedSize<!X_THREAD, !Y_THREAD, !Z_THREAD>(block_dim);
+
+  T inp_avg = init_val;
+  T inp_M2 = init_val;
+  TN inp_N = 0;
+
+  // Block stride across the reduction until we only have one value per thread
+  for (nvfuser_index_t reduction_i = id_in_block_segment;
+       reduction_i < grid_reduction_segment_size;
+       reduction_i += input_stride_for_thread_in_segment) {
+    auto work_buf_offset = reduction_i * block_reduction_segment_size +
+        block_reduction_segment_idx;
+    welfordCombine(
+        inp_avg,
+        inp_M2,
+        inp_N,
+        in_avg[work_buf_offset],
+        in_M2[work_buf_offset],
+        in_N[work_buf_offset]);
+  }
+
+  // Block reduce the per thread values into per "participating" thread values
+  T inp_avg_tmp = init_val;
+  T inp_M2_tmp = init_val;
+  TN inp_N_tmp = 0;
+  blockWelford<!X_THREAD, !Y_THREAD, !Z_THREAD, Aligned>(
+      inp_avg_tmp,
+      inp_M2_tmp,
+      inp_N_tmp,
+      inp_avg,
+      inp_M2,
+      inp_N,
+      shared_buf_avg,
+      shared_buf_M2,
+      shared_buf_N,
+      true,
+      init_val,
+      block_dim);
+  const bool should_write = (X_THREAD || threadIdx.x == 0) &&
+      (Y_THREAD || threadIdx.y == 0) && (Z_THREAD || threadIdx.z == 0);
+  if (should_write && write_pred) {
+    welfordCombine(out_avg, out_M2, out_N, inp_avg_tmp, inp_M2_tmp, inp_N_tmp);
+  }
+}
+
+// Grid welford combine. See GridReduction for more information
+template <
+    bool X_BLOCK,
+    bool Y_BLOCK,
+    bool Z_BLOCK,
+    bool X_THREAD,
+    bool Y_THREAD,
+    bool Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool Aligned,
+    typename T,
+    typename TN,
+    typename BlockDimT>
+__device__ void gridWelford(
+    T& out_avg,
+    T& out_M2,
+    TN& out_N,
+    const T& inp_avg,
+    const T& inp_M2,
+    const TN& inp_N,
+    volatile T* work_buf_avg,
+    volatile T* work_buf_M2,
+    volatile TN* work_buf_N,
+    Tensor<int64_t, 1> sync_flags,
+    T* shared_buf_avg,
+    T* shared_buf_M2,
+    TN* shared_buf_N,
+    bool read_pred,
+    bool write_pred,
+    T init_val,
+    const nvfuser_index_t entrance_ind,
+    const nvfuser_index_t n_entrances,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  // entrance index only matters for non-persistent re-entrant grid reductions.
+  const nvfuser_index_t entrance_ind_ = PERSISTENT_REDUCTION ? 0 : entrance_ind;
+  const nvfuser_index_t n_entrances_ = PERSISTENT_REDUCTION ? 1 : n_entrances;
+
+  // Number of values to reduce in the reduction segment
+  const auto grid_reduction_segment_size =
+      index_utils::maskedSize<X_BLOCK, Y_BLOCK, Z_BLOCK>(gridDim);
+
+  // Index of the reduction we're performing out of the
+  // grid_reduction_segment_size
+  const auto idx_in_grid_segment =
+      index_utils::maskedOffset<!X_BLOCK, !Y_BLOCK, !Z_BLOCK>(
+          blockIdx, gridDim);
+
+  // Number of threads we can use in final reduction, Seems to assume all
+  // threads in the block participate
+  const auto block_reduction_segment_size =
+      index_utils::maskedSize<X_THREAD, Y_THREAD, Z_THREAD>(block_dim);
+
+  // Number of reductions in the grid
+  const nvfuser_index_t grid_segment_size = PERSISTENT_REDUCTION
+      ? 1
+      : index_utils::maskedSize<!X_BLOCK, !Y_BLOCK, !Z_BLOCK>(gridDim);
+
+  // advance to the offset for this segment
+  // index of reduction * size of the reduction * size of threads
+  work_buf_avg += (entrance_ind_ * grid_segment_size + idx_in_grid_segment) *
+      grid_reduction_segment_size * block_reduction_segment_size;
+  work_buf_M2 += (entrance_ind_ * grid_segment_size + idx_in_grid_segment) *
+      grid_reduction_segment_size * block_reduction_segment_size;
+  work_buf_N += (entrance_ind_ * grid_segment_size + idx_in_grid_segment) *
+      grid_reduction_segment_size * block_reduction_segment_size;
+
+  if ((X_THREAD || threadIdx.x == 0) && (Y_THREAD || threadIdx.y == 0) &&
+      (Z_THREAD || threadIdx.z == 0)) {
+    auto block_offset =
+        index_utils::maskedOffset<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim);
+    auto thread_offset =
+        index_utils::maskedOffset<X_THREAD, Y_THREAD, Z_THREAD>(
+            threadIdx, block_dim);
+    auto work_buf_offset =
+        block_offset * block_reduction_segment_size + thread_offset;
+    if (read_pred) {
+      work_buf_avg[work_buf_offset] = inp_avg;
+      work_buf_M2[work_buf_offset] = inp_M2;
+      work_buf_N[work_buf_offset] = inp_N;
+    } else {
+      work_buf_avg[work_buf_offset] = init_val;
+      work_buf_M2[work_buf_offset] = init_val;
+      work_buf_N[work_buf_offset] = 0;
+    }
+  }
+
+  if (PERSISTENT_REDUCTION) {
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+  } else {
+    // Use a different sync flag for each call
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[entrance_ind_ * grid_segment_size + idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+  }
+
+  bool last_block =
+      index_utils::maskedIsLast<X_BLOCK, Y_BLOCK, Z_BLOCK>(blockIdx, gridDim);
+
+  if (last_block) {
+    // final reduction
+    gridWelfordLastBlock<X_THREAD, Y_THREAD, Z_THREAD, Aligned>(
+        out_avg,
+        out_M2,
+        out_N,
+        work_buf_avg,
+        work_buf_M2,
+        work_buf_N,
+        grid_reduction_segment_size,
+        block_reduction_segment_size,
+        block_dim,
+        shared_buf_avg,
+        shared_buf_M2,
+        shared_buf_N,
+        write_pred,
+        init_val);
+  }
+
+  if (PERSISTENT_REDUCTION) {
+    // Make sure we're done with global memory before we allow the kernel to
+    // continue
+    grid_sync::sync<X_BLOCK, Y_BLOCK, Z_BLOCK, PERSISTENT_REDUCTION, Aligned>(
+        sync_flags[idx_in_grid_segment],
+        grid_reduction_segment_size,
+        block_dim);
+  }
+}
+
+} // namespace welford
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+namespace warp {
+
+template <typename T>
+__device__ __forceinline__ T shfl_xor(T var, int laneMask, int width = 32) {
+  return __shfl_xor_sync(0xffffffff, var, laneMask, width);
+}
+template <typename T>
+__device__ __forceinline__ std::complex<T> shfl_xor(
+    std::complex<T> var,
+    int laneMask,
+    int width = 32) {
+  T real = __shfl_xor_sync(0xffffffff, var.real(), laneMask, width);
+  T imag = __shfl_xor_sync(0xffffffff, var.imag(), laneMask, width);
+  return std::complex<T>(real, imag);
+}
+
+template <
+    bool SINGLE_WARP,
+    bool Aligned,
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void warpReduceTIDX(
+    T& out,
+    const T& inp_val,
+    Func reduction_op,
+    T* shared_mem,
+    bool read_write_pred,
+    T init_val,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  constexpr int WARP_SIZE = 32;
+
+  // Assume input padded to multiples of a warp
+  T reduce_val = init_val;
+
+  // Do warp reduction
+  if (read_write_pred) {
+    reduce_val = inp_val;
+  }
+
+  // Reduce within each warp
+  for (int i = 16; i >= 1; i /= 2) {
+    reduction_op(reduce_val, shfl_xor(reduce_val, i, WARP_SIZE));
+  }
+
+  // Reduce across warp if needed
+  // Load value to shared mem
+  if (!SINGLE_WARP) {
+    unsigned int warp_idx = threadIdx.x / WARP_SIZE;
+    unsigned int lane_idx = threadIdx.x % WARP_SIZE;
+    unsigned int reduce_group_id = threadIdx.z * block_dim.y + threadIdx.y;
+    bool is_warp_head = lane_idx == 0;
+    unsigned int reduction_size = block_dim.x;
+    unsigned int num_of_warps = reduction_size / WARP_SIZE;
+    unsigned int smem_offset = reduce_group_id * num_of_warps;
+
+    block_sync::sync<Aligned>(block_dim);
+
+    if (is_warp_head) {
+      shared_mem[smem_offset + warp_idx] = reduce_val;
+    }
+
+    block_sync::sync<Aligned>(block_dim);
+
+    if (warp_idx == 0) {
+      // This assumes num_of_warps will be < 32, meaning < 1024 threads.
+      //  Should be true for long enough.
+      assert(num_of_warps <= 32);
+
+      reduce_val = lane_idx < num_of_warps ? shared_mem[smem_offset + lane_idx]
+                                           : init_val;
+
+      // Reduce within warp 0
+      for (int i = 16; i >= 1; i /= 2) {
+        reduction_op(reduce_val, shfl_xor(reduce_val, i, 32));
+      }
+    }
+
+    if (is_warp_head) {
+      reduction_op(out, reduce_val);
+    }
+    // needs sync, otherwise other warps may access shared memory before this
+    // reduction is done.
+    block_sync::sync<Aligned>(block_dim);
+  } else {
+    reduction_op(out, reduce_val);
+  }
+}
+
+template <
+    int BDIMX,
+    int BDIMY,
+    bool Aligned,
+    typename T,
+    typename Func,
+    typename BlockDimT>
+__device__ void warpReduceTIDXY(
+    T& out,
+    const T& inp_val,
+    Func reduction_op,
+    T* shared_mem,
+    bool read_write_pred,
+    T init_val,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  constexpr int WARP_SIZE = 32;
+  constexpr int num_of_warps = BDIMX * BDIMY / WARP_SIZE;
+
+  // Assume input padded to multiples of a warp
+  T reduce_val = init_val;
+
+  // Do warp reduction
+  if (read_write_pred) {
+    reduce_val = inp_val;
+  }
+
+  // Reduce within each warp
+  for (int i = 16; i >= 1; i /= 2) {
+    reduction_op(reduce_val, shfl_xor(reduce_val, i, WARP_SIZE));
+  }
+
+  // Reduce across warp if needed
+  // Load value to shared mem
+  if (num_of_warps > 1) {
+    unsigned int idx = threadIdx.x + threadIdx.y * BDIMX;
+    unsigned int warp_idx = idx / WARP_SIZE;
+    unsigned int lane_idx = idx % WARP_SIZE;
+    block_sync::sync<Aligned>(block_dim);
+    if (lane_idx == 0) {
+      shared_mem[warp_idx] = reduce_val;
+    }
+    block_sync::sync<Aligned>(block_dim);
+
+    if (warp_idx == 0) {
+      reduce_val = lane_idx < num_of_warps ? shared_mem[lane_idx] : init_val;
+      // Reduce within warp 0
+      for (int i = 16; i >= 1; i /= 2) {
+        reduction_op(reduce_val, shfl_xor(reduce_val, i, 32));
+      }
+    }
+
+    if (lane_idx == 0) {
+      reduction_op(out, reduce_val);
+    }
+    // needs sync, otherwise other warps may access shared memory before this
+    // reduction is done.
+    block_sync::sync<Aligned>(block_dim);
+  } else {
+    reduction_op(out, reduce_val);
+  }
+}
+} // namespace warp
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+
+// Utility for converting generic pointer to SMEM pointer in PTX.
+//  We should review vectorized load/stores with shared memory.
+//  SMEM memory movement PTX is only Global -> SMEM, SMEM -> Local, Local ->
+//  SMEM, and this is needed for these PTX instructions to provide the SMEM
+//  pointer.
+__device__ inline unsigned toSmem(const void* raw_ptr) {
+  unsigned smem_ptr_uint;
+  asm("{ .reg .u64 smem_ptr; cvta.to.shared.u64 smem_ptr, %1; cvt.u32.u64 %0, smem_ptr; }\n"
+      : "=r"(smem_ptr_uint)
+      : "l"(raw_ptr));
+
+  return smem_ptr_uint;
+}
+
+#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 750))
+
+namespace Turing {
+
+// LdMatrix has .x1, .x2 and .x4 options, currently we actively use .x2 and
+//  .x4. In .x2 option. the the address register of upper half warp (lane 16-31)
+//  are un-used but on Turing [sm75,sm80) architecture these un-used addresses
+//  need to be valid, in the sense that:
+//     1. The data it points to has to be within allocated shared mem buffer.
+//     2. The address needs to be aligned to 16 byte.
+//  See also:
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#warp-level-matrix-instructions-ldmatrix
+//  This function addresses 2. above by masking out the sub-16B component
+//    of the address in upper warp and 1. is guaranteed by ldmatrix swizzle
+//    util.
+//  This will **not** affect any functionality. This is just modification
+//    of unused pointers to satisfy the alignment requirement on Turing
+//    hardware.
+//  The alignment requirement is lifted on sm80+,
+//    so this function is a no-op on Ampere or above.
+template <unsigned num_valid_addresses>
+__device__ inline unsigned adjustPartialLdMatrixAddrInTuring(
+    unsigned addr_in_byte) {
+  const unsigned lane = threadIdx.x % 32;
+  if (lane >= num_valid_addresses) {
+    return 0;
+  }
+  return addr_in_byte;
+}
+
+} // namespace Turing
+
+#endif // Arch 75
+
+#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 900))
+
+namespace Hopper {
+
+// Description: Elect a leader thread from a set of threads in a warp
+//
+// The common pattern is to select any thread from the first warp without
+// creating a serialized, peeling loop.
+//
+// Code example: threadIdx.x / 32 == 0 && ptx::elect_sync(~0)
+//
+// Compile Explorer Reference: https://ce.nvidia.com/z/d9x4q8
+//
+// Document Reference:
+// https://docs.nvidia.com/cuda/parallel-thread-execution/#parallel-synchronization-and-communication-instructions-elect-sync
+__device__ inline bool electSync(const uint32_t& membermask) {
+  uint32_t is_elected;
+  asm volatile(
+      "{\n\t .reg .pred P_OUT; \n\t"
+      "elect.sync _|P_OUT, %1;\n\t"
+      "selp.b32 %0, 1, 0, P_OUT; \n"
+      "}"
+      : "=r"(is_elected)
+      : "r"(membermask)
+      :);
+  return static_cast<bool>(is_elected);
+}
+
+// References:
+//
+// TMA:
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#data-movement-and-conversion-instructions-cp-async-bulk-tensor
+// https://github.com/NVIDIA/cutlass/blob/main/include/cute/arch/copy_sm90_tma.hpp
+//
+// Tensor map:
+// https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__TENSOR__MEMORY.html
+
+// TMA Loads:
+
+template <int dim>
+struct CpAsyncBulkTensorTileG2SIndex {
+  const TensorMap* descriptor;
+  Array<int32_t, dim> crds;
+  uint32_t mbarrier;
+};
+
+__device__ inline void cpAsyncBulkTensorTileG2S(
+    const CpAsyncBulkTensorTileG2SIndex<1>& src,
+    uint32_t smem_addr) {
+  uint64_t gmem_int_desc = reinterpret_cast<uint64_t>(src.descriptor);
+  asm volatile(
+      "cp.async.bulk.tensor.1d.shared::cluster.global.mbarrier::complete_tx::bytes"
+      " [%0], [%1, {%3}], [%2];"
+      :
+      : "r"(smem_addr), "l"(gmem_int_desc), "r"(src.mbarrier), "r"(src.crds[0])
+      : "memory");
+}
+
+__device__ inline void cpAsyncBulkTensorTileG2S(
+    const CpAsyncBulkTensorTileG2SIndex<2>& src,
+    uint32_t smem_addr) {
+  uint64_t gmem_int_desc = reinterpret_cast<uint64_t>(src.descriptor);
+  asm volatile(
+      "cp.async.bulk.tensor.2d.shared::cluster.global.mbarrier::complete_tx::bytes"
+      " [%0], [%1, {%3, %4}], [%2];"
+      :
+      : "r"(smem_addr),
+        "l"(gmem_int_desc),
+        "r"(src.mbarrier),
+        "r"(src.crds[0]),
+        "r"(src.crds[1])
+      : "memory");
+}
+
+__device__ inline void cpAsyncBulkTensorTileG2S(
+    const CpAsyncBulkTensorTileG2SIndex<3>& src,
+    uint32_t smem_addr) {
+  uint64_t gmem_int_desc = reinterpret_cast<uint64_t>(src.descriptor);
+  asm volatile(
+      "cp.async.bulk.tensor.3d.shared::cluster.global.mbarrier::complete_tx::bytes"
+      " [%0], [%1, {%3, %4, %5}], [%2];"
+      :
+      : "r"(smem_addr),
+        "l"(gmem_int_desc),
+        "r"(src.mbarrier),
+        "r"(src.crds[0]),
+        "r"(src.crds[1]),
+        "r"(src.crds[2])
+      : "memory");
+}
+
+__device__ inline void cpAsyncBulkTensorTileG2S(
+    const CpAsyncBulkTensorTileG2SIndex<4>& src,
+    uint32_t smem_addr) {
+  uint64_t gmem_int_desc = reinterpret_cast<uint64_t>(src.descriptor);
+  asm volatile(
+      "cp.async.bulk.tensor.4d.shared::cluster.global.mbarrier::complete_tx::bytes"
+      " [%0], [%1, {%3, %4, %5, %6}], [%2];"
+      :
+      : "r"(smem_addr),
+        "l"(gmem_int_desc),
+        "r"(src.mbarrier),
+        "r"(src.crds[0]),
+        "r"(src.crds[1]),
+        "r"(src.crds[2]),
+        "r"(src.crds[3])
+      : "memory");
+}
+
+__device__ inline void cpAsyncBulkTensorTileG2S(
+    const CpAsyncBulkTensorTileG2SIndex<5>& src,
+    uint32_t smem_addr) {
+  uint64_t gmem_int_desc = reinterpret_cast<uint64_t>(src.descriptor);
+  asm volatile(
+      "cp.async.bulk.tensor.5d.shared::cluster.global.mbarrier::complete_tx::bytes"
+      " [%0], [%1, {%3, %4, %5, %6, %7}], [%2];"
+      :
+      : "r"(smem_addr),
+        "l"(gmem_int_desc),
+        "r"(src.mbarrier),
+        "r"(src.crds[0]),
+        "r"(src.crds[1]),
+        "r"(src.crds[2]),
+        "r"(src.crds[3]),
+        "r"(src.crds[4])
+      : "memory");
+}
+
+// TMA Stores:
+
+template <int dim>
+struct CpAsyncBulkTensorTileS2GIndex {
+  const TensorMap* descriptor;
+  Array<int32_t, dim> crds;
+};
+
+__device__ inline void cpAsyncBulkTensorTileS2G(
+    const CpAsyncBulkTensorTileS2GIndex<1>& dest,
+    uint32_t smem_addr) {
+  uint64_t gmem_int_desc = reinterpret_cast<uint64_t>(dest.descriptor);
+  asm volatile(
+      "cp.async.bulk.tensor.1d.global.shared::cta.bulk_group [%0, {%2}], [%1];"
+      :
+      : "l"(gmem_int_desc), "r"(smem_addr), "r"(dest.crds[0])
+      : "memory");
+}
+
+__device__ inline void cpAsyncBulkTensorTileS2G(
+    const CpAsyncBulkTensorTileS2GIndex<2>& dest,
+    uint32_t smem_addr) {
+  uint64_t gmem_int_desc = reinterpret_cast<uint64_t>(dest.descriptor);
+  asm volatile(
+      "cp.async.bulk.tensor.2d.global.shared::cta.bulk_group [%0, {%2, %3}], [%1];"
+      :
+      : "l"(gmem_int_desc), "r"(smem_addr), "r"(dest.crds[0]), "r"(dest.crds[1])
+      : "memory");
+}
+
+__device__ inline void cpAsyncBulkTensorTileS2G(
+    const CpAsyncBulkTensorTileS2GIndex<3>& dest,
+    uint32_t smem_addr) {
+  uint64_t gmem_int_desc = reinterpret_cast<uint64_t>(dest.descriptor);
+  asm volatile(
+      "cp.async.bulk.tensor.3d.global.shared::cta.bulk_group [%0, {%2, %3, %4}], [%1];"
+      :
+      : "l"(gmem_int_desc),
+        "r"(smem_addr),
+        "r"(dest.crds[0]),
+        "r"(dest.crds[1]),
+        "r"(dest.crds[2])
+      : "memory");
+}
+
+__device__ inline void cpAsyncBulkTensorTileS2G(
+    const CpAsyncBulkTensorTileS2GIndex<4>& dest,
+    uint32_t smem_addr) {
+  uint64_t gmem_int_desc = reinterpret_cast<uint64_t>(dest.descriptor);
+  asm volatile(
+      "cp.async.bulk.tensor.4d.global.shared::cta.bulk_group [%0, {%2, %3, %4, %5}], [%1];"
+      :
+      : "l"(gmem_int_desc),
+        "r"(smem_addr),
+        "r"(dest.crds[0]),
+        "r"(dest.crds[1]),
+        "r"(dest.crds[2]),
+        "r"(dest.crds[3])
+      : "memory");
+}
+
+__device__ inline void cpAsyncBulkTensorTileS2G(
+    const CpAsyncBulkTensorTileS2GIndex<5>& dest,
+    uint32_t smem_addr) {
+  uint64_t gmem_int_desc = reinterpret_cast<uint64_t>(dest.descriptor);
+  asm volatile(
+      "cp.async.bulk.tensor.5d.global.shared::cta.bulk_group [%0, {%2, %3, %4, %5, %6}], [%1];"
+      :
+      : "l"(gmem_int_desc),
+        "r"(smem_addr),
+        "r"(dest.crds[0]),
+        "r"(dest.crds[1]),
+        "r"(dest.crds[2]),
+        "r"(dest.crds[3]),
+        "r"(dest.crds[4])
+      : "memory");
+}
+
+} // namespace Hopper
+
+#endif // Arch 90
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+namespace fused_reduction {
+
+// Tuple of Welford avg, var and N parameters.
+//
+// Template parameters:
+// - DataTypeT: Type of avg and var
+// - IndexTypeT: Type of N
+// - MakeTuple: Template template parameter to define Tuple types
+// (e.g., MakeLocalTuple>
+template <
+    int NumVals,
+    typename DataTypeT,
+    typename IndexTypeT,
+    template <int, typename>
+    typename MakeTuple>
+struct WelfordTripletTuple {
+  static constexpr int num_vals = NumVals;
+  using DataType = DataTypeT;
+  using IndexType = IndexTypeT;
+  using DataTuple = typename MakeTuple<NumVals, DataType>::type;
+  using IndexTuple = typename MakeTuple<NumVals, IndexType>::type;
+
+  DataTuple avg;
+  DataTuple var;
+  IndexTuple N;
+
+  WelfordTripletTuple(
+      const DataTuple& avg,
+      const DataTuple& var,
+      const IndexTuple& N)
+      : avg(avg), var(var), N(N) {}
+};
+
+template <int NumVals, typename DataType, typename IndexType>
+using LocalWelfordTripletTuple =
+    WelfordTripletTuple<NumVals, DataType, IndexType, MakeLocalTuple>;
+
+template <int NumVals, typename DataType, typename IndexType>
+using RefWelfordTripletTuple =
+    WelfordTripletTuple<NumVals, DataType, IndexType, MakeRefTuple>;
+
+template <int NumVals, typename DataType, typename IndexType>
+using ConstRefWelfordTripletTuple =
+    WelfordTripletTuple<NumVals, DataType, IndexType, MakeConstRefTuple>;
+
+template <int NumVals, typename DataTypeT, typename IndexTypeT>
+using VolatilePtrWelfordTripletTuple =
+    WelfordTripletTuple<NumVals, DataTypeT, IndexTypeT, MakeVolatilePtrTuple>;
+
+// Advance pointer offsets of WelfordTripleTuple. Only valid when the
+// values are pointer values.
+template <typename WelfordTripletTupleType>
+__inline__ __device__ static void operator+=(
+    WelfordTripletTupleType& triplet,
+    nvfuser_index_t offset) {
+  triplet.avg += offset;
+  triplet.var += offset;
+  triplet.N += offset;
+}
+
+// Copy each of the triplet tuples
+template <typename DstType, typename SrcType>
+__inline__ __device__ static void copyWelfordTripletTuple(
+    DstType& dst,
+    nvfuser_index_t dst_offset,
+    const SrcType& src,
+    nvfuser_index_t src_offset = 0) {
+  copyTuple(dst.avg, dst_offset, src.avg, src_offset);
+  copyTuple(dst.var, dst_offset, src.var, src_offset);
+  copyTuple(dst.N, dst_offset, src.N, src_offset);
+}
+
+// Copy each of the triplet tuples
+template <typename DstType, typename SrcType>
+__inline__ __device__ static void copyWelfordTripletTuple(
+    DstType& dst,
+    const SrcType& src,
+    nvfuser_index_t src_offset = 0) {
+  copyWelfordTripletTuple(dst, 0, src, src_offset);
+}
+
+// Copy each of the triplet tuples
+template <typename DstType, typename SrcType, typename PredType>
+__inline__ __device__ static void copyWelfordTripletTupleIf(
+    DstType& dst,
+    const SrcType& src,
+    const PredType& pred) {
+  copyTupleIf(dst.avg, src.avg, pred);
+  copyTupleIf(dst.var, src.var, pred);
+  copyTupleIf(dst.N, src.N, pred);
+}
+
+} // namespace fused_reduction
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+namespace fused_reduction {
+
+namespace impl {
+
+//! Suppose f_i be the i-th function of the binary function
+//! parameters. Call the function as: f_i(x, y)
+template <int i, typename DataType, typename Func, typename... Funcs>
+struct FuncSelector {
+  static __device__ void call(
+      DataType& x,
+      const DataType y,
+      Func f,
+      Funcs... funcs) {
+    // Here, i is guaranteed to be larger than 0 as there's a
+    // specialization for i == 0 below. Recursively call FuncSelector
+    // by dropping f and decrementing i.
+    FuncSelector<i - 1, DataType, Funcs...>::call(x, y, funcs...);
+  }
+};
+
+//! Specialization of FuncSelector when i == 0, so f_i is f.
+template <typename DataType, typename Func, typename... Funcs>
+struct FuncSelector<0, DataType, Func, Funcs...> {
+  static __device__ void call(
+      DataType& x,
+      const DataType y,
+      Func f,
+      Funcs... funcs) {
+    f(x, y);
+  }
+};
+
+//! Call each of the first i+1 functions with the first i+1 values of
+//! tuples. Here, i is guaranteed to be larger than -1 as there's a
+//! specialization for i == -1.
+template <int i, typename TupleType0, typename TupleType1, typename... Funcs>
+struct FuncForEach {
+  static __device__ void call(
+      TupleType0& val0,
+      nvfuser_index_t offset0,
+      const TupleType1& val1,
+      nvfuser_index_t offset1,
+      Funcs... funcs) {
+    static_assert(
+        IsSameType<
+            typename TupleType0::template ValType<i>,
+            typename TupleType1::template ValType<i>>::value,
+        "Invalid tuple types");
+    // Process the first i functions first.
+    FuncForEach<i - 1, TupleType0, TupleType1, Funcs...>::call(
+        val0, offset0, val1, offset1, funcs...);
+    // Call the i+1-th function
+    FuncSelector<i, typename TupleType0::template ValType<i>, Funcs...>::call(
+        val0.val<i>(offset0), val1.val<i>(offset1), funcs...);
+  }
+};
+
+//! Specialization of FuncForEach when i == -1, which means no
+//! function to call. Just for stopping the recursive pattern here.
+template <typename TupleType0, typename TupleType1, typename... Funcs>
+struct FuncForEach<-1, TupleType0, TupleType1, Funcs...> {
+  static __device__ void call(
+      TupleType0& val0,
+      nvfuser_index_t offset0,
+      const TupleType1& val1,
+      nvfuser_index_t offset1,
+      Funcs... funcs) {}
+};
+
+//! Reduce one value of a tuple using one of the reduction ops. The
+//! value at val_idx is reduced by the function at func_idx.
+template <
+    int func_idx,
+    int val_idx,
+    typename TupleType0,
+    typename TupleType1,
+    typename... Funcs>
+__inline__ __device__ static void reduceVal(
+    TupleType0& val0,
+    nvfuser_index_t offset0,
+    const TupleType1& val1,
+    nvfuser_index_t offset1,
+    Funcs... reduction_ops) {
+  static_assert(
+      IsSameType<
+          typename TupleType0::template ValType<val_idx>,
+          typename TupleType1::template ValType<val_idx>>::value,
+      "Invalid tuple types");
+  FuncSelector<
+      func_idx,
+      typename TupleType0::template ValType<val_idx>,
+      Funcs...>::
+      call(
+          val0.val<val_idx>(offset0),
+          val1.val<val_idx>(offset1),
+          reduction_ops...);
+}
+
+//! Accumulate each value of a given pair of tuples using its corresponding
+//! function. Suppose f_i be the i-th reduciton function. Call f_i as:
+//! f_i(val0.val<i>(offset0), val1.val<i>(offset1)).
+template <typename TupleType0, typename TupleType1, typename... Funcs>
+__inline__ __device__ static void reduceEach(
+    TupleType0& val0,
+    nvfuser_index_t offset0,
+    const TupleType1& val1,
+    nvfuser_index_t offset1,
+    Funcs... reduction_ops) {
+  constexpr int num_funcs = sizeof...(reduction_ops);
+  FuncForEach<num_funcs - 1, TupleType0, TupleType1, Funcs...>::call(
+      val0, offset0, val1, offset1, reduction_ops...);
+}
+
+template <typename TupleType0, typename TupleType1, typename Func, int num_vals>
+struct TupleReduce {};
+
+template <typename TupleType0, typename TupleType1, typename Func>
+struct TupleReduce<TupleType0, TupleType1, Func, 1> {
+  __inline__ __device__ static void reduce(
+      TupleType0& val0,
+      nvfuser_index_t offset0,
+      const TupleType1& val1,
+      nvfuser_index_t offset1,
+      Func reduction_op) {
+    static_assert(
+        IsSameType<
+            typename TupleType0::ValTypes,
+            typename TupleType1::ValTypes>::value,
+        "Invalid value types");
+    reduction_op(val0.val<0>(offset0), val1.val<0>(offset1));
+  }
+};
+
+template <typename TupleType0, typename TupleType1, typename Func>
+struct TupleReduce<TupleType0, TupleType1, Func, 2> {
+  __inline__ __device__ static void reduce(
+      TupleType0& val0,
+      nvfuser_index_t offset0,
+      const TupleType1& val1,
+      nvfuser_index_t offset1,
+      Func reduction_op) {
+    static_assert(
+        IsSameType<
+            typename TupleType0::ValTypes,
+            typename TupleType1::ValTypes>::value,
+        "Invalid value types");
+    reduction_op(
+        val0.val<0>(offset0),
+        val0.val<1>(offset0),
+        val1.val<0>(offset1),
+        val1.val<1>(offset1));
+  }
+};
+
+template <typename TupleType0, typename TupleType1, typename Func>
+struct TupleReduce<TupleType0, TupleType1, Func, 3> {
+  __inline__ __device__ static void reduce(
+      TupleType0& val0,
+      nvfuser_index_t offset0,
+      const TupleType1& val1,
+      nvfuser_index_t offset1,
+      Func reduction_op) {
+    static_assert(
+        IsSameType<
+            typename TupleType0::ValTypes,
+            typename TupleType1::ValTypes>::value,
+        "Invalid value types");
+    reduction_op(
+        val0.val<0>(offset0),
+        val0.val<1>(offset0),
+        val0.val<2>(offset0),
+        val1.val<0>(offset1),
+        val1.val<1>(offset1),
+        val1.val<2>(offset1));
+  }
+};
+
+//! Reduce all values of a tuple together. The reduction function must
+//! have the same number of inputs as the number of values of each tuple.
+template <typename TupleType0, typename TupleType1, typename Func>
+__inline__ __device__ void reduceTuple(
+    TupleType0& val0,
+    nvfuser_index_t offset0,
+    const TupleType1& val1,
+    nvfuser_index_t offset1,
+    Func reduction_op) {
+  static_assert(
+      TupleType0::num_vals == TupleType1::num_vals, "Invalid number of values");
+  TupleReduce<TupleType0, TupleType1, Func, TupleType0::num_vals>::reduce(
+      val0, offset0, val1, offset1, reduction_op);
+}
+
+// Reduces all of the first (idx+1) values by a thread block
+template <
+    int idx,
+    bool BROADCAST,
+    bool FORWARD_PROTECT_SMEM,
+    bool Aligned,
+    typename LocalTupleT,
+    typename BlockDimT,
+    typename... Funcs>
+struct BlockReduceEach {
+  __inline__ __device__ static void reduce(
+      LocalTupleT& block_result,
+      const LocalTupleT& partial_result,
+      void* shared_mem,
+      bool has_block_result,
+      int tid_in_reduction,
+      int num_threads_per_reduction,
+      int num_elements_per_reduction,
+      int reduction_idx,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      Funcs... funcs) {
+    // Finish the reduction of each tuple value with a smaller offset
+    BlockReduceEach<
+        idx - 1,
+        BROADCAST,
+        true,
+        Aligned,
+        LocalTupleT,
+        BlockDimT,
+        Funcs...>::
+        reduce(
+            block_result,
+            partial_result,
+            shared_mem,
+            has_block_result,
+            tid_in_reduction,
+            num_threads_per_reduction,
+            num_elements_per_reduction,
+            reduction_idx,
+            block_dim,
+            funcs...);
+
+    if (num_elements_per_reduction == 1) {
+      if (has_block_result) {
+        block_result.val<idx>(0) = partial_result.val<idx>(0);
+      }
+      return;
+    }
+
+    using DataType = typename LocalTupleT::template ValType<idx>;
+
+    PtrTuple<DataType> shared_buf(static_cast<DataType*>(shared_mem));
+
+    LocalTuple<DataType> block_result_i(partial_result.val<idx>(0));
+
+    const auto smem_offset =
+        reduction_idx * num_threads_per_reduction + tid_in_reduction;
+
+    const int np2 = 1 << (31 - __clz(num_elements_per_reduction));
+
+    // Threads values are initialized, so all can participate here
+    if (tid_in_reduction >= np2) {
+      copyTuple(shared_buf, smem_offset, block_result_i);
+    }
+
+    block_sync::sync<Aligned>(block_dim);
+
+    if (tid_in_reduction < np2 &&
+        tid_in_reduction + np2 < num_elements_per_reduction) {
+      impl::reduceVal<idx, 0>(
+          block_result_i, 0, shared_buf, smem_offset + np2, funcs...);
+    }
+
+    if (tid_in_reduction < np2) {
+      copyTuple(shared_buf, smem_offset, block_result_i);
+    }
+
+    // Always sync when communicating across smem
+    block_sync::sync<Aligned>(block_dim);
+
+    // Reduce down to 2 values, last thread will do the final reduction and
+    // can save a syncthreads this way
+    for (int factor = np2 / 2; factor > 1; factor >>= 1) {
+      if (tid_in_reduction < factor) {
+        impl::reduceVal<idx, 0>(
+            shared_buf,
+            smem_offset,
+            shared_buf,
+            smem_offset + factor,
+            funcs...);
+      }
+      block_sync::sync<Aligned>(block_dim);
+    }
+
+    copyTuple(block_result_i, shared_buf, smem_offset);
+
+    // Do the last reduction
+    if (has_block_result) {
+      impl::reduceVal<idx, 0>(
+          block_result_i, 0, shared_buf, smem_offset + 1, funcs...);
+    }
+
+    if (BROADCAST) {
+      if (has_block_result) {
+        // Put result back in shared memory, put in the first entry of the
+        // reduction segment's buffer
+        copyTuple(
+            shared_buf,
+            reduction_idx * num_threads_per_reduction,
+            block_result_i);
+      }
+
+      // Sync threads to make sure result is in smem
+      block_sync::sync<Aligned>(block_dim);
+
+      copyTuple(
+          block_result_i,
+          shared_buf,
+          reduction_idx * num_threads_per_reduction);
+    }
+
+    block_result.val<idx>(0) = block_result_i.val<0>(0);
+
+    if (FORWARD_PROTECT_SMEM) {
+      block_sync::sync<Aligned>(block_dim);
+    }
+  }
+};
+
+// Specialization for idx == -1, i.e., no value to reduce.
+template <
+    bool BROADCAST,
+    bool FORWARD_PROTECT_SMEM,
+    bool Aligned,
+    typename LocalTupleT,
+    typename BlockDimT,
+    typename... Funcs>
+struct BlockReduceEach<
+    -1,
+    BROADCAST,
+    FORWARD_PROTECT_SMEM,
+    Aligned,
+    LocalTupleT,
+    BlockDimT,
+    Funcs...> {
+  __inline__ __device__ static void reduce(
+      LocalTupleT& block_result,
+      const LocalTupleT& partial_result,
+      void* shared_mem,
+      bool has_block_result,
+      int tid_in_reduction,
+      int num_threads_per_reduction,
+      int num_elements_per_reduction,
+      int reduction_idx,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      Funcs... funcs) {}
+};
+
+//! Reduce each value of a tuple by a thread block.
+//!
+//! The final result is broadcast when BROADCAST is true.
+//!
+//! \param block_result result of the block reduction
+//! \param partial_result Per-thread input tuple
+//! \param shared_mem
+//! \param has_block_result
+//! \param tid_in_reduction
+//! \param num_threads_per_reduction
+//! \param num_elements_per_reduction
+//! \param reduction_idx
+//! \param reduction_ops
+template <
+    bool BROADCAST,
+    bool FORWARD_PROTECT_SMEM,
+    bool Aligned,
+    typename LocalTupleT,
+    typename BlockDimT,
+    typename... Funcs>
+__inline__ __device__ void blockReduceEach(
+    LocalTupleT& block_result,
+    const LocalTupleT& partial_result,
+    void* shared_mem,
+    bool has_block_result,
+    int tid_in_reduction,
+    int num_threads_per_reduction,
+    int num_elements_per_reduction,
+    int reduction_idx,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim,
+    Funcs... reduction_ops) {
+  BlockReduceEach<
+      LocalTupleT::num_vals - 1,
+      BROADCAST,
+      FORWARD_PROTECT_SMEM,
+      Aligned,
+      LocalTupleT,
+      BlockDimT,
+      Funcs...>::
+      reduce(
+          block_result,
+          partial_result,
+          shared_mem,
+          has_block_result,
+          tid_in_reduction,
+          num_threads_per_reduction,
+          num_elements_per_reduction,
+          reduction_idx,
+          block_dim,
+          reduction_ops...);
+}
+
+} // namespace impl
+
+// We have 6 dimensions, 3 in the grid, 3 in the block
+// They can be 1 of 3 states,
+// Reduction Domain - TEMPLATE STATE 0
+//   - Participating in the reduction, has values coming in, one value coming
+//     out across the dimension
+// Iteration Domain - TEMPLATE STATE 1
+//   - Not participating in the reduction, has values across the dimension after
+//     the reduction
+// Collapsed Domain - TEMPLATE STATE 2
+//   - Previously reduced, doesn't need to be reduced on that dimension, doesn't
+//     have values across that dimension
+constexpr __device__ bool isReduce(int STATE) {
+  return STATE == 0;
+}
+
+constexpr __device__ bool isIter(int STATE) {
+  return STATE == 1;
+}
+
+constexpr __device__ bool isPred(int STATE) {
+  return STATE == 2;
+}
+
+constexpr __device__ bool inactive(int STATE) {
+  return STATE == 3;
+}
+
+constexpr __device__ bool activeNotIter(int STATE) {
+  return STATE != 3 && STATE != 1;
+}
+
+constexpr __device__ bool isReduceOrIter(int STATE) {
+  return isReduce(STATE) || isIter(STATE);
+}
+
+// When generating an index into the reduction, we have to stride by iteration
+// domains and reduction domains. Collapsed domains we can ignore, but we need
+// to make sure they never read or write (need to be predicated to correct
+// participation).
+
+// All inclusive reduction with option to re-broadcast. This reduction class
+// does not use predication of parallelization in the read or write predicates.
+// Instead there are 3 states each dimension of parallelization can have,
+// described above. Predication, indexing, and reduction will be done based on
+// this information.
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+class ParallelReduce {
+  static_assert(
+      !BROADCAST || PERSISTENT_REDUCTION,
+      "Broadcast requires persistent reduction");
+
+  static constexpr bool BLOCK_REDUCE =
+      isReduce(X_THREAD) || isReduce(Y_THREAD) || isReduce(Z_THREAD);
+
+  static constexpr bool GRID_REDUCE =
+      isReduce(X_BLOCK) || isReduce(Y_BLOCK) || isReduce(Z_BLOCK);
+
+  // ping-pong between global buffers to avoid a second sync
+  bool flip = false;
+
+ public:
+  __device__ ParallelReduce() {}
+
+  // reduceGroup does not support Welford-style reductions that reduce
+  // all values of a tuple together, so this is the only entry point
+  // for Welford for now.
+  template <bool Aligned, typename Func, typename BlockDimT, typename... Types>
+  __device__ __inline__ void reduce(
+      RefTuple<Types...> out,
+
+      const ConstRefTuple<Types...>& inp,
+      VolatilePtrTuple<Types...> global_work_buffer,
+      int64_t* global_sync_buffer, // Allocated as product of all
+                                   // non-participating Grid dimension
+      PtrTuple<Types...> shared_buf,
+      bool read_pred, // Prevent reading from out of bounds memory
+      bool write_pred, // Prevent from writing out of bounds
+      const LocalTuple<Types...>& init_val,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      Func reduction_op);
+
+  //! Profiled version
+  template <bool Aligned, typename Func, typename BlockDimT, typename... Types>
+  __device__ __inline__ void reduce(
+      RefTuple<Types...> out,
+      const ConstRefTuple<Types...>& inp,
+      VolatilePtrTuple<Types...> global_work_buffer,
+      int64_t* global_sync_buffer, // Allocated as product of all
+                                   // non-participating Grid dimension
+      PtrTuple<Types...> shared_buf,
+      bool read_pred, // Prevent reading from out of bounds memory
+      bool write_pred, // Prevent from writing out of bounds
+      const LocalTuple<Types...>& init_val,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      Func reduction_op,
+      int64_t& cycles,
+      int64_t& count);
+
+  //! Each value of a tuple is independently reduced by the
+  //! corresponding reduction op. Thus, Welford-like reductions are
+  //! not supported by this interface.
+  //!
+  //! Note that out is purely used as the output parameter, and its
+  //! initial value is not used but just overwritten. Since grid
+  //! reductions do not allow serial reduction IterDomains, there is
+  //! no need to accumulate into the out parameter.
+  template <
+      bool Aligned,
+      typename BlockDimT,
+      typename... DataTypes,
+      typename... Funcs,
+      typename... BoolTypes>
+  __device__ __inline__ void reduceGroup(
+      RefTuple<DataTypes...> out,
+      const ConstRefTuple<DataTypes...>& inp,
+      VolatilePtrTuple<DataTypes...> global_work_buffer,
+      const LocalTuple<DataTypes...>& init_val,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      int64_t* global_sync_buffer,
+      void* shared_mem,
+      const LocalTuple<BoolTypes...>& read_preds,
+      const LocalTuple<BoolTypes...>& write_preds,
+      Funcs... funcs);
+
+  //! Profiled version
+  template <
+      bool Aligned,
+      typename BlockDimT,
+      typename... DataTypes,
+      typename... Funcs,
+      typename... BoolTypes>
+  __device__ __inline__ void reduceGroup(
+      RefTuple<DataTypes...> out,
+      const ConstRefTuple<DataTypes...>& inp,
+      VolatilePtrTuple<DataTypes...> global_work_buffer,
+      const LocalTuple<DataTypes...>& init_val,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      int64_t* global_sync_buffer,
+      void* shared_mem,
+      const LocalTuple<BoolTypes...>& read_preds,
+      const LocalTuple<BoolTypes...>& write_preds,
+      int64_t& cycles,
+      int64_t& count,
+      Funcs... funcs);
+
+  // User-visible entry point of grouped grid welford +
+  // broadcast. Mostly the same as reduceGroup, and it would be
+  // possible to combine this to reduceGroup, but it might make the
+  // templated data structures even more complicated and difficult to
+  // understand. For now, keep it as a separate function.
+  //
+  // Unlike reduceGroup, though, the data types of welford ops must be
+  // the same. For example, reduceGroup can be used to reduce half and
+  // float values by passing a tuple of, e.g., LocalTuple<half,
+  // float>, but that's not supported here for implementation
+  // simplicity. In practice, it should be really uncommon to group
+  // welford ops with different data types, so this restriction
+  // shouldn't be an issue.
+  template <
+      bool Aligned,
+      int NumArgs,
+      typename DataType,
+      typename IndexType,
+      typename BlockDimT>
+  __device__ __inline__ void welfordGroup(
+      typename MakeRefTuple<NumArgs, DataType>::type out_avg,
+      typename MakeRefTuple<NumArgs, DataType>::type out_var,
+      typename MakeRefTuple<NumArgs, IndexType>::type out_N,
+      const typename MakeConstRefTuple<NumArgs, DataType>::type& inp_avg,
+      const typename MakeConstRefTuple<NumArgs, DataType>::type& inp_var,
+      const typename MakeConstRefTuple<NumArgs, IndexType>::type& inp_N,
+      const typename MakeLocalTuple<NumArgs, DataType>::type& init_avg,
+      const typename MakeLocalTuple<NumArgs, DataType>::type& init_var,
+      const typename MakeLocalTuple<NumArgs, IndexType>::type& init_N,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      typename MakeVolatilePtrTuple<NumArgs, DataType>::type
+          global_work_buffer_avg,
+      typename MakeVolatilePtrTuple<NumArgs, DataType>::type
+          global_work_buffer_var,
+      typename MakeVolatilePtrTuple<NumArgs, IndexType>::type
+          global_work_buffer_N,
+      int64_t* global_sync_buffer,
+      PtrTuple<DataType, DataType, IndexType> shared_buf,
+      const typename MakeLocalTuple<NumArgs, bool>::type& read_preds,
+      const typename MakeLocalTuple<NumArgs, bool>::type& write_preds);
+
+  //! Profiled version
+  template <
+      bool Aligned,
+      int NumArgs,
+      typename DataType,
+      typename IndexType,
+      typename BlockDimT>
+  __device__ __inline__ void welfordGroup(
+      typename MakeRefTuple<NumArgs, DataType>::type out_avg,
+      typename MakeRefTuple<NumArgs, DataType>::type out_var,
+      typename MakeRefTuple<NumArgs, IndexType>::type out_N,
+      const typename MakeConstRefTuple<NumArgs, DataType>::type& inp_avg,
+      const typename MakeConstRefTuple<NumArgs, DataType>::type& inp_var,
+      const typename MakeConstRefTuple<NumArgs, IndexType>::type& inp_N,
+      const typename MakeLocalTuple<NumArgs, DataType>::type& init_avg,
+      const typename MakeLocalTuple<NumArgs, DataType>::type& init_var,
+      const typename MakeLocalTuple<NumArgs, IndexType>::type& init_N,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      typename MakeVolatilePtrTuple<NumArgs, DataType>::type
+          global_work_buffer_avg,
+      typename MakeVolatilePtrTuple<NumArgs, DataType>::type
+          global_work_buffer_var,
+      typename MakeVolatilePtrTuple<NumArgs, IndexType>::type
+          global_work_buffer_N,
+      int64_t* global_sync_buffer,
+      PtrTuple<DataType, DataType, IndexType> shared_buf,
+      const typename MakeLocalTuple<NumArgs, bool>::type& read_preds,
+      const typename MakeLocalTuple<NumArgs, bool>::type& write_preds,
+      int64_t& cycles,
+      int64_t& count);
+
+  // This is highly specific to the outer-reduction pattern. All the
+  // assumptions should be asserted with static_assert at the begging of
+  // the fuction.
+  template <
+      bool Aligned,
+      int NumVals,
+      typename DataType,
+      int BDIMX,
+      int BDIMY,
+      typename BlockDimT>
+  __device__ __inline__ void welfordGroupOuter(
+      DataType out_avg[NumVals],
+      DataType out_var[NumVals],
+      nvfuser_index_t out_N[NumVals],
+      const DataType in_avg[NumVals],
+      const DataType in_var[NumVals],
+      nvfuser_index_t in_N,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      DataType* global_buf_avg,
+      DataType* global_buf_var,
+      nvfuser_index_t* global_buf_N,
+      DataType* shared_buf,
+      int64_t* global_sync_buffer);
+
+  // Profiled version
+  template <
+      bool Aligned,
+      int NumVals,
+      typename DataType,
+      int BDIMX,
+      int BDIMY,
+      typename BlockDimT>
+  __device__ __inline__ void welfordGroupOuter(
+      DataType out_avg[NumVals],
+      DataType out_var[NumVals],
+      nvfuser_index_t out_N[NumVals],
+      const DataType in_avg[NumVals],
+      const DataType in_var[NumVals],
+      nvfuser_index_t in_N,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      DataType* global_buf_avg,
+      DataType* global_buf_var,
+      nvfuser_index_t* global_buf_N,
+      DataType* shared_buf,
+      int64_t* global_sync_buffer,
+      int64_t& cycles,
+      int64_t& count);
+
+ private:
+  __device__ static bool isLastBlockInGrid() {
+    return index_utils::maskedIsLast<
+               isReduceOrIter(X_BLOCK),
+               isReduceOrIter(Y_BLOCK),
+               isReduceOrIter(Z_BLOCK)>(blockIdx, gridDim) &&
+        index_utils::maskedIsZero<
+               !isReduceOrIter(X_BLOCK),
+               !isReduceOrIter(Y_BLOCK),
+               !isReduceOrIter(Z_BLOCK)>(blockIdx);
+  }
+
+  //! Initial per-CTA reduction of each value of a tuple. Each value
+  //! is reduced individually, so the shared memory buffer just needs
+  //! to be large enough for each value. NOTE that the smem buffer is
+  //! not forward protected.
+  template <
+      bool BLOCK_BROADCAST,
+      bool Aligned,
+      typename BlockDimT,
+      typename... DataTypes,
+      typename... Funcs,
+      typename... BoolTypes>
+  __device__ __inline__ static LocalTuple<DataTypes...> reduceGroupBlock(
+      const ConstRefTuple<DataTypes...>& inp,
+      const LocalTuple<DataTypes...>& init_val,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      void* shared_mem,
+      const LocalTuple<BoolTypes...>& read_preds,
+      bool block_reduce_participate,
+      Funcs... funcs);
+
+  //! Final reduction of partial results. Done by all blocks
+  //! redundantly when BROADCAST is true, or just one block otherwise.
+  //! The smem buffer is assumed synchronized when it is passed in,
+  //! but it isn't synchronized when returning from this function.
+  template <
+      bool Aligned,
+      typename BlockDimT,
+      typename... DataTypes,
+      typename... Funcs,
+      typename... BoolTypes>
+  __device__ __inline__ static void reduceGroupLastBlock(
+      RefTuple<DataTypes...>& out,
+      const VolatilePtrTuple<DataTypes...>& global_work_buffer,
+      const LocalTuple<DataTypes...>& init_val,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      void* shared_mem,
+      nvfuser_index_t block_red_idx_offset,
+      nvfuser_index_t num_thread_iters,
+      nvfuser_index_t num_block_iters,
+      nvfuser_index_t thread_red_idx_offset,
+      nvfuser_index_t grid_red_size,
+      const LocalTuple<BoolTypes...>& write_preds,
+      bool block_reduce_participate,
+      bool grid_reduce_participate,
+      Funcs... reduction_ops);
+
+  //! Welford version of reduceGroupBlock
+  template <
+      bool BLOCK_BROADCAST,
+      bool Aligned,
+      int NumVals,
+      typename DataType,
+      typename IndexType,
+      typename BlockDimT>
+  __device__ __inline__ static void welfordGroupBlock(
+      LocalWelfordTripletTuple<NumVals, DataType, IndexType>& block_result,
+      const ConstRefWelfordTripletTuple<NumVals, DataType, IndexType>& inp,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      PtrTuple<DataType, DataType, IndexType> shared_buf,
+      const typename MakeLocalTuple<NumVals, bool>::type& read_preds,
+      bool block_reduce_participate);
+
+  //! Welford version of reduceGrouplLastBlock
+  template <
+      bool Aligned,
+      int NumVals,
+      typename DataType,
+      typename IndexType,
+      typename BlockDimT>
+  __device__ __inline__ static void welfordGroupLastBlock(
+      RefWelfordTripletTuple<NumVals, DataType, IndexType>& out,
+      const VolatilePtrWelfordTripletTuple<NumVals, DataType, IndexType>&
+          global_work_buffer,
+      const LocalWelfordTripletTuple<NumVals, DataType, IndexType>& init_val,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim,
+      PtrTuple<DataType, DataType, IndexType> shared_buf,
+      nvfuser_index_t block_red_idx_offset,
+      nvfuser_index_t num_thread_iters,
+      nvfuser_index_t num_block_iters,
+      nvfuser_index_t thread_red_idx_offset,
+      nvfuser_index_t grid_red_size,
+      const typename MakeLocalTuple<NumVals, bool>::type& write_preds,
+      bool block_reduce_participate,
+      bool grid_reduce_participate);
+
+  // End Parallel reduce class
+};
+
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <bool Aligned, typename Func, typename BlockDimT, typename... Types>
+__device__ __inline__ void ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    reduce(
+        RefTuple<Types...> out,
+        const ConstRefTuple<Types...>& inp,
+        VolatilePtrTuple<Types...> global_work_buffer,
+        int64_t* global_sync_buffer, // Allocated as product of all
+        // non-participating Grid dimension
+        PtrTuple<Types...> shared_buf,
+        bool read_pred, // Prevent reading from out of bounds memory
+        bool write_pred, // Prevent from writing out of bounds
+        const LocalTuple<Types...>& init_val,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        Func reduction_op) {
+  // If no reduction needed, just return input
+  if (!BLOCK_REDUCE && !GRID_REDUCE) {
+    if (read_pred && write_pred) {
+      out = inp;
+    }
+    return;
+  }
+
+
+  // Don't read/write in temporary buffers if in a predicated dimension
+  bool block_reduce_participate = index_utils::
+      maskedIsZero<isPred(X_THREAD), isPred(Y_THREAD), isPred(Z_THREAD)>(
+          threadIdx);
+
+  // Initialize block result
+  LocalTuple<Types...> block_result = init_val;
+
+  // Grab input data if participating in the reduction, set to block_result in
+  // the case there is no block reduction
+  if (block_reduce_participate && read_pred) {
+    block_result = inp;
+  }
+
+  // Only threads that with id == 0 in the dimensions being reduced will
+  // have a valid result
+  bool has_block_result = index_utils::
+      maskedIsZero<isReduce(X_THREAD), isReduce(Y_THREAD), isReduce(Z_THREAD)>(
+          threadIdx);
+
+  if (BLOCK_REDUCE) {
+    // -- START BLOCK REDUCTION -- //
+
+    // Size of the block reduction segment, can be an int since it's limited
+    // to number of threads
+    int block_reduction_size = index_utils::
+        maskedSize<isReduce(X_THREAD), isReduce(Y_THREAD), isReduce(Z_THREAD)>(
+            block_dim);
+
+    // Index in the reduction segment, can be an int since it's limited to
+    // number of threads
+    int tid_in_block_reduction = index_utils::maskedOffset<
+        isReduce(X_THREAD),
+        isReduce(Y_THREAD),
+        isReduce(Z_THREAD)>(threadIdx, block_dim);
+
+    // ID of the block reduction this thread is participating in
+    //
+    // If any of the parallel dimensions are predicated out, that means
+    // they've already been reduced, so we only care about the first thread in
+    // that dimension. Therefore don't expand the reduction_idx by that
+    // dimension
+    int block_reduction_idx = index_utils::
+        maskedOffset<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+            threadIdx, block_dim);
+
+    // Shared memory buffer is 2D
+    // [iter dimension, reduction dimension]
+
+    // Offset into smem for the current thread
+    int block_reduce_smem_offset =
+        block_reduction_idx * block_reduction_size + tid_in_block_reduction;
+
+    // Initialize shared memory
+    if (block_reduce_participate) {
+      copyTuple(shared_buf, block_reduce_smem_offset, block_result);
+    }
+
+    // Sync to make sure smem is completely initialized
+    block_sync::sync<Aligned>(block_dim);
+
+    // Round reduction size down to nearest power of 2
+    int np2 = 1 << (31 - __clz(block_reduction_size));
+
+    // Perform an initial reduction leaving np2 elements
+    if (block_reduce_participate && tid_in_block_reduction < np2 &&
+        tid_in_block_reduction + np2 < block_reduction_size) {
+      impl::reduceTuple(
+          shared_buf,
+          block_reduce_smem_offset,
+          shared_buf,
+          block_reduce_smem_offset + np2,
+          reduction_op);
+    }
+
+    // Always need to sync while operating on shared memory
+    block_sync::sync<Aligned>(block_dim);
+
+    // Reduce down until 2 values, leaving 2 values allows us to manually
+    // perform the last reduction and avoid a syncthreads
+    for (int factor = np2 / 2; factor > 1; factor >>= 1) {
+      if (tid_in_block_reduction < factor && block_reduce_participate) {
+        impl::reduceTuple(
+            shared_buf,
+            block_reduce_smem_offset,
+            shared_buf,
+            block_reduce_smem_offset + factor,
+            reduction_op);
+      }
+      block_sync::sync<Aligned>(block_dim);
+    }
+
+    // Accumulate that last valid result
+    if (has_block_result) {
+      copyTuple(block_result, shared_buf, block_reduce_smem_offset);
+      if (block_reduction_size > 1) {
+        impl::reduceTuple(
+            block_result,
+            0,
+            shared_buf,
+            block_reduce_smem_offset + 1,
+            reduction_op);
+      }
+    }
+
+    // ===== BLOCK REDUCTION CLEANUP =======
+    if (!GRID_REDUCE) {
+      // If no grid reduction, we don't have to continue. Either broadcast
+      // back across the block or return the correct reduction
+      if (has_block_result && write_pred) {
+        impl::reduceTuple(block_result, 0, out, 0, reduction_op);
+        out = block_result;
+      }
+      if (BROADCAST) {
+        // No grid reduce, but need to broadcast, perform block broadcast
+        if (has_block_result && write_pred) {
+          // Put result back in shared memory, put in the first entry of the
+          // reduction segment's buffer
+          copyTuple(
+              shared_buf,
+              block_reduction_idx * block_reduction_size,
+              block_result);
+        }
+
+        // Sync threads to make sure result is in smem
+        block_sync::sync<Aligned>(block_dim);
+        // If the thread is participating, and is not attempting to write out
+        // of bounds, return the broadcasted value.
+        if (block_reduce_participate && write_pred) {
+          copyTuple(
+              out, shared_buf, block_reduction_idx * block_reduction_size);
+        }
+      }
+
+      // Forward protect shared memory, don't want threads to continue to
+      // another reduction/broadcast and pollute shared memory before the
+      // reduction is completely finished.
+      //
+      // This could be avoided in some cases if we added thread syncs from
+      // block reductions in the syncthread insertion pass.
+      block_sync::sync<Aligned>(block_dim);
+      return;
+    }
+  }
+
+  // -- START GRID REDUCTION -- //
+  // Grid reductions are more challenging for two reasons, (1) the reduction
+  // itself is 3D instead of 2D because we now have an iter domain space in
+  // the grid dimension. (2) a tree reduction isn't performed, instead all
+  // blocks will populate GMEM and one  block will finish the grid reduction.
+
+  // What is the grid reduction size, block reduction already performed so
+  // that doesn't have to be taken into consideration
+  const auto grid_red_size = index_utils::
+      maskedSize<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          gridDim);
+
+  // Which ID in the reduction is this block. Threads can participate in
+  // multiple grid reductions, but the block will have the same relative index
+  // in those reductions
+  const auto idx_in_grid_red = index_utils::
+      maskedOffset<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  if (PERSISTENT_REDUCTION && flip) {
+    auto global_buffer_size =
+        index_utils::
+            maskedSize<isIter(X_BLOCK), isIter(Y_BLOCK), isIter(Z_BLOCK)>(
+                gridDim) *
+        index_utils::
+            maskedSize<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+                block_dim) *
+        grid_red_size;
+    global_work_buffer += global_buffer_size;
+  }
+  flip = !flip;
+
+  // How many grid reductions have to be performed, in the grid dimension
+  const auto num_block_iters = index_utils::
+      maskedSize<isIter(X_BLOCK), isIter(Y_BLOCK), isIter(Z_BLOCK)>(gridDim);
+
+  // Which grid reduction does this block participate in, in the grid
+  // dimension
+  const auto block_red_idx_offset = index_utils::
+      maskedOffset<isIter(X_BLOCK), isIter(Y_BLOCK), isIter(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  // How many grid reductions have to be performed, in the block dimension
+  const auto num_thread_iters = index_utils::
+      maskedSize<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+          block_dim);
+
+  // Which grid reduction does this thread participate in, in the block
+  // dimension
+  const auto thread_red_idx_offset = index_utils::
+      maskedOffset<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+          threadIdx, block_dim);
+
+  // 3D buffer of reductions:
+  //    [reduction_offset(grid), iter_offset(grid), iter_offset(block)]
+  // Offset into the work buffer
+  const auto work_buf_offset =
+      (idx_in_grid_red * num_block_iters + block_red_idx_offset) *
+          num_thread_iters +
+      thread_red_idx_offset;
+
+  // Don't read/write in temporary buffers if in a predicated dimension
+  bool grid_reduce_participate = index_utils::
+      maskedIsZero<isPred(X_BLOCK), isPred(Y_BLOCK), isPred(Z_BLOCK)>(blockIdx);
+
+  if (grid_reduce_participate && block_reduce_participate) {
+    if (has_block_result) {
+      copyTuple(global_work_buffer, work_buf_offset, block_result);
+    }
+  }
+
+  // -- GLOBAL BUFFER FILLED -- //
+
+  bool last_block = index_utils::
+      maskedIsLast<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  if (grid_reduce_participate) {
+    // Don't need to sync up blocks that are not participating in this
+    // reduction
+    grid_sync::sync<
+        isReduce(X_BLOCK),
+        isReduce(Y_BLOCK),
+        isReduce(Z_BLOCK),
+        PERSISTENT_REDUCTION,
+        Aligned>(
+        global_sync_buffer[block_red_idx_offset],
+        grid_red_size,
+        last_block,
+        block_dim);
+  }
+
+  // -- START BLOCK CLEANUP -- //
+  // All blocks perform the last cleanup, so every block, and every thread
+  // will have the final result
+
+  // Initialize block result
+  LocalTuple<Types...> last_block_result(init_val);
+
+  if ((PERSISTENT_REDUCTION || last_block) && grid_reduce_participate) {
+    // Can use the last block to reduce all the values the blocks filled in.
+    // Can use any thread that has been predicated, or has been reduced to do
+    // this reduction, cannot use any block that's associated with an
+    // iteration domain
+
+    // Start with non-block reduction
+
+    // Index in the reduction segment
+    int tid_in_block_reduction_2 = index_utils::maskedOffset<
+        activeNotIter(X_THREAD),
+        activeNotIter(Y_THREAD),
+        activeNotIter(Z_THREAD)>(threadIdx, block_dim);
+
+    int block_reduction_size_2 = index_utils::maskedSize<
+        activeNotIter(X_THREAD),
+        activeNotIter(Y_THREAD),
+        activeNotIter(Z_THREAD)>(block_dim);
+
+    // 3D buffer of reductions:
+    //    [reduction_offset(grid), iter_offset(grid), iter_offset(block)]
+    // Change the offset, we want to keep the last two dimensions, but the
+    // first dimension is what we will reduce over
+    const auto work_buf_offset_2 =
+        block_red_idx_offset * num_thread_iters + thread_red_idx_offset;
+    for (auto reduction_i = tid_in_block_reduction_2;
+         reduction_i < grid_red_size;
+         reduction_i += block_reduction_size_2) {
+      impl::reduceTuple(
+          last_block_result,
+          0,
+          global_work_buffer,
+          work_buf_offset_2 +
+              reduction_i * num_block_iters *
+                  num_thread_iters, // Iterating over the outer most
+          // dimension, so need to stride by the
+          // total number of grid reductions. Could
+          // come back and change it so this is the
+          // contiguous dimension
+          reduction_op);
+    }
+
+    // -- START LAST BLOCK - BLOCK REDUCTION -- //
+
+    // Reduced so we have one value per thread, we need to further reduce any
+    // dimension that is not an iter dimension
+
+    // Which block reduction this thread is participating in
+    int block_reduction_idx = index_utils::
+        maskedOffset<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+            threadIdx, block_dim);
+
+    // Offset in smem for this thread's result
+    auto smem_offset =
+        block_reduction_idx * block_reduction_size_2 + tid_in_block_reduction_2;
+
+    // Similar as before, reduce down to nearest power of 2 so we can do a
+    // tree reduction
+    int np2 = 1 << (31 - __clz(min(block_reduction_size_2, grid_red_size)));
+
+    // Threads values are initialized, so all can participate here
+    if (tid_in_block_reduction_2 >= np2) {
+      copyTuple(shared_buf, smem_offset, last_block_result);
+    }
+
+    block_sync::sync<Aligned>(block_dim);
+
+    if (tid_in_block_reduction_2 < np2 &&
+        tid_in_block_reduction_2 + np2 <
+            min(block_reduction_size_2, grid_red_size)) {
+      impl::reduceTuple(
+          last_block_result, 0, shared_buf, smem_offset + np2, reduction_op);
+    }
+
+    if (tid_in_block_reduction_2 < np2) {
+      copyTuple(shared_buf, smem_offset, last_block_result);
+    }
+
+    // Always sync when communicating across smem
+    block_sync::sync<Aligned>(block_dim);
+
+    // Reduce down to 2 values, last thread will do the final reduction and
+    // can save a syncthreads this way
+    for (int factor = np2 / 2; factor > 1; factor >>= 1) {
+      if (tid_in_block_reduction_2 < factor) {
+        impl::reduceTuple(
+            shared_buf,
+            smem_offset,
+            shared_buf,
+            smem_offset + factor,
+            reduction_op);
+      }
+      block_sync::sync<Aligned>(block_dim);
+    }
+
+    // If this thread in each block has the final result before broadcasting
+    // to all other threads in block
+    bool has_block_result_2 = index_utils::maskedIsZero<
+        activeNotIter(X_THREAD),
+        activeNotIter(Y_THREAD),
+        activeNotIter(Z_THREAD)>(threadIdx);
+    // Do the last reduction, protected by the write predicate
+    copyTuple(last_block_result, shared_buf, smem_offset);
+    if (has_block_result && grid_reduce_participate) {
+      impl::reduceTuple(last_block_result, 0, out, 0, reduction_op);
+      if (min(block_reduction_size_2, grid_red_size) > 1) {
+        impl::reduceTuple(
+            last_block_result, 0, shared_buf, smem_offset + 1, reduction_op);
+      }
+    }
+
+    if (grid_reduce_participate && PERSISTENT_REDUCTION) {
+      // If persistent reduction, always broadcast reduced values
+      copyTuple(shared_buf, smem_offset, last_block_result);
+      block_sync::sync<Aligned>(block_dim);
+      if (write_pred && block_reduce_participate) {
+        copyTuple(
+            out, shared_buf, block_reduction_idx * block_reduction_size_2);
+      }
+      // For persistent kernels we double the global buffer allocation so we
+      // don't need to protect those buffers every iteration preventing the
+      // need of an additional grid_sync. Since we flip back and forth between
+      // sections of the buffer, the one grid sync protects the other part of
+      // the buffer.
+    } else {
+      if (grid_reduce_participate) {
+        if (last_block && has_block_result && block_reduce_participate &&
+            write_pred) {
+          copyTuple(
+              out, shared_buf, block_reduction_idx * block_reduction_size_2);
+        }
+      }
+    }
+    // Forward protect the smem used in this reduction
+    block_sync::sync<Aligned>(block_dim);
+  }
+}
+
+//! Profiled version
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <bool Aligned, typename Func, typename BlockDimT, typename... Types>
+__device__ __inline__ void ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    reduce(
+        RefTuple<Types...> out,
+        const ConstRefTuple<Types...>& inp,
+        VolatilePtrTuple<Types...> global_work_buffer,
+        int64_t* global_sync_buffer, // Allocated as product of all
+        // non-participating Grid dimension
+        PtrTuple<Types...> shared_buf,
+        bool read_pred, // Prevent reading from out of bounds memory
+        bool write_pred, // Prevent from writing out of bounds
+        const LocalTuple<Types...>& init_val,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        Func reduction_op,
+        int64_t& cycles,
+        int64_t& count) {
+
+  int64_t start_counter = 0;
+
+  if (isLastBlockInGrid() &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    start_counter = readCycleCounter();
+  }
+
+  reduce<Aligned>(
+      out,
+      inp,
+      global_work_buffer,
+      global_sync_buffer,
+      shared_buf,
+      read_pred,
+      write_pred,
+      init_val,
+      block_dim,
+      reduction_op);
+
+  if (isLastBlockInGrid() &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    cycles += readCycleCounter() - start_counter;
+    ++count;
+  }
+}
+
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <
+    bool Aligned,
+    typename BlockDimT,
+    typename... DataTypes,
+    typename... Funcs,
+    typename... BoolTypes>
+__device__ __inline__ void ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    reduceGroup(
+        RefTuple<DataTypes...> out,
+        const ConstRefTuple<DataTypes...>& inp,
+        VolatilePtrTuple<DataTypes...> global_work_buffer,
+        const LocalTuple<DataTypes...>& init_val,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        int64_t* global_sync_buffer,
+        void* shared_mem,
+        const LocalTuple<BoolTypes...>& read_preds,
+        const LocalTuple<BoolTypes...>& write_preds,
+        Funcs... funcs) {
+  static_assert(
+      sizeof...(DataTypes) == sizeof...(Funcs),
+      "Mismatched number of Tuple values and functions");
+  static_assert(
+      sizeof...(DataTypes) == sizeof...(BoolTypes),
+      "Mismatched number of Tuple values and predicate values");
+
+  // If no reduction needed, just return input
+  if (!BLOCK_REDUCE && !GRID_REDUCE) {
+    copyTupleIf(out, inp, read_preds && write_preds);
+    return;
+  }
+
+  // Don't read/write in temporary buffers if in a predicated dimension
+  const bool block_reduce_participate = index_utils::
+      maskedIsZero<isPred(X_THREAD), isPred(Y_THREAD), isPred(Z_THREAD)>(
+          threadIdx);
+
+  // Only threads that with id == 0 in the dimensions being reduced will
+  // have a valid result
+  const bool has_block_result = index_utils::
+      maskedIsZero<isReduce(X_THREAD), isReduce(Y_THREAD), isReduce(Z_THREAD)>(
+          threadIdx);
+
+  // Initial per-block reduction. Result is broadcast if specified
+  // and this call is block reduction only.
+  const auto block_result = reduceGroupBlock < !GRID_REDUCE && BROADCAST,
+             Aligned > (inp,
+                        init_val,
+                        block_dim,
+                        shared_mem,
+                        read_preds,
+                        block_reduce_participate,
+                        funcs...);
+  // If block reduction only, save to out and exit
+  if (!GRID_REDUCE) {
+    copyTupleIf(
+        out,
+        block_result,
+        write_preds &&
+            (block_reduce_participate && (BROADCAST || has_block_result)));
+
+    // Need a block sync here as reduceGroupBlock does not
+    // forward-protect the smem buffer. This block sync is not
+    // necessary when a grid reduction follows since a block sync is
+    // done just before the grid sync.
+    block_sync::sync<Aligned>(block_dim);
+    return;
+  }
+
+  // -- START GRID REDUCTION -- //
+  // Grid reductions are more challenging for two reasons, (1) the reduction
+  // itself is 3D instead of 2D because we now have an iter domain space in
+  // the grid dimension. (2) a tree reduction isn't performed, instead all
+  // blocks will populate GMEM and one  block will finish the grid reduction.
+
+  // What is the grid reduction size, block reduction already performed so
+  // that doesn't have to be taken into consideration
+  const auto grid_red_size = index_utils::
+      maskedSize<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          gridDim);
+
+  // Which ID in the reduction is this block. Threads can participate in
+  // multiple grid reductions, but the block will have the same relative index
+  // in those reductions
+  const auto idx_in_grid_red = index_utils::
+      maskedOffset<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  // How many grid reductions have to be performed, in the grid dimension
+  const auto num_block_iters = index_utils::
+      maskedSize<isIter(X_BLOCK), isIter(Y_BLOCK), isIter(Z_BLOCK)>(gridDim);
+
+  // Which grid reduction does this block participate in, in the grid
+  // dimension
+  const auto block_red_idx_offset = index_utils::
+      maskedOffset<isIter(X_BLOCK), isIter(Y_BLOCK), isIter(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  // How many grid reductions have to be performed, in the block dimension
+  const auto num_thread_iters = index_utils::
+      maskedSize<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+          block_dim);
+
+  // Which grid reduction does this thread participate in, in the block
+  // dimension
+  const auto thread_red_idx_offset = index_utils::
+      maskedOffset<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+          threadIdx, block_dim);
+
+  // 3D buffer of reductions:
+  //    [reduction_offset(grid), iter_offset(grid), iter_offset(block)]
+  // Offset into the work buffer
+  const auto work_buf_offset =
+      (idx_in_grid_red * num_block_iters + block_red_idx_offset) *
+          num_thread_iters +
+      thread_red_idx_offset;
+
+  // Don't read/write in temporary buffers if in a predicated dimension
+  bool grid_reduce_participate = index_utils::
+      maskedIsZero<isPred(X_BLOCK), isPred(Y_BLOCK), isPred(Z_BLOCK)>(blockIdx);
+
+  if (PERSISTENT_REDUCTION && flip) {
+    auto global_buffer_size =
+        index_utils::
+            maskedSize<isIter(X_BLOCK), isIter(Y_BLOCK), isIter(Z_BLOCK)>(
+                gridDim) *
+        index_utils::
+            maskedSize<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+                block_dim) *
+        grid_red_size;
+    global_work_buffer += global_buffer_size;
+  }
+  flip = !flip;
+
+  // Per-block partial reduction to global work buffer
+  if (grid_reduce_participate && block_reduce_participate && has_block_result) {
+    copyTuple(global_work_buffer, work_buf_offset, block_result);
+  }
+
+  // -- GLOBAL BUFFER FILLED -- //
+
+  bool last_block = index_utils::
+      maskedIsLast<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  if (grid_reduce_participate) {
+    // Don't need to sync up blocks that are not participating in this
+    // reduction
+    grid_sync::sync<
+        isReduce(X_BLOCK),
+        isReduce(Y_BLOCK),
+        isReduce(Z_BLOCK),
+        PERSISTENT_REDUCTION,
+        Aligned>(
+        global_sync_buffer[block_red_idx_offset],
+        grid_red_size,
+        last_block,
+        block_dim);
+  }
+
+  // -- START BLOCK CLEANUP -- //
+  reduceGroupLastBlock<Aligned>(
+      out,
+      global_work_buffer,
+      init_val,
+      block_dim,
+      shared_mem,
+      block_red_idx_offset,
+      num_thread_iters,
+      num_block_iters,
+      thread_red_idx_offset,
+      grid_red_size,
+      write_preds,
+      block_reduce_participate,
+      grid_reduce_participate,
+      funcs...);
+
+  // Forward protect the smem buffer
+  block_sync::sync<Aligned>(block_dim);
+}
+
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <
+    bool Aligned,
+    typename BlockDimT,
+    typename... DataTypes,
+    typename... Funcs,
+    typename... BoolTypes>
+__device__ __inline__ void ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    reduceGroup(
+        RefTuple<DataTypes...> out,
+        const ConstRefTuple<DataTypes...>& inp,
+        VolatilePtrTuple<DataTypes...> global_work_buffer,
+        const LocalTuple<DataTypes...>& init_val,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        int64_t* global_sync_buffer,
+        void* shared_mem,
+        const LocalTuple<BoolTypes...>& read_preds,
+        const LocalTuple<BoolTypes...>& write_preds,
+        int64_t& cycles,
+        int64_t& count,
+        Funcs... funcs) {
+  int64_t start_counter = 0;
+
+  if (isLastBlockInGrid() &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    start_counter = readCycleCounter();
+  }
+
+  reduceGroup<Aligned>(
+      out,
+      inp,
+      global_work_buffer,
+      init_val,
+      block_dim,
+      global_sync_buffer,
+      shared_mem,
+      read_preds,
+      write_preds,
+      funcs...);
+
+  if (isLastBlockInGrid() &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    cycles += readCycleCounter() - start_counter;
+    ++count;
+  }
+}
+
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <
+    bool BLOCK_BROADCAST,
+    bool Aligned,
+    typename BlockDimT,
+    typename... DataTypes,
+    typename... Funcs,
+    typename... BoolTypes>
+__device__ __inline__ LocalTuple<DataTypes...> ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    reduceGroupBlock(
+        const ConstRefTuple<DataTypes...>& inp,
+        const LocalTuple<DataTypes...>& init_val,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        void* shared_mem,
+        const LocalTuple<BoolTypes...>& read_preds,
+        bool block_reduce_participate,
+        Funcs... funcs) {
+  const bool has_block_result = index_utils::
+      maskedIsZero<isReduce(X_THREAD), isReduce(Y_THREAD), isReduce(Z_THREAD)>(
+          threadIdx);
+
+  // Initialize block result
+  LocalTuple<DataTypes...> block_result = init_val;
+
+  copyTupleIf(block_result, inp, block_reduce_participate && read_preds);
+
+  // Size of the block reduction segment, can be an int since it's limited
+  // to number of threads
+  const int block_reduction_size = index_utils::
+      maskedSize<isReduce(X_THREAD), isReduce(Y_THREAD), isReduce(Z_THREAD)>(
+          block_dim);
+
+  // Index in the reduction segment, can be an int since it's limited to
+  // number of threads
+  const int tid_in_block_reduction = index_utils::
+      maskedOffset<isReduce(X_THREAD), isReduce(Y_THREAD), isReduce(Z_THREAD)>(
+          threadIdx, block_dim);
+
+  // ID of the block reduction this thread is participating in
+  //
+  // If any of the parallel dimensions are predicated out, that means
+  // they've already been reduced, so we only care about the first thread in
+  // that dimension. Therefore don't expand the reduction_idx by that
+  // dimension
+  const int block_reduction_idx = index_utils::
+      maskedOffset<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+          threadIdx, block_dim);
+
+  // Do not protect the smem buffer as it's not always necessary.
+  impl::blockReduceEach<
+      BLOCK_BROADCAST,
+      false,
+      Aligned,
+      LocalTuple<DataTypes...>,
+      BlockDimT,
+      Funcs...>(
+      block_result,
+      block_result,
+      shared_mem,
+      has_block_result,
+      tid_in_block_reduction,
+      block_reduction_size,
+      block_reduction_size,
+      block_reduction_idx,
+      block_dim,
+      funcs...);
+
+  return block_result;
+}
+
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <
+    bool Aligned,
+    typename BlockDimT,
+    typename... DataTypes,
+    typename... Funcs,
+    typename... BoolTypes>
+__device__ __inline__ void ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    reduceGroupLastBlock(
+        RefTuple<DataTypes...>& out,
+        const VolatilePtrTuple<DataTypes...>& global_work_buffer,
+        const LocalTuple<DataTypes...>& init_val,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        void* shared_mem,
+        nvfuser_index_t block_red_idx_offset,
+        nvfuser_index_t num_thread_iters,
+        nvfuser_index_t num_block_iters,
+        nvfuser_index_t thread_red_idx_offset,
+        nvfuser_index_t grid_red_size,
+        const LocalTuple<BoolTypes...>& write_preds,
+        bool block_reduce_participate,
+        bool grid_reduce_participate,
+        Funcs... reduction_ops) {
+  // Initialize block result
+  LocalTuple<DataTypes...> last_block_result(init_val);
+
+  const bool last_block = index_utils::
+      maskedIsLast<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  if ((PERSISTENT_REDUCTION || last_block) && grid_reduce_participate) {
+    // Can use the last block to reduce all the values the blocks filled in.
+    // Can use any thread that has been predicated, or has been reduced to do
+    // this reduction, cannot use any block that's associated with an
+    // iteration domain
+
+    // Start with non-block reduction
+
+    // Index in the reduction segment
+    int tid_in_block_reduction = index_utils::maskedOffset<
+        activeNotIter(X_THREAD),
+        activeNotIter(Y_THREAD),
+        activeNotIter(Z_THREAD)>(threadIdx, block_dim);
+
+    int block_reduction_size = index_utils::maskedSize<
+        activeNotIter(X_THREAD),
+        activeNotIter(Y_THREAD),
+        activeNotIter(Z_THREAD)>(block_dim);
+
+    bool has_block_result = index_utils::maskedIsZero<
+        activeNotIter(X_THREAD),
+        activeNotIter(Y_THREAD),
+        activeNotIter(Z_THREAD)>(threadIdx);
+
+    // 3D buffer of reductions:
+    //    [reduction_offset(grid), iter_offset(grid), iter_offset(block)]
+    // Change the offset, we want to keep the last two dimensions, but the
+    // first dimension is what we will reduce over
+    const auto work_buf_offset =
+        block_red_idx_offset * num_thread_iters + thread_red_idx_offset;
+    for (auto reduction_i = tid_in_block_reduction; reduction_i < grid_red_size;
+         reduction_i += block_reduction_size) {
+      impl::reduceEach(
+          last_block_result,
+          0,
+          global_work_buffer,
+          work_buf_offset +
+              reduction_i * num_block_iters *
+                  num_thread_iters, // Iterating over the outer most
+                                    // dimension, so need to stride by the
+                                    // total number of grid reductions. Could
+                                    // come back and change it so this is the
+                                    // contiguous dimension
+          reduction_ops...);
+    }
+
+
+    // Which block reduction this thread is participating in
+    int block_reduction_idx = index_utils::
+        maskedOffset<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+            threadIdx, block_dim);
+
+    impl::blockReduceEach<
+        BROADCAST,
+        false,
+        Aligned,
+        LocalTuple<DataTypes...>,
+        BlockDimT,
+        Funcs...>(
+        last_block_result,
+        last_block_result,
+        shared_mem,
+        has_block_result,
+        tid_in_block_reduction,
+        block_reduction_size,
+        min(grid_red_size, block_reduction_size),
+        block_reduction_idx,
+        block_dim,
+        reduction_ops...);
+
+    copyTupleIf(
+        out,
+        last_block_result,
+        write_preds &&
+            (block_reduce_participate && (BROADCAST || has_block_result)));
+  }
+}
+
+} // namespace fused_reduction
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+namespace fused_reduction {
+
+namespace impl {
+
+//! Implementation helper for welfordEach.
+template <int ValIdx, typename Triplet0, typename Triplet1>
+struct WelfordForEach {
+  static __inline__ __device__ void call(
+      Triplet0& triplet0,
+      nvfuser_index_t offset0,
+      const Triplet1& triplet1,
+      nvfuser_index_t offset1) {
+    static_assert(
+        Triplet0::num_vals == Triplet1::num_vals, "Invalid Triplet types");
+    static_assert(
+        IsSameType<typename Triplet0::DataType, typename Triplet1::DataType>::
+            value,
+        "Invalid Triplet types");
+    static_assert(
+        IsSameType<typename Triplet0::IndexType, typename Triplet1::IndexType>::
+            value,
+        "Invalid Triplet types");
+
+    using DataType = typename Triplet0::DataType;
+    using IndexType = typename Triplet0::IndexType;
+
+    WelfordForEach<ValIdx - 1, Triplet0, Triplet1>::call(
+        triplet0, offset0, triplet1, offset1);
+    welfordCombine<DataType, IndexType>(
+        triplet0.avg.val<ValIdx>(offset0),
+        triplet0.var.val<ValIdx>(offset0),
+        triplet0.N.val<ValIdx>(offset0),
+        triplet1.avg.val<ValIdx>(offset1),
+        triplet1.var.val<ValIdx>(offset1),
+        triplet1.N.val<ValIdx>(offset1));
+  }
+};
+
+template <typename Triplet0, typename Triplet1>
+struct WelfordForEach<-1, Triplet0, Triplet1> {
+  __inline__ __device__ static void call(
+      Triplet0& triplet0,
+      nvfuser_index_t offset0,
+      const Triplet1& triplet1,
+      nvfuser_index_t offset1) {}
+};
+
+//! Call welfordCombine with each of the triplet tuples. This is a
+//! welford version of reduceEach.
+template <typename Triplet0, typename Triplet1>
+__inline__ __device__ static void welfordEach(
+    Triplet0& triplet0,
+    nvfuser_index_t offset0,
+    const Triplet1& triplet1,
+    nvfuser_index_t offset1) {
+  WelfordForEach<Triplet0::num_vals - 1, Triplet0, Triplet1>::call(
+      triplet0, offset0, triplet1, offset1);
+}
+
+// Welford version of BlockReduceEach
+template <
+    int idx,
+    bool BROADCAST,
+    bool FORWARD_PROTECT_SMEM,
+    bool Aligned,
+    int NumVals,
+    typename DataType,
+    typename IndexType,
+    typename BlockDimT>
+struct BlockWelfordEach {
+  __inline__ __device__ static void reduce(
+      LocalWelfordTripletTuple<NumVals, DataType, IndexType>& block_result,
+      const LocalWelfordTripletTuple<NumVals, DataType, IndexType>&
+          partial_result,
+      PtrTuple<DataType, DataType, IndexType> shared_buf,
+      bool has_block_result,
+      int tid_in_reduction,
+      int num_threads_per_reduction,
+      int num_elements_per_reduction,
+      int reduction_idx,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim) {
+    // Finish the reduction of each tuple value with a smaller offset
+    BlockWelfordEach<
+        idx - 1,
+        BROADCAST,
+        true,
+        Aligned,
+        NumVals,
+        DataType,
+        IndexType,
+        BlockDimT>::
+        reduce(
+            block_result,
+            partial_result,
+            shared_buf,
+            has_block_result,
+            tid_in_reduction,
+            num_threads_per_reduction,
+            num_elements_per_reduction,
+            reduction_idx,
+            block_dim);
+
+    if (num_elements_per_reduction == 1) {
+      if (has_block_result) {
+        copyWelfordTripletTuple(block_result, partial_result);
+      }
+      return;
+    }
+
+    LocalTuple<DataType, DataType, IndexType> block_result_i(
+        partial_result.avg.val<idx>(0),
+        partial_result.var.val<idx>(0),
+        partial_result.N.val<idx>(0));
+
+    const auto smem_offset =
+        reduction_idx * num_threads_per_reduction + tid_in_reduction;
+
+    const int np2 = 1 << (31 - __clz(num_elements_per_reduction));
+
+    // Threads values are initialized, so all can participate here
+    if (tid_in_reduction >= np2) {
+      copyTuple(shared_buf, smem_offset, block_result_i);
+    }
+
+    block_sync::sync<Aligned>(block_dim);
+    if (tid_in_reduction < np2 &&
+        tid_in_reduction + np2 < num_elements_per_reduction) {
+      impl::reduceTuple(
+          block_result_i,
+          0,
+          shared_buf,
+          smem_offset + np2,
+          welfordCombine<DataType, IndexType>);
+    }
+
+    if (tid_in_reduction < np2) {
+      copyTuple(shared_buf, smem_offset, block_result_i);
+    }
+
+    // Always sync when communicating across smem
+    block_sync::sync<Aligned>(block_dim);
+
+    // Reduce down to 2 values, last thread will do the final reduction and
+    // can save a syncthreads this way
+    for (int factor = np2 / 2; factor > 1; factor >>= 1) {
+      if (tid_in_reduction < factor) {
+        impl::reduceTuple(
+            shared_buf,
+            smem_offset,
+            shared_buf,
+            smem_offset + factor,
+            welfordCombine<DataType, IndexType>);
+      }
+      block_sync::sync<Aligned>(block_dim);
+    }
+
+    copyTuple(block_result_i, shared_buf, smem_offset);
+
+    // Do the last reduction
+    if (has_block_result) {
+      impl::reduceTuple(
+          block_result_i,
+          0,
+          shared_buf,
+          smem_offset + 1,
+          welfordCombine<DataType, IndexType>);
+    }
+
+    if (BROADCAST) {
+      if (has_block_result) {
+        // Put result back in shared memory, put in the first entry of the
+        // reduction segment's buffer
+        copyTuple(
+            shared_buf,
+            reduction_idx * num_threads_per_reduction,
+            block_result_i);
+      }
+
+      // Sync threads to make sure result is in smem
+      block_sync::sync<Aligned>(block_dim);
+
+      copyTuple(
+          block_result_i,
+          shared_buf,
+          reduction_idx * num_threads_per_reduction);
+    }
+
+    block_result.avg.val<idx>(0) = block_result_i.val<0>(0);
+    block_result.var.val<idx>(0) = block_result_i.val<1>(0);
+    block_result.N.val<idx>(0) = block_result_i.val<2>(0);
+
+    if (FORWARD_PROTECT_SMEM) {
+      block_sync::sync<Aligned>(block_dim);
+    }
+  }
+};
+
+// Specialization for idx == -1, i.e., no value to reduce.
+template <
+    bool BROADCAST,
+    bool FORWARD_PROTECT_SMEM,
+    bool Aligned,
+    int NumVals,
+    typename DataType,
+    typename IndexType,
+    typename BlockDimT>
+struct BlockWelfordEach<
+    -1,
+    BROADCAST,
+    FORWARD_PROTECT_SMEM,
+    Aligned,
+    NumVals,
+    DataType,
+    IndexType,
+    BlockDimT> {
+  __inline__ __device__ static void reduce(
+      LocalWelfordTripletTuple<NumVals, DataType, IndexType>& block_result,
+      const LocalWelfordTripletTuple<NumVals, DataType, IndexType>&
+          partial_result,
+      PtrTuple<DataType, DataType, IndexType> shared_buf,
+      bool has_block_result,
+      int tid_in_reduction,
+      int num_threads_per_reduction,
+      int num_elements_per_reduction,
+      int reduction_idx,
+      // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+      // there is no warp specialization in the kernel. If there is warp
+      // specialization, block_dim is the the dimension of the compute warps.
+      BlockDimT block_dim) {}
+};
+
+//! Welford version of blockReduceEach. Perform block-parallel Welford
+//! reduction of each Welford triplet.
+template <
+    bool BROADCAST,
+    bool FORWARD_PROTECT_SMEM,
+    bool Aligned,
+    int NumVals,
+    typename DataType,
+    typename IndexType,
+    typename BlockDimT>
+__inline__ __device__ void blockWelfordEach(
+    LocalWelfordTripletTuple<NumVals, DataType, IndexType>& block_result,
+    const LocalWelfordTripletTuple<NumVals, DataType, IndexType>&
+        partial_result,
+    PtrTuple<DataType, DataType, IndexType> shared_buf,
+    bool has_block_result,
+    int tid_in_reduction,
+    int num_threads_per_reduction,
+    int num_elements_per_reduction,
+    int reduction_idx,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim) {
+  BlockWelfordEach<
+      NumVals - 1,
+      BROADCAST,
+      FORWARD_PROTECT_SMEM,
+      Aligned,
+      NumVals,
+      DataType,
+      IndexType,
+      BlockDimT>::
+      reduce(
+          block_result,
+          partial_result,
+          shared_buf,
+          has_block_result,
+          tid_in_reduction,
+          num_threads_per_reduction,
+          num_elements_per_reduction,
+          reduction_idx,
+          block_dim);
+}
+
+} // namespace impl
+
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <
+    bool Aligned,
+    int NumArgs,
+    typename DataType,
+    typename IndexType,
+    typename BlockDimT>
+__device__ __inline__ void ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    welfordGroup(
+        typename MakeRefTuple<NumArgs, DataType>::type out_avg,
+        typename MakeRefTuple<NumArgs, DataType>::type out_var,
+        typename MakeRefTuple<NumArgs, IndexType>::type out_N,
+        const typename MakeConstRefTuple<NumArgs, DataType>::type& inp_avg,
+        const typename MakeConstRefTuple<NumArgs, DataType>::type& inp_var,
+        const typename MakeConstRefTuple<NumArgs, IndexType>::type& inp_N,
+        const typename MakeLocalTuple<NumArgs, DataType>::type& init_avg,
+        const typename MakeLocalTuple<NumArgs, DataType>::type& init_var,
+        const typename MakeLocalTuple<NumArgs, IndexType>::type& init_N,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        typename MakeVolatilePtrTuple<NumArgs, DataType>::type
+            global_work_buffer_avg,
+        typename MakeVolatilePtrTuple<NumArgs, DataType>::type
+            global_work_buffer_var,
+        typename MakeVolatilePtrTuple<NumArgs, IndexType>::type
+            global_work_buffer_N,
+        int64_t* global_sync_buffer,
+        PtrTuple<DataType, DataType, IndexType> shared_buf,
+        const typename MakeLocalTuple<NumArgs, bool>::type& read_preds,
+        const typename MakeLocalTuple<NumArgs, bool>::type& write_preds) {
+  const ConstRefWelfordTripletTuple<NumArgs, DataType, IndexType> inp(
+      inp_avg, inp_var, inp_N);
+  RefWelfordTripletTuple<NumArgs, DataType, IndexType> out(
+      out_avg, out_var, out_N);
+
+  // If no reduction needed, just return input
+  if (!BLOCK_REDUCE && !GRID_REDUCE) {
+    copyWelfordTripletTupleIf(out, inp, read_preds && write_preds);
+    return;
+  }
+
+  // Don't read/write in temporary buffers if in a predicated dimension
+  const bool block_reduce_participate = index_utils::
+      maskedIsZero<isPred(X_THREAD), isPred(Y_THREAD), isPred(Z_THREAD)>(
+          threadIdx);
+
+  // Only threads that with id == 0 in the dimensions being reduced will
+  // have a valid result
+  const bool has_block_result = index_utils::
+      maskedIsZero<isReduce(X_THREAD), isReduce(Y_THREAD), isReduce(Z_THREAD)>(
+          threadIdx);
+
+  LocalWelfordTripletTuple<NumArgs, DataType, IndexType> block_result(
+      init_avg, init_var, init_N);
+
+  // Initial per-block reduction. Result is broadcast if specified
+  // and this call is block reduction only.
+  welfordGroupBlock<
+      !GRID_REDUCE && BROADCAST,
+      Aligned,
+      NumArgs,
+      DataType,
+      IndexType>(
+      block_result,
+      inp,
+      block_dim,
+      shared_buf,
+      read_preds,
+      block_reduce_participate);
+
+  // If block reduction only, save to out and exit
+  if (!GRID_REDUCE) {
+    copyWelfordTripletTupleIf(
+        out,
+        block_result,
+        write_preds &&
+            (block_reduce_participate && (BROADCAST || has_block_result)));
+
+    // Need a block sync here as reduceGroupBlock does not
+    // forward-protect the smem buffer. This block sync is not
+    // necessary when a grid reduction follows since a block sync is
+    // done just before the grid sync.
+    block_sync::sync<Aligned>(block_dim);
+    return;
+  }
+
+  // -- START GRID REDUCTION -- //
+  // Grid reductions are more challenging for two reasons, (1) the reduction
+  // itself is 3D instead of 2D because we now have an iter domain space in
+  // the grid dimension. (2) a tree reduction isn't performed, instead all
+  // blocks will populate GMEM and one  block will finish the grid reduction.
+
+  // What is the grid reduction size, block reduction already performed so
+  // that doesn't have to be taken into consideration
+  const auto grid_red_size = index_utils::
+      maskedSize<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          gridDim);
+
+  // Which ID in the reduction is this block. Threads can participate in
+  // multiple grid reductions, but the block will have the same relative index
+  // in those reductions
+  const auto idx_in_grid_red = index_utils::
+      maskedOffset<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  // How many grid reductions have to be performed, in the grid dimension
+  const auto num_block_iters = index_utils::
+      maskedSize<isIter(X_BLOCK), isIter(Y_BLOCK), isIter(Z_BLOCK)>(gridDim);
+
+  // Which grid reduction does this block participate in, in the grid
+  // dimension
+  const auto block_red_idx_offset = index_utils::
+      maskedOffset<isIter(X_BLOCK), isIter(Y_BLOCK), isIter(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  // How many grid reductions have to be performed, in the block dimension
+  const auto num_thread_iters = index_utils::
+      maskedSize<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+          block_dim);
+
+  // Which grid reduction does this thread participate in, in the block
+  // dimension
+  const auto thread_red_idx_offset = index_utils::
+      maskedOffset<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+          threadIdx, block_dim);
+
+  // 3D buffer of reductions:
+  //    [reduction_offset(grid), iter_offset(grid), iter_offset(block)]
+  // Offset into the work buffer
+  auto work_buf_offset =
+      (idx_in_grid_red * num_block_iters + block_red_idx_offset) *
+          num_thread_iters +
+      thread_red_idx_offset;
+
+  // Don't read/write in temporary buffers if in a predicated dimension
+  bool grid_reduce_participate = index_utils::
+      maskedIsZero<isPred(X_BLOCK), isPred(Y_BLOCK), isPred(Z_BLOCK)>(blockIdx);
+
+  VolatilePtrWelfordTripletTuple<NumArgs, DataType, IndexType>
+      global_work_buffer(
+          global_work_buffer_avg, global_work_buffer_var, global_work_buffer_N);
+
+  if (PERSISTENT_REDUCTION && flip) {
+    auto global_buffer_size =
+        index_utils::
+            maskedSize<isIter(X_BLOCK), isIter(Y_BLOCK), isIter(Z_BLOCK)>(
+                gridDim) *
+        index_utils::
+            maskedSize<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+                block_dim) *
+        grid_red_size;
+    global_work_buffer += global_buffer_size;
+  }
+  flip = !flip;
+
+  // Per-block partial reduction to global work buffer
+
+  if (grid_reduce_participate && block_reduce_participate && has_block_result) {
+    copyWelfordTripletTuple(global_work_buffer, work_buf_offset, block_result);
+  }
+
+  // -- GLOBAL BUFFER FILLED -- //
+
+  bool last_block = index_utils::
+      maskedIsLast<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  if (grid_reduce_participate) {
+    // Don't need to sync up blocks that are not participating in this
+    // reduction
+    grid_sync::sync<
+        isReduce(X_BLOCK),
+        isReduce(Y_BLOCK),
+        isReduce(Z_BLOCK),
+        PERSISTENT_REDUCTION,
+        Aligned>(
+        global_sync_buffer[block_red_idx_offset],
+        grid_red_size,
+        last_block,
+        block_dim);
+  }
+
+  // -- START BLOCK CLEANUP -- //
+  welfordGroupLastBlock<Aligned, NumArgs, DataType, IndexType>(
+      out,
+      global_work_buffer,
+      LocalWelfordTripletTuple<NumArgs, DataType, IndexType>(
+          init_avg, init_var, init_N),
+      block_dim,
+      shared_buf,
+      block_red_idx_offset,
+      num_thread_iters,
+      num_block_iters,
+      thread_red_idx_offset,
+      grid_red_size,
+      write_preds,
+      block_reduce_participate,
+      grid_reduce_participate);
+
+  // Forward protect the smem buffer
+  block_sync::sync<Aligned>(block_dim);
+}
+
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <
+    bool Aligned,
+    int NumArgs,
+    typename DataType,
+    typename IndexType,
+    typename BlockDimT>
+__device__ __inline__ void ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    welfordGroup(
+        typename MakeRefTuple<NumArgs, DataType>::type out_avg,
+        typename MakeRefTuple<NumArgs, DataType>::type out_var,
+        typename MakeRefTuple<NumArgs, IndexType>::type out_N,
+        const typename MakeConstRefTuple<NumArgs, DataType>::type& inp_avg,
+        const typename MakeConstRefTuple<NumArgs, DataType>::type& inp_var,
+        const typename MakeConstRefTuple<NumArgs, IndexType>::type& inp_N,
+        const typename MakeLocalTuple<NumArgs, DataType>::type& init_avg,
+        const typename MakeLocalTuple<NumArgs, DataType>::type& init_var,
+        const typename MakeLocalTuple<NumArgs, IndexType>::type& init_N,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        typename MakeVolatilePtrTuple<NumArgs, DataType>::type
+            global_work_buffer_avg,
+        typename MakeVolatilePtrTuple<NumArgs, DataType>::type
+            global_work_buffer_var,
+        typename MakeVolatilePtrTuple<NumArgs, IndexType>::type
+            global_work_buffer_N,
+        int64_t* global_sync_buffer,
+        PtrTuple<DataType, DataType, IndexType> shared_buf,
+        const typename MakeLocalTuple<NumArgs, bool>::type& read_preds,
+        const typename MakeLocalTuple<NumArgs, bool>::type& write_preds,
+        int64_t& cycles,
+        int64_t& count) {
+  int64_t start_counter = 0;
+
+  if (isLastBlockInGrid() &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    start_counter = readCycleCounter();
+  }
+
+  welfordGroup<Aligned, NumArgs, DataType, IndexType>(
+      out_avg,
+      out_var,
+      out_N,
+      inp_avg,
+      inp_var,
+      inp_N,
+      init_avg,
+      init_var,
+      init_N,
+      block_dim,
+      global_work_buffer_avg,
+      global_work_buffer_var,
+      global_work_buffer_N,
+      global_sync_buffer,
+      shared_buf,
+      read_preds,
+      write_preds);
+
+  if (isLastBlockInGrid() &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    cycles += readCycleCounter() - start_counter;
+    ++count;
+  }
+}
+
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <
+    bool BLOCK_BROADCAST,
+    bool Aligned,
+    int NumVals,
+    typename DataType,
+    typename IndexType,
+    typename BlockDimT>
+__device__ __inline__ void ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    welfordGroupBlock(
+        LocalWelfordTripletTuple<NumVals, DataType, IndexType>& block_result,
+        const ConstRefWelfordTripletTuple<NumVals, DataType, IndexType>& inp,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        PtrTuple<DataType, DataType, IndexType> shared_buf,
+        const typename MakeLocalTuple<NumVals, bool>::type& read_preds,
+        bool block_reduce_participate) {
+  const bool has_block_result = index_utils::
+      maskedIsZero<isReduce(X_THREAD), isReduce(Y_THREAD), isReduce(Z_THREAD)>(
+          threadIdx);
+
+  copyWelfordTripletTupleIf(
+      block_result, inp, block_reduce_participate && read_preds);
+
+  // Size of the block reduction segment, can be an int since it's limited
+  // to number of threads
+  const int block_reduction_size = index_utils::
+      maskedSize<isReduce(X_THREAD), isReduce(Y_THREAD), isReduce(Z_THREAD)>(
+          block_dim);
+
+  // Index in the reduction segment, can be an int since it's limited to
+  // number of threads
+  const int tid_in_block_reduction = index_utils::
+      maskedOffset<isReduce(X_THREAD), isReduce(Y_THREAD), isReduce(Z_THREAD)>(
+          threadIdx, block_dim);
+
+  // ID of the block reduction this thread is participating in
+  //
+  // If any of the parallel dimensions are predicated out, that means
+  // they've already been reduced, so we only care about the first thread in
+  // that dimension. Therefore don't expand the reduction_idx by that
+  // dimension
+  const int block_reduction_idx = index_utils::
+      maskedOffset<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+          threadIdx, block_dim);
+
+  // Do not protect the smem buffer as it's not always necessary.
+  impl::blockWelfordEach<
+      BLOCK_BROADCAST,
+      false,
+      Aligned,
+      NumVals,
+      DataType,
+      IndexType,
+      BlockDimT>(
+      block_result,
+      block_result,
+      shared_buf,
+      has_block_result,
+      tid_in_block_reduction,
+      block_reduction_size,
+      block_reduction_size,
+      block_reduction_idx,
+      block_dim);
+}
+
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <
+    bool Aligned,
+    int NumVals,
+    typename DataType,
+    typename IndexType,
+    typename BlockDimT>
+__device__ __inline__ void ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    welfordGroupLastBlock(
+        RefWelfordTripletTuple<NumVals, DataType, IndexType>& out,
+        const VolatilePtrWelfordTripletTuple<NumVals, DataType, IndexType>&
+            global_work_buffer,
+        const LocalWelfordTripletTuple<NumVals, DataType, IndexType>& init_val,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        PtrTuple<DataType, DataType, IndexType> shared_buf,
+        nvfuser_index_t block_red_idx_offset,
+        nvfuser_index_t num_thread_iters,
+        nvfuser_index_t num_block_iters,
+        nvfuser_index_t thread_red_idx_offset,
+        nvfuser_index_t grid_red_size,
+        const typename MakeLocalTuple<NumVals, bool>::type& write_preds,
+        bool block_reduce_participate,
+        bool grid_reduce_participate) {
+  // Initialize block result
+  auto last_block_result = init_val;
+
+  const bool last_block = index_utils::
+      maskedIsLast<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  if ((PERSISTENT_REDUCTION || last_block) && grid_reduce_participate) {
+    // Can use the last block to reduce all the values the blocks filled in.
+    // Can use any thread that has been predicated, or has been reduced to do
+    // this reduction, cannot use any block that's associated with an
+    // iteration domain
+
+    // Start with non-block reduction
+
+    // Index in the reduction segment
+    int tid_in_block_reduction = index_utils::maskedOffset<
+        activeNotIter(X_THREAD),
+        activeNotIter(Y_THREAD),
+        activeNotIter(Z_THREAD)>(threadIdx, block_dim);
+
+    int block_reduction_size = index_utils::maskedSize<
+        activeNotIter(X_THREAD),
+        activeNotIter(Y_THREAD),
+        activeNotIter(Z_THREAD)>(block_dim);
+
+    bool has_block_result = index_utils::maskedIsZero<
+        activeNotIter(X_THREAD),
+        activeNotIter(Y_THREAD),
+        activeNotIter(Z_THREAD)>(threadIdx);
+
+    // 3D buffer of reductions:
+    //    [reduction_offset(grid), iter_offset(grid), iter_offset(block)]
+    // Change the offset, we want to keep the last two dimensions, but the
+    // first dimension is what we will reduce over
+    const auto work_buf_offset =
+        block_red_idx_offset * num_thread_iters + thread_red_idx_offset;
+    for (auto reduction_i = tid_in_block_reduction; reduction_i < grid_red_size;
+         reduction_i += block_reduction_size) {
+      impl::welfordEach(
+          last_block_result,
+          0,
+          global_work_buffer,
+          work_buf_offset + reduction_i * num_block_iters * num_thread_iters);
+    }
+
+    // Which block reduction this thread is participating in
+    int block_reduction_idx = index_utils::
+        maskedOffset<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+            threadIdx, block_dim);
+
+    impl::blockWelfordEach<
+        BROADCAST,
+        false,
+        Aligned,
+        NumVals,
+        DataType,
+        IndexType>(
+        last_block_result,
+        last_block_result,
+        shared_buf,
+        has_block_result,
+        tid_in_block_reduction,
+        block_reduction_size,
+        min(grid_red_size, block_reduction_size),
+        block_reduction_idx,
+        block_dim);
+
+    copyWelfordTripletTupleIf(
+        out,
+        last_block_result,
+        write_preds &&
+            (block_reduce_participate && (BROADCAST || has_block_result)));
+  }
+}
+
+} // namespace fused_reduction
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+namespace fused_reduction {
+namespace impl {
+
+// Grouped block welford optimized for outer reductions with
+// TIDx and TIDy mapped to non-reduction and reduction domains,
+// respectively with unused TIDz.
+//
+// The main motivation of this optimized version is the same as the
+// grouped grid reduction, i.e, by doing multiple reductions together,
+// it is possible to reduce the number of synchronizations. However,
+// unlike the grouped grid reduction, the cost of grouping can be
+// prohitively high, i.e., the size of the work buffer must be
+// expanded by a factor of grouping. In the case of grid
+// reductions, the buffer is on global memory, so the space requirement
+// is not a concern, but that isn't the case with block reductions,
+// since the buffer is on shared memory, which has a limited
+// capacity.
+//
+// This implementation tries to benefit from aggregated block
+// synchronizations while minimizing the cost of the expanded buffer
+// size by first partially reducing the input within each warp. It
+// would save the required buffer size by a factor of WARP_SIZE /
+// blockDim.x as the reduction is done along threadIdx.y. So to be
+// effective, blockDim.x needs to be smaller than WARP_SIZE, and in the
+// case of grouped grid welford, it should be typically 8 or 16.
+//
+// The algorithm is an adaptation of scattered butterfly reduction,
+// aka recursive halving, commonly used for implementing
+// MPI_Reduce_scatter. For a visual illustration of the data
+// organization, see, for example, page 22 of Solomonik,
+// Design of Parallel and High-Performance Computing:
+// Distributed-Memory Models and Algorithms, 2015
+// (https://solomonik.cs.illinois.edu/talks/dphpc-dec-2015.pdf)
+//
+// Assumptions:
+// - blockDim.x and blockDim.y are statically known values so that all
+// loops can be completely unrolled
+// - blockDim.x is smaller than WARP_SIZE
+// - blockDim.x evenly divides WARP_SIZE
+// - There are multiple warps per block
+// - The gouping factor, NumVals, is at least as large as the warp
+// dimY and is divisible by the warp dimY.
+//
+// This is meant to be used as part of the grouped grid welford
+// reduction but should be usable as a standalone block welford routine as
+// long as the above assumptions hold.
+//
+// Note: Having an output reference parameter resulted in using more
+// registers than just returing the output. Results would vary
+// depending on compiler versions, but it seems safer to return outputs
+// as a new value.
+template <
+    bool Aligned,
+    int NumVals,
+    typename DataType,
+    int BDIMX,
+    int BDIMY,
+    typename BlockDimT>
+__inline__ __device__ WelfordTriplet<DataType> blockWelfordOuter(
+    DataType* inp_avg,
+    DataType* inp_var,
+    nvfuser_index_t inp_N,
+    // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+    // there is no warp specialization in the kernel. If there is warp
+    // specialization, block_dim is the the dimension of the compute warps.
+    BlockDimT block_dim,
+    DataType* smem) {
+  constexpr int num_warps = BDIMX * BDIMY / 32;
+  static_assert(num_warps >= 1, "There must be at least a single warp");
+  static_assert(32 % BDIMX == 0, "blockDimx.x must be able to divide 32");
+
+  const int tid = threadIdx.x + threadIdx.y * BDIMX;
+  const int wid = tid / 32;
+
+  // Dimension of the Y axis within each warp
+  constexpr int wdimy = 32 / BDIMX;
+  static_assert(NumVals >= wdimy, "NumVals must be >= 32 / blockDim.x");
+  static_assert(
+      NumVals % wdimy == 0, "NumVals must be divisible by 32 / blockDim.x");
+  // There must be at least a single warp
+
+  // Y index within each warp
+  const int warp_tidy = threadIdx.y % wdimy;
+
+  // Thread index in each warp
+  const int lane_id = threadIdx.x + warp_tidy * BDIMX;
+
+  constexpr int smem_var_offset = num_warps * BDIMX * NumVals;
+  constexpr int smem_N_offset = num_warps * BDIMX * NumVals * 2;
+
+  // We define a chunk as a value in a group and a chunk size as the
+  // number of group values per thread. Initially, the chunk size is
+  // NumVals. After the initial warp reduction, the chunk size is
+  // reduced to NumVals/wdimy. For example, suppose NumVals=8,
+  // blockDim.x=8, blockDim.y=32, then wdimy=4, so after the initial
+  // warp reduction, the chunk size is 2. This is the number of
+  // elements each thread stores to shared memory.
+
+  int chunk_size = NumVals;
+
+  // Butterfly reduction, a.k.a. recursive halving as each iteration
+  // halves the number of values
+#pragma unroll
+  for (int lane_mask = 16; lane_mask >= BDIMX; lane_mask /= 2) {
+    chunk_size /= 2;
+
+    const auto peer_N = __shfl_xor_sync(0xffffffff, inp_N, lane_mask);
+    const auto updated_N = inp_N + peer_N;
+    const DataType b_N_div_ab_N =
+        updated_N != 0 ? ((DataType)peer_N) / ((DataType)updated_N) : 0;
+
+#pragma unroll
+    for (int index_in_chunk = 0; index_in_chunk < chunk_size;
+         ++index_in_chunk) {
+      DataType pushed_avg = 0;
+      DataType pushed_var = 0;
+      DataType self_avg = 0;
+      DataType self_var = 0;
+      // Divergent branch. Not a big deal with independent scheduling?
+      if (lane_id & lane_mask) {
+        // Push first half
+        auto push_offset = index_in_chunk;
+        auto self_offset = index_in_chunk + chunk_size;
+        pushed_avg = inp_avg[push_offset];
+        pushed_var = inp_var[push_offset];
+        self_avg = inp_avg[self_offset];
+        self_var = inp_var[self_offset];
+      } else {
+        // Push second half
+        auto push_offset = index_in_chunk + chunk_size;
+        auto self_offset = index_in_chunk;
+        pushed_avg = inp_avg[push_offset];
+        pushed_var = inp_var[push_offset];
+        self_avg = inp_avg[self_offset];
+        self_var = inp_var[self_offset];
+      }
+      auto peer_avg = __shfl_xor_sync(0xffffffff, pushed_avg, lane_mask);
+      auto peer_var = __shfl_xor_sync(0xffffffff, pushed_var, lane_mask);
+
+      auto delta = peer_avg - self_avg;
+      self_avg += delta * b_N_div_ab_N;
+      self_var += peer_var + delta * delta * ((DataType)(inp_N)) * b_N_div_ab_N;
+
+      inp_avg[index_in_chunk] = self_avg;
+      inp_var[index_in_chunk] = self_var;
+    }
+    inp_N = updated_N;
+  }
+
+  // At this point, chunk_size is reduced to NumVals/wdimy as
+  // mentioned above. Each thread has warp-reduced chunk_size values
+  // in array inp. This chunk_size_post_reduction should be equal to
+  // chunk_size at this point.
+  constexpr int chunk_size_post_reduction = NumVals / wdimy;
+
+  // More specifically, the warp_tidy of each thread defines
+  // the chunk IDs held by the thread as follows:
+  //
+  // [warp_tidy * chunk_size_post_reduction, warp_tidy *
+  // chunk_size_post_reduction + chunk_size_post_reduction]
+  //
+  // Each thread uploads the chunk_size_post_reduction values one by
+  // one. Each chunk is spread by BDIMX * BDIMY values. The data
+  // layout of the shared memory is:
+  //
+  // [chunk_size, wid, warp_tidy, TIDx]
+  //
+  // The remaining reduction is done on the WID
+  // dimension. More specifically, we assign one warp per chunk (or
+  // a value of the group). The wdimy threads of the same threadId.x
+  // collectively reduce num_warps partial results, each of which is
+  // stored with stride 32. This means that there will be wdimy-way
+  // bank conflicts, so to avoid that, swizzling is also employed.
+#pragma unroll
+  for (int i = 0; i < chunk_size; ++i) {
+    // Accumulating smem offset from the innermost dimension
+    int smem_offset = 0;
+    // TIDx
+    smem_offset += threadIdx.x;
+    // Warp_TIDy with swizzle
+    smem_offset += ((warp_tidy + wid) % wdimy) * BDIMX;
+    // WID
+    smem_offset += wid * 32;
+    // chunk_size
+    smem_offset += i * BDIMX * BDIMY;
+    smem[smem_offset] = inp_avg[i];
+    smem[smem_var_offset + smem_offset] = inp_var[i];
+    // Upload N only when threadIdx.x == 0 && chunk_index == 0
+    if (threadIdx.x == 0 && i == 0 && warp_tidy == 0) {
+      reinterpret_cast<nvfuser_index_t*>(smem + smem_N_offset)[wid] = inp_N;
+    }
+  }
+
+  block_sync::sync<Aligned>(block_dim);
+
+  // The next step is to let each thread of a warp independently
+  // accumulate the partial results on the shared memory
+  // reduction. A single warp is used to accumulate of the partial
+  // results for a single chunk, so warp wid takes care of the wid-th
+  // chunk.
+  //
+  // The starting offset of partial results of a chunk is:
+  //
+  // (wid % chunk_size_post_reduction) * BDIMX * BDIMY + (wid /
+  // chunk_size_post_reduction) * BDIMX
+  //
+  // Note that each thread had chunk_size_post_reduction contiguous
+  // chunks, so when uploaded to shmem, they are strided by
+  // BDIMX*BDIMY, hence (wid % chunk_size_post_reduction) * BDIMX *
+  // BDIMY.
+
+  // The vector width is likely at least 4, so at least 4 warps should
+  // be used, which is
+  // enough to occupy an SM. When NumVals=8, it might be more
+  // efficient to use just 4 warps with each warp taking care of two
+  // groups, but the difference would be pretty small.
+
+  // Also, the number of warps should be at least 8 and can be 16
+  // too. NumVals should be 8 at largest, so it's always num_warps >=
+  // NumVals.
+
+  DataType avg = 0;
+  DataType var = 0;
+  nvfuser_index_t N = 0;
+
+  static_assert(
+      num_warps >= NumVals,
+      "Number of warps must be at least as large as NumVals");
+
+  if (wid < NumVals) {
+#pragma unroll
+    for (int i = warp_tidy; i < num_warps; i += wdimy) {
+      int offset = 0;
+      offset += threadIdx.x;
+      // Offset to the partial results of the i-th warp
+      offset += i * 32;
+      // Offset to the chunk for this warp. Swizzled to avoid bank
+      // conflicts.
+      offset += ((wid / chunk_size + i) % wdimy) * BDIMX;
+      offset += (wid % chunk_size) * BDIMX * BDIMY;
+
+      DataType avg_smem = smem[offset];
+      DataType var_smem = smem[smem_var_offset + offset];
+      nvfuser_index_t N_smem =
+          reinterpret_cast<nvfuser_index_t*>(&smem[smem_N_offset])[i];
+
+      welfordCombine(avg, var, N, avg_smem, var_smem, N_smem);
+    }
+  }
+
+  block_sync::sync<Aligned>(block_dim);
+
+  // Nothing to do for warps whose wid is larger than NunVals
+  if (wid >= NumVals) {
+    WelfordTriplet<DataType> out = {0, 0, 0};
+    return out;
+  }
+
+  // Standard binary-exchange reduction within wdimy intra-warp
+  // threads.
+#pragma unroll
+  for (int lane_mask = 16; lane_mask >= BDIMX; lane_mask /= 2) {
+    auto avg_peer = __shfl_xor_sync(0xffffffff, avg, lane_mask);
+    auto var_peer = __shfl_xor_sync(0xffffffff, var, lane_mask);
+    auto N_peer = __shfl_xor_sync(0xffffffff, N, lane_mask);
+
+    welfordCombine(avg, var, N, avg_peer, var_peer, N_peer);
+  }
+
+  WelfordTriplet<DataType> out = {avg, var, N};
+  return out;
+}
+
+} // namespace impl
+} // namespace fused_reduction
+
+// clang-format off
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2023-present NVIDIA CORPORATION & AFFILIATES.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+// clang-format on
+namespace fused_reduction {
+
+namespace impl {
+
+// Utility struct to hold multiple values for grouped Welford. The
+// count is uniform, so there's only one N value.
+template <int NumVals, typename DataType>
+struct WelfordTripletVector {
+  Array<DataType, NumVals, NumVals> avg_;
+  Array<DataType, NumVals, NumVals> var_;
+  nvfuser_index_t N_;
+
+  WelfordTripletVector() = default;
+
+  __device__ WelfordTripletVector(
+      const DataType avg[NumVals],
+      const DataType var[NumVals],
+      const nvfuser_index_t N) {
+    memcpy(avg_.array, avg, sizeof(DataType) * NumVals);
+    memcpy(var_.array, var, sizeof(DataType) * NumVals);
+    N_ = N;
+  }
+
+  __device__ WelfordTripletVector& operator=(
+      const WelfordTripletVector<NumVals, DataType>& other) {
+    avg_ = other.avg_;
+    var_ = other.var_;
+    N_ = other.N_;
+    return *this;
+  }
+
+  __device__ void init() {
+    avg_.set((DataType)0);
+    var_.set((DataType)0);
+    N_ = 0;
+  }
+
+  __device__ DataType& avg(int idx) {
+    return avg_[idx];
+  }
+
+  __device__ DataType avg(int idx) const {
+    return avg_.array[idx];
+  }
+
+  __device__ DataType& var(int idx) {
+    return var_[idx];
+  }
+
+  __device__ DataType var(int idx) const {
+    return var_.array[idx];
+  }
+
+  __device__ nvfuser_index_t& N() {
+    return N_;
+  }
+
+  __device__ nvfuser_index_t N() const {
+    return N_;
+  }
+};
+
+// The offset in smem buffer to broadcast final results within a
+// thread block
+template <int BDIMX>
+__inline__ __device__ int getSmemGroupOffset(int iter_idx, int group_idx) {
+  return group_idx * BDIMX + iter_idx;
+}
+
+// Upload the final results to smem for intra-block broadcasting
+template <int NumVals, typename DataType, int BDIMX, int BDIMY>
+__inline__ __device__ void copyFromTripletToSmem(
+    DataType* smem,
+    int iter_idx,
+    int group_idx,
+    const WelfordTriplet<DataType>& local_triplet) {
+  int offset = getSmemGroupOffset<BDIMX>(iter_idx, group_idx);
+  smem[offset] = local_triplet.avg;
+  int smem_stride = BDIMX * NumVals;
+  smem[smem_stride + offset] = local_triplet.var;
+  if (iter_idx == 0 && group_idx == 0) {
+    reinterpret_cast<nvfuser_index_t*>(smem + smem_stride * 2)[0] =
+        local_triplet.N;
+  }
+}
+
+// Fetch the final results from smem for intra-block broadcasting
+template <int NumVals, typename DataType, int BDIMX, int BDIMY>
+__inline__ __device__ void copyFromSmemToTriplet(
+    WelfordTriplet<DataType>& local_triplet,
+    const DataType* smem,
+    int iter_idx,
+    int group_idx) {
+  int offset = getSmemGroupOffset<BDIMX>(iter_idx, group_idx);
+  local_triplet.avg = smem[offset];
+  int smem_stride = BDIMX * NumVals;
+  local_triplet.var = smem[smem_stride + offset];
+  local_triplet.N =
+      reinterpret_cast<const nvfuser_index_t*>(smem + smem_stride * 2)[0];
+}
+
+// Per-thread accumulation of the per-block partial results in global
+// memory. There's gridDim.y partial results, which is accumulated in
+// parallel by threadIdx.y. This should be followed by a block reduction.
+template <int NumVals, typename DataType, int BDIMX, int BDIMY>
+__device__ __inline__ WelfordTripletVector<NumVals, DataType>
+welfordGroupAccumulateGlobalBuffer(
+    volatile DataType* global_buf_avg,
+    volatile DataType* global_buf_var,
+    volatile nvfuser_index_t* global_buf_N,
+    bool flip) {
+  const int grid_size = gridDim.x * gridDim.y;
+  const int iter_idx = threadIdx.x;
+  const int red_idx = threadIdx.y;
+  const int num_threads_per_reduction = BDIMY;
+
+  WelfordTripletVector<NumVals, DataType> results;
+
+  results.init();
+
+  // Reduction is done cooperatively with the thread blocks with the
+  // same blockIdx.x. Thread blocks with the same blockIdx.x uses a
+  // global buffer of size blockDim.x * gridDim.y for each value in a
+  // group.
+
+  // Advance the global buffer pointers to the location of the values
+  // to accumulate for the first group value (i.e., gi == 0 in the
+  // below NumVals loop)
+  global_buf_avg += iter_idx + blockIdx.x * BDIMX * gridDim.y;
+  global_buf_var += iter_idx + blockIdx.x * BDIMX * gridDim.y;
+  global_buf_N += iter_idx + blockIdx.x * BDIMX * gridDim.y;
+
+  if (flip) {
+    global_buf_avg += BDIMX * grid_size * NumVals;
+    global_buf_var += BDIMX * grid_size * NumVals;
+    global_buf_N += BDIMX * grid_size * NumVals;
+  }
+
+  // Since there's gridDim.y elements to reduce using blockDim.y
+  // threads, loop over gridDim.y with stride blockDim.y. First, just
+  // grab the values in the global memory.
+
+  if (red_idx < gridDim.y) {
+    int work_buf_offset = red_idx * BDIMX;
+    // N is constant across NumVals
+    const auto g_N = global_buf_N[work_buf_offset];
+    results.N() = g_N;
+
+    // Just copy the first elements
+#pragma unroll
+    for (int gi = 0; gi < NumVals; ++gi) {
+      auto& a_avg = results.avg(gi);
+      auto& a_var = results.var(gi);
+      auto b_avg = global_buf_avg[work_buf_offset];
+      auto b_var = global_buf_var[work_buf_offset];
+      work_buf_offset += grid_size * BDIMX;
+
+      results.avg(gi) = b_avg;
+      results.var(gi) = b_var;
+    }
+  }
+
+  // Accumulate into results by looping over the remaining results in
+  // the global buffer
+  for (int ri = red_idx + num_threads_per_reduction; ri < gridDim.y;
+       ri += num_threads_per_reduction) {
+    int work_buf_offset = ri * BDIMX;
+    // N is constant across NumVals
+    const auto g_N = global_buf_N[work_buf_offset];
+    nvfuser_index_t updated_N = results.N() + g_N;
+
+    // Hoist the division by updated_N as it's invariant over the
+    // NumVals loop
+    DataType b_N_div_ab_N = updated_N != 0
+        ? (((DataType)g_N) / ((DataType)updated_N))
+        : (DataType)0;
+    DataType a_N_b_N_div_ab_N = ((DataType)results.N()) * b_N_div_ab_N;
+
+#pragma unroll
+    for (int gi = 0; gi < NumVals; ++gi) {
+      auto& a_avg = results.avg(gi);
+      auto& a_var = results.var(gi);
+      auto b_avg = global_buf_avg[work_buf_offset];
+      auto b_var = global_buf_var[work_buf_offset];
+      work_buf_offset += grid_size * BDIMX;
+
+      auto delta = b_avg - a_avg;
+      a_avg += delta * b_N_div_ab_N;
+      a_var += b_var + delta * delta * a_N_b_N_div_ab_N;
+    }
+    results.N() = updated_N;
+  }
+
+  return results;
+}
+
+} // namespace impl
+
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <
+    bool Aligned,
+    int NumVals,
+    typename DataType,
+    int BDIMX,
+    int BDIMY,
+    typename BlockDimT>
+__device__ __inline__ void ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    welfordGroupOuter(
+        DataType out_avg[NumVals],
+        DataType out_var[NumVals],
+        nvfuser_index_t out_N[NumVals],
+        const DataType in_avg[NumVals],
+        const DataType in_var[NumVals],
+        nvfuser_index_t in_N,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        DataType* global_buf_avg,
+        DataType* global_buf_var,
+        nvfuser_index_t* global_buf_N,
+        DataType* shared_buf,
+        int64_t* global_sync_buffer) {
+  using namespace fused_reduction::impl;
+
+  static_assert(
+      isIter(X_BLOCK) && isReduce(Y_BLOCK) && inactive(Z_BLOCK) &&
+          isIter(X_THREAD) && isReduce(Y_THREAD) && inactive(Z_THREAD),
+      "Invalid parallelization for outer welford reduction");
+
+  static_assert(
+      BDIMY % NumVals == 0, "blockDim.y must be divisible by group count");
+  static_assert(BDIMX <= 32, "blockDim.x must be up to 32.");
+  static_assert(
+      (BDIMX * BDIMY) % 32 == 0, "Number of threads must be a multiple of 32.");
+  static_assert(32 % BDIMX == 0, "blockDim.x must be able to divide 32.");
+  static_assert(
+      NumVals >= (32 / BDIMX), "Group count must be >= 32 / blockDim.x");
+
+#pragma unroll
+  for (int i = 0; i < NumVals; ++i) {
+    out_avg[i] = in_avg[i];
+    out_var[i] = in_var[i];
+  }
+
+  auto iter_tid = index_utils::
+      maskedOffset<isIter(X_THREAD), isIter(Y_THREAD), isIter(Z_THREAD)>(
+          threadIdx, block_dim);
+
+  auto per_block_result =
+      impl::blockWelfordOuter<Aligned, NumVals, DataType, BDIMX, BDIMY>(
+          out_avg, out_var, in_N, block_dim, shared_buf);
+
+  // At this point, threads with tid_in_group == 0 has valid partial
+  // results. Store them to global buffer.
+
+  const int grid_size = gridDim.x * gridDim.y;
+  const int iter_idx = threadIdx.x;
+
+  // Stores the partial results into the global work buffer. Only
+  // threads with tid_in_group have the valid partial results
+  const int wid = (threadIdx.x + threadIdx.y * BDIMX) / 32;
+  constexpr int wdimy = 32 / BDIMX;
+  const int warp_tidy = threadIdx.y % wdimy;
+  const bool has_valid_block_reduction_result = warp_tidy == 0 && wid < NumVals;
+  // Each valid result is held by a warp
+  const int valid_group_idx = wid;
+
+  if (has_valid_block_reduction_result) {
+    int work_buf_offset = iter_idx + blockIdx.y * BDIMX +
+        blockIdx.x * BDIMX * gridDim.y + valid_group_idx * BDIMX * grid_size;
+    if (PERSISTENT_REDUCTION && flip) {
+      auto global_buffer_size = BDIMX * grid_size * NumVals;
+      work_buf_offset += global_buffer_size;
+    }
+
+    global_buf_avg[work_buf_offset] = per_block_result.avg;
+    global_buf_var[work_buf_offset] = per_block_result.var;
+
+    // the count values should be the same across the group, so just
+    // store once
+    if (valid_group_idx == 0) {
+      global_buf_N[work_buf_offset] = per_block_result.N;
+    }
+  }
+
+  flip = !flip;
+
+  // -- GLOBAL BUFFER FILLED -- //
+
+  bool last_block = index_utils::
+      maskedIsLast<isReduce(X_BLOCK), isReduce(Y_BLOCK), isReduce(Z_BLOCK)>(
+          blockIdx, gridDim);
+
+  grid_sync::sync<
+      isReduce(X_BLOCK),
+      isReduce(Y_BLOCK),
+      isReduce(Z_BLOCK),
+      PERSISTENT_REDUCTION,
+      Aligned>(
+      global_sync_buffer[blockIdx.x], gridDim.y, last_block, block_dim);
+
+  auto partial_results =
+      welfordGroupAccumulateGlobalBuffer<NumVals, DataType, BDIMX, BDIMY>(
+          global_buf_avg, global_buf_var, global_buf_N, !flip);
+
+  auto per_block_final_result =
+      impl::blockWelfordOuter<Aligned, NumVals, DataType, BDIMX, BDIMY>(
+          partial_results.avg_.array,
+          partial_results.var_.array,
+          partial_results.N_,
+          block_dim,
+          shared_buf);
+
+  // At this point, each thread of the groups with tid_in_group=0
+  // has the final reduction result. We need to upload them to
+  // shmem for broadcasting.
+  if (has_valid_block_reduction_result) {
+    copyFromTripletToSmem<NumVals, DataType, BDIMX, BDIMY>(
+        shared_buf, iter_idx, valid_group_idx, per_block_final_result);
+  }
+
+  __syncthreads();
+
+#pragma unroll
+  for (int i = 0; i < NumVals; ++i) {
+    WelfordTriplet<DataType> final_result;
+    copyFromSmemToTriplet<NumVals, DataType, BDIMX, BDIMY>(
+        final_result, shared_buf, iter_idx, i);
+    out_avg[i] = final_result.avg;
+    out_var[i] = final_result.var;
+    in_N = final_result.N;
+  }
+
+#pragma unroll
+  for (int i = 0; i < NumVals; ++i) {
+    out_N[i] = in_N;
+  }
+
+  // Forward protect the smem buffer
+  __syncthreads();
+}
+
+template <
+    int X_BLOCK,
+    int Y_BLOCK,
+    int Z_BLOCK,
+    int X_THREAD,
+    int Y_THREAD,
+    int Z_THREAD,
+    bool PERSISTENT_REDUCTION,
+    bool BROADCAST>
+template <
+    bool Aligned,
+    int NumVals,
+    typename DataType,
+    int BDIMX,
+    int BDIMY,
+    typename BlockDimT>
+__device__ __inline__ void ParallelReduce<
+    X_BLOCK,
+    Y_BLOCK,
+    Z_BLOCK,
+    X_THREAD,
+    Y_THREAD,
+    Z_THREAD,
+    PERSISTENT_REDUCTION,
+    BROADCAST>::
+    welfordGroupOuter(
+        DataType out_avg[NumVals],
+        DataType out_var[NumVals],
+        nvfuser_index_t out_N[NumVals],
+        const DataType in_avg[NumVals],
+        const DataType in_var[NumVals],
+        nvfuser_index_t in_N,
+        // block_dim is basically just blockDim (wrapped as DefaultBlockDim) if
+        // there is no warp specialization in the kernel. If there is warp
+        // specialization, block_dim is the the dimension of the compute warps.
+        BlockDimT block_dim,
+        DataType* global_buf_avg,
+        DataType* global_buf_var,
+        nvfuser_index_t* global_buf_N,
+        DataType* shared_buf,
+        int64_t* global_sync_buffer,
+        int64_t& cycles,
+        int64_t& count) {
+  int64_t start_counter = 0;
+
+  if (isLastBlockInGrid() &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    start_counter = readCycleCounter();
+  }
+
+  welfordGroupOuter<Aligned, NumVals, DataType, BDIMX, BDIMY>(
+      out_avg,
+      out_var,
+      out_N,
+      in_avg,
+      in_var,
+      in_N,
+      block_dim,
+      global_buf_avg,
+      global_buf_var,
+      global_buf_N,
+      shared_buf,
+      global_sync_buffer);
+
+  if (isLastBlockInGrid() &&
+      index_utils::maskedIsZero<true, true, true>(threadIdx)) {
+    cycles += readCycleCounter() - start_counter;
+    ++count;
+  }
+}
+
+} // namespace fused_reduction
+__global__ void nvfuser_none_f0_c0_r0_g0(Tensor<__half, 3, 3> T0, Tensor<__half, 3, 3> T1, const __grid_constant__ TensorMap var0, const __grid_constant__ TensorMap var1, Tensor<__half, 2, 2> T3) {
+  alignas(16) extern __shared__ char array[];
+  const unsigned smem_offset = 0;
+  nvfuser_index_t i2;
+  i2 = ceilDiv(T0.logical_size[0LL], 16);
+  const TensorMap* ptr3;
+  ptr3 = &var0;
+  nvfuser_index_t i4;
+  i4 = 256 * ((nvfuser_index_t)blockIdx.x);
+  __half* T5 = reinterpret_cast<__half*>(array + smem_offset + 16512);
+  unsigned i5;
+  i5 = toSmem(T5);
+  const TensorMap* ptr6;
+  ptr6 = &var1;
+  nvfuser_index_t i7;
+  i7 = 128 * ((nvfuser_index_t)blockIdx.y);
+  __half* T4 = reinterpret_cast<__half*>(array + smem_offset + 128);
+  unsigned i8;
+  i8 = toSmem(T4);
+  unsigned i9;
+  i9 = i8 + (2048 * ((nvfuser_index_t)threadIdx.y));
+  nvfuser_index_t i10;
+  i10 = ((nvfuser_index_t)threadIdx.x) / 4;
+  nvfuser_index_t i11;
+  i11 = 2 * (((nvfuser_index_t)threadIdx.x) % 4);
+  nvfuser_index_t i12;
+  i12 = i10 / 8;
+  nvfuser_index_t i13;
+  i13 = i10 % 8;
+  nvfuser_index_t i14;
+  i14 = ((((i11 + ((16 * T1.logical_size[2LL]) * i12)) + (T1.logical_size[2LL] * i13)) + ((64 * T1.logical_size[2LL]) * ((nvfuser_index_t)threadIdx.y))) + i4) + ((128 * T1.logical_size[2LL]) * ((nvfuser_index_t)blockIdx.y));
+  nvfuser_index_t i15;
+  i15 = 8 * T1.logical_size[2LL];
+  bool b16;
+  b16 = ((nvfuser_index_t)threadIdx.x) < 32ULL;
+  bool b17;
+  b17 = ((nvfuser_index_t)threadIdx.y) == 0ULL;
+  bool b18;
+  b18 = ((nvfuser_index_t)threadIdx.y) < 2;
+  nvfuser_index_t i19;
+  i19 = ((1 - T1.logical_size[2LL]) + i11) + i4;
+  nvfuser_index_t i20;
+  i20 = ((((-T0.logical_size[1LL]) + (16 * i12)) + i13) + (64 * ((nvfuser_index_t)threadIdx.y))) + i7;
+  float T2[128];
+  ((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))).set(0);
+  asm volatile("wgmma.fence.sync.aligned;\n");
+  asm volatile("fence.proxy.async;\n");
+  uint64_t* T7 = reinterpret_cast<uint64_t*>(array + smem_offset + 0);
+  #pragma unroll
+  for(nvfuser_index_t i21 = 0; i21 < 4; ++i21) {
+    if (((Hopper::electSync(4294967295U) && b16) && b17)) {
+      mbarrier::init(toSmem((&T7[i21])), 2U);
+    }
+  }
+  #pragma unroll
+  for(nvfuser_index_t i22 = 0; i22 < 4; ++i22) {
+    if (((Hopper::electSync(4294967295U) && b16) && b17)) {
+      mbarrier::init(toSmem((&T7[(i22 + 4LL)])), 256U);
+    }
+  }
+  __syncthreads();
+  if ((((nvfuser_index_t)threadIdx.y) == 2)) {
+    #pragma unroll 4
+    for(nvfuser_index_t i23 = 0; i23 < i2; ++i23) {
+      nvfuser_index_t i24;
+      i24 = 16 * i23;
+      nvfuser_index_t i25;
+      i25 = i23 % 4;
+      unsigned i26;
+      i26 = i5 + (8192 * i25);
+      unsigned i27;
+      i27 = i8 + (4096 * i25);
+      if ((Hopper::electSync(4294967295U) && b16)) {
+        mbarrier::waitParity(toSmem((&T7[((i23 % 4) + 4LL)])), (uint32_t)(((i23 / 4) % 2)));
+        mbarrier::arriveExpectTX(toSmem((&T7[(i23 % 4)])), 8192U);
+        #pragma unroll
+        for(nvfuser_index_t i28 = 0; i28 < 4; ++i28) {
+          Hopper::cpAsyncBulkTensorTileG2S((Hopper::CpAsyncBulkTensorTileG2SIndex<2>{ ptr3, (Array<nvfuser_index_t, 2, 1>{(i4 + (64 * i28)), i24}), toSmem((&T7[(i23 % 4)])) }), (i26 + (2048 * i28)));
+        }
+        mbarrier::arriveExpectTX(toSmem((&T7[(i23 % 4)])), 4096U);
+        #pragma unroll
+        for(nvfuser_index_t i29 = 0; i29 < 2; ++i29) {
+          Hopper::cpAsyncBulkTensorTileG2S((Hopper::CpAsyncBulkTensorTileG2SIndex<2>{ ptr6, (Array<nvfuser_index_t, 2, 1>{(i7 + (64 * i29)), i24}), toSmem((&T7[(i23 % 4)])) }), (i27 + (2048 * i29)));
+        }
+      }
+    }
+  } else {
+    #pragma unroll
+    for(nvfuser_index_t i30 = 0; i30 < 4; ++i30) {
+      mbarrier::arrive(toSmem((&T7[(i30 + 4LL)])));
+    }
+    #pragma unroll 4
+    for(nvfuser_index_t i31 = 0; i31 < i2; ++i31) {
+      nvfuser_index_t i32;
+      i32 = i31 % 4;
+      unsigned i33;
+      i33 = i9 + (4096 * i32);
+      unsigned i34;
+      i34 = i5 + (8192 * i32);
+      mbarrier::waitParity(toSmem((&T7[(i31 % 4)])), (uint32_t)(((i31 / 4) % 2)));
+      asm volatile(
+        "{\n"
+        "  .reg .pred p0; \n"
+        "  setp.ne.b32 p0, %130, 0;\n"
+        "  wgmma.mma_async.sync.aligned.m64n256k16.f32.f16.f16 {%0, %1, %2, %3, %4, %5, %6, %7, %8, %9, %10, %11, %12, %13, %14, %15, %16, %17, %18, %19, %20, %21, %22, %23, %24, %25, %26, %27, %28, %29, %30, %31, %32, %33, %34, %35, %36, %37, %38, %39, %40, %41, %42, %43, %44, %45, %46, %47, %48, %49, %50, %51, %52, %53, %54, %55, %56, %57, %58, %59, %60, %61, %62, %63, %64, %65, %66, %67, %68, %69, %70, %71, %72, %73, %74, %75, %76, %77, %78, %79, %80, %81, %82, %83, %84, %85, %86, %87, %88, %89, %90, %91, %92, %93, %94, %95, %96, %97, %98, %99, %100, %101, %102, %103, %104, %105, %106, %107, %108, %109, %110, %111, %112, %113, %114, %115, %116, %117, %118, %119, %120, %121, %122, %123, %124, %125, %126, %127}, %128, %129, p0, %131, %132, %133, %134;\n"
+        "}\n"
+        :"+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[0]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[1]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[2]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[3]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[4]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[5]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[6]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[7]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[8]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[9]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[10]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[11]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[12]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[13]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[14]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[15]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[16]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[17]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[18]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[19]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[20]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[21]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[22]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[23]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[24]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[25]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[26]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[27]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[28]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[29]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[30]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[31]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[32]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[33]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[34]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[35]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[36]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[37]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[38]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[39]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[40]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[41]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[42]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[43]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[44]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[45]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[46]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[47]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[48]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[49]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[50]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[51]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[52]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[53]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[54]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[55]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[56]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[57]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[58]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[59]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[60]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[61]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[62]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[63]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[64]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[65]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[66]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[67]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[68]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[69]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[70]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[71]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[72]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[73]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[74]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[75]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[76]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[77]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[78]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[79]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[80]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[81]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[82]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[83]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[84]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[85]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[86]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[87]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[88]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[89]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[90]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[91]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[92]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[93]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[94]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[95]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[96]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[97]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[98]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[99]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[100]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[101]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[102]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[103]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[104]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[105]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[106]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[107]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[108]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[109]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[110]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[111]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[112]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[113]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[114]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[115]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[116]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[117]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[118]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[119]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[120]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[121]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[122]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[123]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[124]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[125]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[126]),
+         "+f"((*reinterpret_cast<Array<float, 128, 1>*>(&T2[0]))[127])
+        :"l"((4611686293305294848ULL | ((262143ULL & (uint64_t)(i33)) >> 4ULL))),
+         "l"((4611686293313683456ULL | ((262143ULL & (uint64_t)(i34)) >> 4ULL))),
+         "n"((uint32_t)(true)),
+         "n"(1),
+         "n"(1),
+         "n"(1),
+         "n"(1)
+      );
+      mbarrier::arrive(toSmem((&T7[((i31 % 4) + 4LL)])));
+    }
+  }
+  #pragma unroll
+  for(nvfuser_index_t i35 = 0; i35 < 4; ++i35) {
+    if (((Hopper::electSync(4294967295U) && b16) && b17)) {
+      mbarrier::inval(toSmem((&T7[(i35 + 4LL)])));
+    }
+  }
+  #pragma unroll
+  for(nvfuser_index_t i36 = 0; i36 < 4; ++i36) {
+    if (((Hopper::electSync(4294967295U) && b16) && b17)) {
+      mbarrier::inval(toSmem((&T7[i36])));
+    }
+  }
+  asm volatile("wgmma.commit_group.sync.aligned;\n");
+  asm volatile("wgmma.wait_group.sync.aligned %0;\n"::"n"(0LL):"memory");
+  #pragma unroll
+  for(nvfuser_index_t i37 = 0; i37 < 32; ++i37) {
+    nvfuser_index_t i38;
+    i38 = 4 * i37;
+    nvfuser_index_t i39;
+    i39 = 8 * i37;
+    nvfuser_index_t i40;
+    i40 = i14 + i39;
+    bool b41;
+    b41 = b18 && (i19 < (-i39));
+    #pragma unroll
+    for(nvfuser_index_t i42 = 0; i42 < 2; ++i42) {
+      nvfuser_index_t i43;
+      i43 = i38 + (2 * i42);
+      Array<__half, 2, 2> T6;
+      #pragma unroll
+      for(nvfuser_index_t i44 = 0; i44 < 2; ++i44) {
+        T6[i44]
+           = __float2half(T2[(i43 + i44)]);
+      }
+      if ((b41 && (i20 < (-(8 * i42))))) {
+        loadLocalToGlobal<__half, /*vec_size=*/2, /*is_volatile=*/false>( &T3[(i40 + (i15 * i42))], &T6[0]);
+      }
+    }
+  }
+}
+}
+
diff --git a/nsys-log.txt b/nsys-log.txt
new file mode 100644
index 00000000000..a67c33f1a26
--- /dev/null
+++ b/nsys-log.txt
@@ -0,0 +1,221 @@
+# $NVFUSER_DUMP="cuda_to_file" nsys nvprof ./bin/test_matmul --gtest_filter=HopperMatmulTest.HSH_NT_128BSwizzle
+WARNING: test_matmul and any of its children processes will be profiled.
+
+Collecting data...
+Running main() from /opt/pytorch/nvfuser/third_party/googletest/googletest/src/gtest_main.cc
+Note: Google Test filter = HopperMatmulTest.HSH_NT_128BSwizzle
+[==========] Running 1 test from 1 test suite.
+[----------] Global test environment set-up.
+[----------] 1 test from HopperMatmulTest
+[ RUN      ] HopperMatmulTest.HSH_NT_128BSwizzle
+PRINTING: __tmp_kernel_none_f0_c0_r0_g0.cu
+[       OK ] HopperMatmulTest.HSH_NT_128BSwizzle (1366 ms)
+[----------] 1 test from HopperMatmulTest (1366 ms total)
+
+[----------] Global test environment tear-down
+[==========] 1 test from 1 test suite ran. (1367 ms total)
+[  PASSED  ] 1 test.
+Generating '/tmp/nsys-report-bf35.qdstrm'
+[1/7] [========================100%] report1.nsys-rep
+[2/7] [========================100%] report1.sqlite
+[3/7] Executing 'nvtx_sum' stats report
+
+ Time (%)  Total Time (ns)  Instances   Avg (ns)     Med (ns)    Min (ns)   Max (ns)   StdDev (ns)   Style                                  Range
+
+ --------  ---------------  ---------  -----------  -----------  ---------  ---------  -----------  -------  -------------------------------------------------------------------
+     33.8        346690728          1  346690728.0  346690728.0  346690728  346690728          0.0  PushPop  :KernelExecutor::compileFusion
+
+     30.5        313685389          1  313685389.0  313685389.0  313685389  313685389          0.0  PushPop  :executor_utils::NVRTC
+
+     30.5        313357655          1  313357655.0  313357655.0  313357655  313357655          0.0  PushPop  :executor_utils::Nvrtc::CompileProgram
+
+      1.1         11663565          1   11663565.0   11663565.0   11663565   11663565          0.0  PushPop  :GpuLower::Lower::IndexLowering::getIndexedExprs
+      0.9          9601713          1    9601713.0    9601713.0    9601713    9601713          0.0  PushPop  :GpuLower::lower
+
+      0.6          5855399          1    5855399.0    5855399.0    5855399    5855399          0.0  PushPop  :ConditionalFromPredicateModifier::ConditionalFromPredicateModifier
+      0.4          4498029          1    4498029.0    4498029.0    4498029    4498029          0.0  PushPop  :KernelExecutor::runFusion
+
+      0.4          4266882          1    4266882.0    4266882.0    4266882    4266882          0.0  PushPop  :fusion_executor::allocations::allocateOutputs
+      0.4          4259360          1    4259360.0    4259360.0    4259360    4259360          0.0  PushPop  :fusion_executor::allocations::allocateTensor
+      0.1          1465079          1    1465079.0    1465079.0    1465079    1465079          0.0  PushPop  :GpuLower::Lower::replaceSymbolicSizes
+
+      0.1          1281591          2     640795.5     640795.5     608888     672703      45124.0  PushPop  :Index::getCpAsyncBulkGmemIndex
+
+      0.1           721652          1     721652.0     721652.0     721652     721652          0.0  PushPop  :generateCudaKernel
+
+      0.1           676934          7      96704.9       4875.0        453     598347     222062.7  PushPop  :IrContainer clear
+
+      0.1           649428         20      32471.4      28826.0       6961      57475      13460.2  PushPop  :transform_replay.cpp::getMatchedLeafPosWithoutReplayCasP
+      0.1           562594          1     562594.0     562594.0     562594     562594          0.0  PushPop  :GpuLower::Lower::UnswitchPredicate::get
+
+      0.1           555928          1     555928.0     555928.0     555928     555928          0.0  PushPop  :GpuLower::Lower::UnswitchPredicate::openLoop
+      0.1           554544          1     554544.0     554544.0     554544     554544          0.0  PushPop  :GpuLower::Lower::UnswitchPredicate::openIte
+      0.1           552128          1     552128.0     552128.0     552128     552128          0.0  PushPop  :GpuLower::Lower::UnswitchPredicate::predicateOn
+      0.0           474897        410       1158.3        536.5        233      23945       1879.5  PushPop  :ExpressionEvaluator::evaluate
+
+      0.0           466710          2     233355.0     233355.0     224148     242562      13020.7  PushPop  :GpuLower::Lower::Index::getConsumerStridedIndices
+      0.0           431526          1     431526.0     431526.0     431526     431526          0.0  PushPop  :GpuLower::Lower::Index::getReferenceRootPredicates
+      0.0           422979          1     422979.0     422979.0     422979     422979          0.0  PushPop  :GpuLower::Lower::Index::getProducerStridedIndices
+      0.0           325974          1     325974.0     325974.0     325974     325974          0.0  PushPop  :reuseMemoryAllocations
+
+      0.0           301718          5      60343.6      65254.0      41861      75235      13530.5  PushPop  :GpuLower::Lower::updateIndexCompute
+
+      0.0           283658          5      56731.6      42030.0      34163     118951      35252.8  PushPop  :TransformReplay::replayPasC
+
+      0.0           269600          1     269600.0     269600.0     269600     269600          0.0  PushPop  :GpuLower::Lower::validateIr
+
+      0.0           251157          1     251157.0     251157.0     251157     251157          0.0  PushPop  :GpuLower::Lower::validateIterDomainUse
+
+      0.0           221892          1     221892.0     221892.0     221892     221892          0.0  PushPop  :GpuLower::Lower::getGlobalConsumerIndex
+
+      0.0           221542          7      31648.9      26959.0       9633      53309      18265.3  PushPop  :TransformReplay::replayCasP
+
+      0.0           212673          1     212673.0     212673.0     212673     212673          0.0  PushPop  :IrContainer copy
+
+      0.0           208919          1     208919.0     208919.0     208919     208919          0.0  PushPop  :GpuLower::Lower::insertAllocations
+
+      0.0           145336          1     145336.0     145336.0     145336     145336          0.0  PushPop  :Fusion copy
+
+      0.0           140574          1     140574.0     140574.0     140574     140574          0.0  PushPop  :executor_utils::NvrtcCreateProgram
+
+      0.0           137294          1     137294.0     137294.0     137294     137294          0.0  PushPop  :KernelExecutor::initializeExecutorEntry
+
+      0.0           131736          1     131736.0     131736.0     131736     131736          0.0  PushPop  :GpuLower::Lower::LoopNestGenerator::loweredExprs
+      0.0           115538          1     115538.0     115538.0     115538     115538          0.0  PushPop  :executor_utils::Nvrtc::LoadPTX
+
+      0.0            93821          1      93821.0      93821.0      93821      93821          0.0  PushPop  :SyncMap::SyncMap
+
+      0.0            82446          6      13741.0       9194.0       4811      41149      13565.9  PushPop  :Fusion::resetTvUses
+
+      0.0            82075          1      82075.0      82075.0      82075      82075          0.0  PushPop  :PrecomputedValues::PrecomputedValues
+
+      0.0            72991          1      72991.0      72991.0      72991      72991          0.0  PushPop  :GpuLower::Lower::insertGridSerializationSyncs
+      0.0            66913          1      66913.0      66913.0      66913      66913          0.0  PushPop  :GpuLower::Lower::insertWarAsyncWait
+
+      0.0            65913          4      16478.3      13254.0      12330      27075       7108.3  PushPop  :transform_replay.cpp::getMatchedLeafPosWithoutReplayPasC
+      0.0            64205          1      64205.0      64205.0      64205      64205          0.0  PushPop  :GpuLower::Lower::ThreadPredicateMap
+
+      0.0            62985          1      62985.0      62985.0      62985      62985          0.0  PushPop  :KernelExecutor::computeArgs
+
+      0.0            61459          7       8779.9       5682.0        193      25171       9143.0  PushPop  :getKernelArgument
+
+      0.0            59083          1      59083.0      59083.0      59083      59083          0.0  PushPop  :GpuLower::Lower::validateVectorize
+
+      0.0            52447          2      26223.5      26223.5      18958      33489      10275.0  PushPop  :KernelExecutor::computeLaunchParams
+
+      0.0            49045         70        700.6        340.0        146      11229       1773.2  PushPop  :getTerminatingOutputs
+
+      0.0            47589          1      47589.0      47589.0      47589      47589          0.0  PushPop  :GpuLower::Lower::UnrollPass::runPass
+
+      0.0            38321          1      38321.0      38321.0      38321      38321          0.0  PushPop  :GpuLower::Lower::insertRawThreadSynchronization
+      0.0            28726          1      28726.0      28726.0      28726      28726          0.0  PushPop  :Kernel::analyze
+
+      0.0            26032          1      26032.0      26032.0      26032      26032          0.0  PushPop  :KernelExecutor::supported
+
+      0.0            22062          1      22062.0      22062.0      22062      22062          0.0  PushPop  :PrecomputedValues::bindInputs
+
+      0.0            20239          8       2529.9       3005.0        699       3766       1211.4  PushPop  :KernelExecutor::ParallelBindingResolution
+      0.0            18622          1      18622.0      18622.0      18622      18622          0.0  PushPop  :GpuLower::Lower::insertWarThreadSynchronization
+      0.0            17332          1      17332.0      17332.0      17332      17332          0.0  PushPop  :GpuLower::Lower::processMisalignedVectorization
+      0.0            16848          1      16848.0      16848.0      16848      16848          0.0  PushPop  :GpuLower::Lower::vectorizeWelford
+
+      0.0            16278          1      16278.0      16278.0      16278      16278          0.0  PushPop  :GpuLower::Lower::MisalignedVectorizationModifier
+      0.0            14582          2       7291.0       7291.0       3400      11182       5502.7  PushPop  :executor_utils::bindInputs
+
+      0.0            12959          1      12959.0      12959.0      12959      12959          0.0  PushPop  :KernelExecutor::runFusion::execute_kernel
+      0.0             9355          1       9355.0       9355.0       9355       9355          0.0  PushPop  :ExecutorRunFusion::cuLaunchKernel
+
+      0.0             7470          5       1494.0       1195.0        907       2535        680.7  PushPop  :GpuLower::Lower::ThreadPredicateMap::updateBitSet
+      0.0             5905          2       2952.5       2952.5        835       5070       2994.6  PushPop  :PrecomputedValues::Evaluate
+
+      0.0             4285          1       4285.0       4285.0       4285       4285          0.0  PushPop  :fusion_executor::allocations::getOutbufferInfo
+      0.0             3910         12        325.8        275.5        187        710        141.0  PushPop  :GpuLower::Lower::IndexCompute::IndexCompute
+      0.0             3487          1       3487.0       3487.0       3487       3487          0.0  PushPop  :fusion_executor::allocations::getBufferInfo
+      0.0             3042          2       1521.0       1521.0        368       2674       1630.6  PushPop  :PrecomputedValuess::Validate
+
+      0.0             2939          2       1469.5       1469.5       1387       1552        116.7  PushPop  :fusion_executor::allocations::computeSharedMemory
+      0.0             2372          1       2372.0       2372.0       2372       2372          0.0  PushPop  :KernelExecutor::validateVectorizedTensors
+      0.0             2280          1       2280.0       2280.0       2280       2280          0.0  PushPop  :KernelExecutor::recomputeArgs
+
+      0.0             2218          1       2218.0       2218.0       2218       2218          0.0  PushPop  :fusion_executor::allocations::inferShapeOfOutput
+      0.0             1812          1       1812.0       1812.0       1812       1812          0.0  PushPop  :executor_utils::NvrtcDestroyProgram
+
+      0.0             1515          3        505.0        503.0        408        604         98.0  PushPop  :GpuLower::Lower::getInlinePredicate
+
+      0.0              579          1        579.0        579.0        579        579          0.0  PushPop  :KernelExecutor::runFusion::intermediates
+
+      0.0              530          1        530.0        530.0        530        530          0.0  PushPop  :fusion_executor::allocations::inferShape
+
+      0.0              520          1        520.0        520.0        520        520          0.0  PushPop  :GpuLower::Lower::insertMagicZero
+
+      0.0              371          1        371.0        371.0        371        371          0.0  PushPop  :KernelExecutor::getIntermediateBufferInfo
+
+[4/7] Executing 'cuda_api_sum' stats report
+
+ Time (%)  Total Time (ns)  Num Calls  Avg (ns)   Med (ns)   Min (ns)  Max (ns)  StdDev (ns)                        Name
+ --------  ---------------  ---------  ---------  ---------  --------  --------  -----------  ------------------------------------------------
+     66.6         60848371         17  3579315.9  1358264.0      3404  12968043    4456513.8  cudaLaunchKernel
+     26.5         24224471         15  1614964.7  1135046.0     23751   3518519    1143699.1  cuLibraryLoadData
+      3.1          2818835          1  2818835.0  2818835.0   2818835   2818835          0.0  cudaGetDeviceProperties_v2_v12000
+      1.3          1152285          1  1152285.0  1152285.0   1152285   1152285          0.0  cudaFree
+      1.3          1148664         10   114866.4   129926.5      2424    170853      50599.6  cudaMalloc
+      0.8           761842          1   761842.0   761842.0    761842    761842          0.0  cudaHostAlloc
+      0.1           131534        838      157.0      109.0        54       869        103.4  cuGetProcAddress_v2
+      0.1            85445          1    85445.0    85445.0     85445     85445          0.0  cuModuleLoadDataEx
+      0.1            69924          1    69924.0    69924.0     69924     69924          0.0  cuLaunchKernelEx
+      0.1            56223          1    56223.0    56223.0     56223     56223          0.0  cuModuleUnload
+      0.0            42609         15     2840.6     3359.0       337      6672       1733.9  cuLibraryGetKernel
+      0.0            17938         11     1630.7     1189.0       197      7041       1932.6  cudaStreamIsCapturing_v10000
+      0.0            13875          1    13875.0    13875.0     13875     13875          0.0  cudaMemcpyAsync
+      0.0             8862          1     8862.0     8862.0      8862      8862          0.0  cudaStreamSynchronize
+      0.0             7985         18      443.6      253.0       181      1624        459.7  cudaEventCreateWithFlags
+      0.0             7060         18      392.2      302.0       284      1768        344.6  cudaOccupancyMaxActiveClusters_v11070
+      0.0             6934          1     6934.0     6934.0      6934      6934          0.0  cudaMemsetAsync
+      0.0             6317          1     6317.0     6317.0      6317      6317          0.0  cuLaunchKernel
+      0.0             4201          3     1400.3     1292.0      1058      1851        407.4  cuInit
+      0.0             1632          1     1632.0     1632.0      1632      1632          0.0  cudaOccupancyAvailableDynamicSMemPerBlock_v10200
+      0.0             1457          2      728.5      728.5       100      1357        888.8  cuTensorMapEncodeTiled
+      0.0             1457          2      728.5      728.5       261      1196        661.1  cuKernelSetAttribute
+      0.0             1413          3      471.0      109.0        86      1218        647.0  cuModuleGetLoadingMode
+      0.0              862          2      431.0      431.0       341       521        127.3  cudaGetDriverEntryPoint_v11030
+      0.0              482          2      241.0      241.0       108       374        188.1  cuKernelGetAttribute
+
+[5/7] Executing 'cuda_gpu_kern_sum' stats report
+
+ Time (%)  Total Time (ns)  Instances  Avg (ns)  Med (ns)  Min (ns)  Max (ns)  StdDev (ns)                                                  Name
+
+ --------  ---------------  ---------  --------  --------  --------  --------  -----------  ----------------------------------------------------------------------------------------------------
+     33.8           135999          1  135999.0  135999.0    135999    135999          0.0  <unnamed>::nvfuser_none_f0_c0_r0_g0(<unnamed>::Tensor<<unnamed>::__half, (int)3, (int)3>, <unnamed>…
+     22.6            91103          1   91103.0   91103.0     91103     91103          0.0  nvjet_hsh_128x256_64x4_2x1_v_bz_coopA_NTN
+
+     20.1            80672          2   40336.0   40336.0     40256     40416        113.1  void at::native::<unnamed>::distribution_elementwise_grid_stride_kernel<float, (int)4, void at::nat…
+      4.8            19424          3    6474.7    6464.0      6432      6528         48.9  void at::native::vectorized_elementwise_kernel<(int)4, at::native::AbsFunctor<c10::Half>, std::arra…
+      3.3            13472          2    6736.0    6736.0      6656      6816        113.1  void at::native::vectorized_elementwise_kernel<(int)4, at::native::BinaryFunctor<c10::Half, c10::Ha…
+      2.8            11104          1   11104.0   11104.0     11104     11104          0.0  void at::native::vectorized_elementwise_kernel<(int)4, at::native::CUDAFunctor_add<c10::Half>, std:…
+      2.1             8512          1    8512.0    8512.0      8512      8512          0.0  void at::native::reduce_kernel<(int)512, (int)1, at::native::ReduceOp<bool, at::native::func_wrappe…
+      1.8             7167          1    7167.0    7167.0      7167      7167          0.0  void at::native::vectorized_elementwise_kernel<(int)4, at::native::<unnamed>::CompareFunctor<c10::H…
+      1.7             6720          1    6720.0    6720.0      6720      6720          0.0  void at::native::vectorized_elementwise_kernel<(int)4, at::native::CUDAFunctorOnSelf_add<c10::Half>…
+      1.6             6528          1    6528.0    6528.0      6528      6528          0.0  void at::native::vectorized_elementwise_kernel<(int)4, at::native::AUnaryFunctor<c10::Half, c10::Ha…
+      1.2             4960          1    4960.0    4960.0      4960      4960          0.0  void at::native::vectorized_elementwise_kernel<(int)4, at::native::BinaryFunctor<bool, bool, bool, …
+      1.0             4192          1    4192.0    4192.0      4192      4192          0.0  void at::native::vectorized_elementwise_kernel<(int)4, at::native::BinaryFunctor<bool, bool, bool, …
+      1.0             4160          1    4160.0    4160.0      4160      4160          0.0  void at::native::vectorized_elementwise_kernel<(int)4, at::native::BinaryFunctor<bool, bool, bool, …
+      1.0             4160          1    4160.0    4160.0      4160      4160          0.0  void at::native::vectorized_elementwise_kernel<(int)4, at::native::FillFunctor<c10::Half>, std::arr…
+      1.0             4128          1    4128.0    4128.0      4128      4128          0.0  void at::native::vectorized_elementwise_kernel<(int)4, at::native::AUnaryFunctor<c10::Half, c10::Ha…
+
+[6/7] Executing 'cuda_gpu_mem_time_sum' stats report
+
+ Time (%)  Total Time (ns)  Count  Avg (ns)  Med (ns)  Min (ns)  Max (ns)  StdDev (ns)           Operation
+ --------  ---------------  -----  --------  --------  --------  --------  -----------  ----------------------------
+     72.6             2880      1    2880.0    2880.0      2880      2880          0.0  [CUDA memcpy Device-to-Host]
+     27.4             1088      1    1088.0    1088.0      1088      1088          0.0  [CUDA memset]
+
+[7/7] Executing 'cuda_gpu_mem_size_sum' stats report
+
+ Total (MB)  Count  Avg (MB)  Med (MB)  Min (MB)  Max (MB)  StdDev (MB)           Operation
+ ----------  -----  --------  --------  --------  --------  -----------  ----------------------------
+      0.000      1     0.000     0.000     0.000     0.000        0.000  [CUDA memset]
+      0.000      1     0.000     0.000     0.000     0.000        0.000  [CUDA memcpy Device-to-Host]
+
+Generated:
+    /opt/pytorch/nvfuser/report1.nsys-rep
+    /opt/pytorch/nvfuser/report1.sqlite
diff --git a/report1.nsys-rep b/report1.nsys-rep
new file mode 100644
index 0000000000000000000000000000000000000000..047659b4a9437fc7a9e7db8df5a869de63e17624
GIT binary patch
literal 284494
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%0D@-Rj3?QnE(?Biu-%
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
G{r>`bddPnO

literal 0
HcmV?d00001

diff --git a/report1.sqlite b/report1.sqlite
new file mode 100644
index 0000000000000000000000000000000000000000..da819b5fef6781c8b5fb39b3f1271ed814b8ae5a
GIT binary patch
literal 864256
zcmeFa31A~<eg7@%zDHI_R?2~uJDXkG8r^c@1h1{#b=FsWY_bW7kR{nxR+hYy?A^@)
z$d(UDyXC$L6lkG^w3I*#eYwjGX-lC{3KYtpa+QYCLTS0%_xsFfW}as(d%a28{`<ah
z8?%09=K0QZ{C>~pIcMt5kz6I~n=6(UQx#uO<I;3=XrANqX*8M+{PzX?C;iOeAA0Ez
z{4cqFp`Q*-&x1<_+~wdtOz!;*_e<{IxgT*q;J(NGJ@<9)%iI^Z&vKvPJ}zFqP;}2+
zfBJL4Xf_Iw*8C>ZzV7ahtxGDY*?e|jY+&TX)bLbtC^0=SJTj&J`{3YYVqiMqn;tkc
zlJKdo`fjrN@YCJx8_HHvxqR7|nk_C@e3gZ)FI7n8&z5s#UpZSY=Zb|Mt8njpzBrr8
zAJ1jTgQ}n5vFXH-#3Vw;#;1K_Gb1AhRd)z~LT)Ns%BAwT2eTR95h23iOpg$KX1SEA
zK&{<#dyjq^?_ViaQh8q`x0v;nmr?~^aZX59wou8HaJ7_5XMHyn%KJs#awS!&Op}|p
z|6GKw5UUWEpp1VlF8Oi=Um;Z}mb2+%Aybz0ic34l`L^qAe<y?>8>d@(#id>3_ODGD
zP5Xw2J2tKss?7Aj<dMX5a(L|UcycN+H8ngwmYhQ1baHxl6t!r#s|T3swEMlS%C%fc
zCzguog|YJXRJ2msww6$LBc(IbgFYb|DxvU%Vpg|`Hl13kETe3dQib+Tne3ZR+&z6E
zVKJAdNZpX?k0gRZ#XE_GnJ=bO`5lCa43(6f{z+_N2N@xDu_BX%rb_eKN{@B_#uWzB
zzHqpsd170sjtvhA#Y>lu6n4XoB`Dp|Dz_su!$Uj0?e-elHYbs&v25jZv2+qPP|23&
zh|Q6B1ye`aRkCBLwkD_K+J!vHP<ADUScS-7W{X)N?m{j-+|EOh1U;3PAI^x;w|{FP
zyY~L-+w(?#|BR5T_DR_L`%fkgCnghPgNZ3$Vr*tKIR>*IN*o^^OeBYgZpvl$3yE3D
z7Ba=se}&fZ#MsdIB(0Ut6;6(%&Spz(YS#92wYf=fd+pLSGCX!HIelUxA*5@6tw(R#
z7ms&rp5A61QzxdT6Qjw**m2rEl+Y`8v=HT<mW}M8F>GrXRKkei@7Ne-SKt)d8_C|Q
z*)|IioffHU)O#@h+<W8`rQ%YyR5>e{o)U4Qu)N5`*!p988Mn<JWQrVdmPECZ$}eZd
z=!Ji_iyL9v-@EONbo8y5_pjM?rhWVOcdR4F!Bvn?gL|ebrEF@k%>H!+Q$g5kOvRY^
zucD;6Ts}+6ubt8EJ&P$bLOOGW`Qc2NSPvnK!%$G%DZr%yaB3&l#+~kz=ey~N8SQHc
zS@*BaYfbxZys=}`AryxUu7`(563ic$GljuiYLx|2Ga#`n$v9a=@P2KJsFi~4S&0i1
zlf$C}lP7$~5+_=97XoN1OWC<>DO*5WL{(O)pxR{#sjO{lKYO!O7)z<jg7C(BD2xk5
zi#T^H459F)q9AW0`nkPUXZHPDe?hXXpWDBBO^0b;S64^v5}~B!nkfH6%apJjtd#Cx
zu~07Na~ZMY07fchm$H>yCAUJjfK+U;NPyn|4MpD0KcVOL;Sv1$;{<*^dMkdtF^FHU
zycxgFU4vgQyd1yAF2S#3PW+16@hfP<uU;#D^%zOt{1WaZ_^t7_`sPn?-{HQ&eFZ)9
zzu-Q_eS~{I_ipYT+}pU{;a<<ZihGIe%eGJ1K45#R?d7(rZOQgr+pw)ie?YI({e$k4
zx<AzYw(gYfxGtn~YJZ~rlJ+f{FKRM{ZoQ_OO5QUTNL3;QWadgX5MRlrE5#D&s3o)c
z>>`}N>0CLRJee&OviaeWTqrR%<xlcFs!aaya)I1DJQhsz{?O4>elC$nOjW|EQYm$I
zcp^Qr$Ri-JlAHD?r}^aC*g?H!^J+#g97-M;89y{Il1z>zlc8C^KNJdOk^w$Blp{qs
zyG%NVV`La4pG+?&{ps**BpVBdf*I;M^Q!ZuTqa4L&B(7kN8bA$^5XGIc5x|>Cbk?(
zFK1E#e?g2oRmddKMJ$xbhzp&dxrwo<Bp)4|85%f}Eo9MIMS>AU;+}gDVJOK5TQRh9
zXeypWiYJeer~K1dRMgU;R5_c-WTrtN$7b>?iDWvTSZV#67yp<+)(Ov%$714R!vJWa
zCOnSpn+_xsGx>=CUK}r)5kO&LA(t<n2_=I8s3rW!+9^I6h%$LoSkC8DrL$5IPDPV*
zk-2;^RSDr;r_d!lN|dMWNKTC;Cyz}BlhYw0loQ`5N8Ttb>I@>s1lh#YF>-hB0i7mG
za>ln*D#G&-!-G+#d~^Bb@`4YYdcmihsrb@pRV&%dl{f1&w-3%tOb`1ev*qG)3C?pA
z;|}veMf2>}X^_$6>Tm%CxJ+uFVB^=_q|=O(@;Z{Oh;)NSm|#dQTTZS7k}G_`@Avy|
z)M<_Y^6sWyCs%-5AOjCVJl-30ns|D7w3u1WXA##(F_pnf<L_+m^%qRb@-QOv%^}M2
zLN;T)PN%tIrf{-QJYBf#TAd~+zB%dqfOabjNO8t@4c<tVL8>>p8gHb!qfGjR*~|?-
zon}f%PBvA_pWQK0Z$Hze*Zl4B;LPE})5+tBNz%XX=lPx>{*RAqrbcEaN73I;OeCiV
zrjAV|ClZs%vGJiqKd-rad<>;8J>&1;Lp>qQ==k&yD#iF+WBp61MGbj5sS`0iIh2^}
zpBNlY9-5f~=4+<#_~7{1SYmKmQ1$l&dU!tG6Y_<Fk!Zxn`+LHHo(O*PzCb{8Y#2R~
z@#M((k>p6?cw(eKj`y3K8AJSsW{&g+AvQHJFgcZw--!?OgnObr!C)&LW8}@J@akg|
z6ZB0au_5WEnNcLPA2lK%M>wKnjlU;?n**%~NuDGphKKq?{&*l5i?s4&XkZ$t9-i#)
zEftHE-X5V(-dkQsm9o8O(EKb&?<3?X-bc*lv5Cp?LGpStgM-Pzk>sI)DRj-JN2dDk
zC(kamZo6ar5OS}dkMQAGI6?&?@zcXXR?em>X-Q;oVkUWLcx*`M?(`Rmg{)@m_~Dr;
z6yzYX0b@C1Lj#jT{Q<w`==f+teCJlI6VoS>cMXpvC&%yV4@s#zIy^N!K6xTZ;A+Pd
z_AbD~7U4J^C>IN2qPwH1us`Pa$Gg+9c(gl|352@iVSlPS9S_b0gLC0PIuhz3_iGUU
zAnFFGJOkukBarNm_V|4<{1?Z6s2cbc=<y$zn7&&xHZ^?Y=rrom=)}ylQv3mbAl$?E
z_)#sz3??~;?4W9KAP~}wPb9_;jSNi5HNsCy*snpCufI22Nu%J1*}+vvLSoNOc>qEo
z)Qdn*AdI{n9vVjJPY%N}l7j;i1BZr3P%5Z*>EhzjawU5Ztx`T$IeTygjZ9H<bYk#s
zSsGFBnu+m|6GtWoCXSwv!;yw~4<FP_3{NBvVT=|YRP2{d3=AF{I3iT)$)VAK!SP8Y
z{XyiEX8NA~fkku~)2ZH(VmUcbm`BT8)=XmnPcmI(Ci0dfS;%oYIM5R#wj%_hE@Bv9
z6jJ^3xk^4Y+r5}7qmAh)AQib(57O2b_WQ%VnS5_%{!B0Nw|yv}Sa&A7lFfH7&n_1#
z%g82wsJlDhkMTi19%`8jDYuctG_ngeGbL3ic>lTFyjXR5N!H~-X)vBXp-cobVuN?E
zwcdHL<pq;4u`HKMv`O}g0~_1#*=D?L?rhbs!I2rbN;t>?*ip7fa(Q?f<E11A2a(|u
z1Jg(Qdx@|ZDaoYXTp^ub&SW(s!-po(Q)quvJ~tZ)^_DBkv*kY7e5b}|CNVf8IGW;8
zrFZEpEH1s!TUeP}E@w+(?oJMhH;{@fW?CuTlj&=DCMJ`~1-$aW*wo?i$x);uF?Iw#
zSE(nY298evw<gdZ7{0r|m#8i*rO))DcybyP<8X3xa3DEb$tNr6rDSd{*-Bl1wz3e^
zAZmD4$wc7ohGqt*#oU^>V{C-fw6U?|;mL8#48UQ@6%qB2IH##;GGfzzCKgFXM6)G=
z(p@2#dK7WrF_AbT2ciZB(FO#=%FCsT`FwIg_?<0)kagZ?qZL)P{H<2B^D3QYKOC?x
zl_w=e>Yw{co#w!`fx+UU+|e&`SLig?U&~LY$|on63*fxY%kdm3-R{In<tTV7Uvhi#
zoT`;~dk{u$Lu=y?hRE-%WuH#ty?1QtZ23O!GDIu<(<jK?=e`v8->lMp7H+zk(l%Y9
z(_Bg_K<%_!uc?>G8xgizOyvqU?f1=<ii<v>;8fM6x3Z8cWs*z4hqJx&#o|2dEnBY8
z|16i%z4Ih6Nh0e>r>$efO195;M7Y~GjVmCWJluk>-*>dQ1jrgqRTh`?<Vw#`H1}iE
zNj?xeG<7=n;Dh<B_1=E@=RTkGqP&kth%egucX=7}nLXBfyXBwzS~Ef7y;*pnQn5gg
z4--(8?&T%b&2*gV7qi~$14W1(&-?cD+UV4eO%IP9>GLI%mBpnN94ATJnw;||)Ba@1
zpPcviq?Zx5_%nXYx2L#$H}Szp#J5=9&!%>_1jx^bvsnAB?4#n8+4hX8fDF4c08q9V
zXeB!Pedssz2vSkJo+O3zO$<y;B{2AZpHIBK$9hSpPSZWOuv|Fl8;}jh>C$PgZB-sp
zC#E=bAP@8+|KPAl8`4`S=jInG$?{n=EQ{sdQ_HCg`eNdIB6=u+Kr|MOzzGV2Y`sh9
zs39oMN6=r(U>*{fHScojG&dFyLw7!f{^dfpq;u#rjw$=osg*62h?dc&(_E66zRO~T
z#U2(W*NhefRdN}l8UKqHbeZrv<+H@icwTWCe(!rZ>6>5n(lhvd=}Q*y`&lpU!S736
zL?+?g=a1rd=Q(nxtML$ibM<@h+qrceemgcuJofcCe%sbwfZx{D0sJ;s$)vq8hhK&}
z@Jru~Um7wj3153;XmW6TLIH_D5B#JCv@@NYOia&AqH!WL@7IX5MVjJ)9U3aqdZsFJ
z>ysEGlf)WvRGd&+e`+xUzbv8_@yvp^7Jw79F+L^pQmfeq$Pc5hp&1!W4vdWS5BAJV
zAMTDxOfWEbwAHkU?Rq+e(rnT5$oL={p;l`mc0<VE+vET`630o`L;~EQ;VI!I#d`)O
zKzc)%*SHJA|Kv764Z5!q=FO(c3q9mlDb3~v5P5oLs-LvtzM&EZI!eCrV+vAIEH3Jx
zPjh(q2;Bjon^~#(J2W#qGDJW=zz5>~NZ7BzpSwbUSOC3XfgYGZzE4dO%60lu%ee4V
z`%n~F3sc69ll+<*ZI2+cxdIFog9EAZVk_}SriX{7P<N(|CPqfY;znP7ajBB56pQ(j
zxr%0JU_@!5`JNDny$3+p0(=zv_+82A!x(@VoDmRw9Ig4}u+Y6!kX^v3bP;LJB{TWC
z(@Dh8-GUq;w#4B9rN!?F0y32z1c2grEIEMcC{|c>oJ1B7#Yz7W=s!6=PWlfhx5-i5
zAcBZQ7V(~V92mjJgtnSM?SabtgFD1Rs+CZ(=maLvsS1Sn0Pjba?rzD#V2vR4Lo<ib
z8Ea+a)XbsL;prqnoPKzgT%jBE=nwSZcMs^0fOeT8ZOz09v4<qRAqJ(=*@a?01L_-`
zfniYaM0zuL{UD5f?1*e-ca2Y?x=jt=L+n7zYN3~p`iSxrdi|ugL^{ku=Sz4WbZ^8<
zcpAO&Bj}_Gz)M)SPwuS;f_;$~AMK0BW1&8tbkdbU1TwEEb$SQUR~wtcjGvSWQaR9L
zr{s@Jj?YZ=pP5fd86|gS$x9J~0f~-`4-B=aIyc)Z(qT7-la|kP&li@7xjc}?03ZOa
zr(Em_^gZ;5X8I`lP)PpFA*stPyd!)A(kszB8k{i3Gmrtv@d>53gn<syuTt`e_!P1h
zqMwfjF$Um|M5Ipn^f<b5<3~;;2Zn|wNhWpAFD-Y&e3yzDlx}V|ozJG`{DE$Nh!nLT
zNI*Dw$ME#w8F=Re83Wiuk4r+i<t2=uWxLDiQf{eI?rQ~i7f8FBKZ~vy@m?9y|B6N<
zQNH_uTxD*Vtb*u9gN&gr^d4FXlQO#h)N(FcIVgB>jNG9AiTZ#(f!O!xFT*L5;V{i8
zJix%%IC`?fQ^RN%T7y3D4hMq=LkGhLBM0LLdH+G4IA<hJn1GcEo|u#}N+Z<6k%5^p
zv;dRIiSfzl{$L#crx_c>posJgddk6`LiS7r{Z`l*#*Jj_)TsMe=$!PzeYNp_s!*Xr
zrV1;o{+9n#E(k&5pYm0)hqsKrkq|_BN~y)vgBT3S&ZS5g43&(a$O+=nyMh5kH5h*)
zok$_!;dn4A)g~cdwi%@2Y?7nHLu0}~$ney7%pc(e@6*i(x-pjQ_xB0^-|dh3{Vfl5
z*YGrmoIEjdf()L(1;H7#1~Am+2m{iLVEqpnE$M&QC$v3CMK1;u%1gPWtnd0Vahn4e
z@(^2Yq2-mGi{MPiq5{|x8RC+A#u%_|-`+_5;+FRiJ*3drT_`Ss1c+0>h~M}KYJ`%B
z=mWxsz}qDSLn0$w(*s9Tm73gsXdH$mRPNSAF?*?3Y&A(zg+rs$(;D-bD3&XuS*)z-
z;iJ4XEQSFYu?1<h{Bno86~9=cg$zgzPY51CcA0!gGjSK3Si4@ln114?DBmoMVqs)~
zWM{uLh(+2M>1|P)NT*qRnA}A@EDV~G@}`Yz;I66U_~GFsV`PX0L$VqnE2WqhDwQP+
z!hi*&0f+8%uD2UJzLbU6&6ay*pb_c=Jm?InIq}kHGWtgb?m5wVEm9|xrDUS}3<pDS
zp8_@rH5;MvKq!b@Rva!FyQCWh0SCqOf#)zt(BF%~>V*gF4Ms6eJ%kczjmTnjNgns1
z-GMMRE7b475mGVQRc}(mVVI-+XV4rkb_c={3?dXU%!2rV5u^!dG2e0l&u2@$WL_Z}
zilUFA5b4b5L_cveK%^x4%30xYX<^+Uz<jD-9K1oSQm_EhmCD&x9uQ7xjZEg3ON+f_
z@*5*?g*gHSN5{v8$FYoOT*&U_${d(l$T7mvl66le?wlD$^KwUGnv5U{<dGa5M=GYI
zVIxsN95NDqm(n|p8l5RGNS9i7Ql&L8I7s5f=qCekk_W)}E%;0Au_Z^0LOhcyw_@8i
z13^^@6hD>Q!iAyM#DFwdFAZi7j*npQTpI2tmGI8-DX<usC8XZ_2pgp^$$*&)KsyLY
zc3<O%?ifOm?wo-1a&h*7%<|%rNXh-g_4krqhGu$nLU3p30W0xgD1L|Tm*fvgb(1Ov
zc}0w;#6qp1+t#SFWUApPnL%l#34<2nz@>4l?;^|&E)hV7f~#$93*k|khIZspp(E8A
z#>G?)ZDm4QyGhqX9KRL*rbb!CS)h^O1gZ%9Av*(vS)W#O#JHfP2MT#WObe|?#}6kI
z-VOJJx=WeG6sc~)0Jz}Lh7Tpl#1mj~;BMS3OhplIBzZ{1B?=5qJ7%$xk;)^YNFWA=
z5d#^%BUJ$IVXVJ=I)~Yp9`=6<m?cCF7&(r*r%5XQrCeGrNG-lZi2?^QgQ=LVEaYaB
zr&FZ@IzMwMz*=%1;~z^{Mv^<DqyqDF#1A^q|L@UcG+2}W_gIPlN$x$E>3=O(=c?RU
zuE5Q4ot)kI3+G#$uW-K5ZnXW{_Je2U|65BHo|*rDX8vDZj-Z-te`fxlnmK)D{vQh?
zo|*sOX@$cx^Z(Dx|35STFLx83ng4%g{{NZz|7Yg^FSsN^p38q`{{R0&^Z#iwC5lD8
z<psM@r|H6q01}eR*bF+&Rq1@HT*e<xJy{@uHAKns^6X-+V$@*~!Qx`lt%c_hmXGJs
zgGDT(!(^bNL#MfVs+b<lVySw%?9kxPBTLKjpBl|on!nIs#sA~nTezl`vwXwyaSLbu
znK@%VWWLeVYjPX^)A&8(*NmSrzSi&sLs<Vw{fO?%I+yl^9bfL4#H0WB{8Y7f=ryYr
zX5s&ycNzo_<qBB7F6}j#ot-7?`1#18oUk)tyd+;CdkvV~2SIxGK~*=5m#{spFA;6M
z#6Tgl*SEO-DBfcHNxenbPw$oR`!oJ{dM=F33CTgSuA`JaCT!9ulYJ7gIes<}Po?-!
z>zed_JMYzCbIWlA@7eXF-jm;<$if&mB^wcht-;u!#rsE><vk>`7bv~NVZCOJdy?-n
zFhf@%DhsfIL#R$+p3d4>WG)p82YGD8kg_&$r<l1UZ!=f{9ZSa}e594PiBnSUBED_u
z2+*~#l)y5k+>=X2m`ujBl#*CjMQ>Btt>&K@g68s*(hTsF=6GQ$o1eRYGLzcHK`1Am
zlrrxhm@P}$N|l%@p^RMhibJThw>&w$;BJ)!<tlicU8^wJ{lq#T_U#e_PoWC4UXaR=
z|BfomxQ2tz(P@%}l?Sqw<U)CYECxM;i8QR|#Xh9K89up^oP7|p1I48QtQ8&WyuG!K
z_HZeiO|As}0l(!othP%FyJ;@#$HtlTGPdH7U9|(53>sLnqo?y$;i(Z}1)ykoSKOl0
z^tYA_ZCj^VUG78P7H`EuS?rR{+}78()15a__lWzfZlyw!$p!3UJLtO!K5BnZ`rq3Q
z`lx%J%2T7Mr8aT358d&-0<HH7+_v8v7dAABuY_n4g*0X<rZFj*@x`$BXxH6*)y^o)
z<;ImFw#23?$TDFIU|-*^58WzcP3R!=1hpCPR%`|A>mz#sk!x7h+1DrR2D~+m?JvHY
z@#f29jc5VymoFCP_w%>iMj|}un?|apgZnRy=rp{vLyK(B8p3|E#F=U!j8`RoGa8^h
zHCb;>e#i#6T^I5azdakz#%Jf^@z$EtKxn5rf;COah?u9t<ey@#NQ~ry!hbOG0Ng<`
zu4MaEQ1B1K*nKyW3*atd`QDIFIGGe(jgu=_y@3T?I!&6{rAKeJ+&+WRI2+JwUU7O`
zQBl?MB4WE$*#6h5MJUQ`(aM`7`})W<E~-YGU6M*kAH;?~>?aiK1Zgmsosy)~_pE@u
zbJ%BkE2)lcBD(D+Op#+@Ik_xmKG_`UyWyY@tB0{#R{7s)et%!zz4_GQY$k;z^QdFk
z4?y;6^ZW1X>mz#y$<|8WP5W_Ch_n6O!3*9kq+BI%+fB*~(z`gxi%!F<OoynK+i5qa
z?`AsI!2bK%<l;`n&u;l_Q&8gm&!?lnuros0INL^PhmvfQn4K!!GgU&`;JcS9@&Dgk
zgd-EZ!*p0Mv<PKnLKD;8RE0~Vma6tR%ckn#u`PKd_25~bfTQHBvev%gYyCRSDE7Qm
z$T4EmrQG~H4ur_~#O=k>O_%gyCk64Mqrw7K5rMjTbeaSSoD#M|43`ImqpYyW2YZ=G
zgGT26yYw&9aAVv7=f6Au-1#==%bX88)6P4bVaGl8=i8pJjauJr`KrZf&YK=Je&6_)
zhE2n=;XcEl;aY=B|M&Vo)4v0cKlAfU4m^_s&*Z?<kpq|KbedaKn=GZn5H4T9H3DqZ
zDFxECOXq>~;<m{{%X2t0M?4<l;2gS<sz=zvBd`&L9LeO%p2<}@vqFbZbgeT5;AZC8
z8J%WO@u5=~kzK$JLL6Np`dCjIep_(7*~RqI*#R<SD_*&5R_JwRQb(~0SlHeshPzVO
z>je+KoR&@wSxr1ouUY4|;VW~K*d+?{QooF6J4cg3gyT!M&SFOmdua|E+>)nDDKe*!
zthBj-(3QwP=)izvw{xZM2CA8(iSgn<mj_^8fQ!Y~C%;uP=;+CvI-xZc?-V<V=-;7R
z=SeDMf!&={SyXSkA3gVuZ8?1Lols_kq?MP-JF^+D9y}Iqzim%F)}X4#TD|=~BtZ8+
zlK^Gl`KhF!>$&J$4?Ybkp!y^1u(Q%Jcyf6>d@u5N-_!7h7gI@8!_|F#%5e2l$?d!E
zL0ZC3Lt2;tOC^Va!O{@SL7!*<#BCH>qdVKnNFKgc;@F!h1k|Q*=?PS%-lrjHq+Os!
zx~Ui2%b?OW6TRYYyw@#H?|Uhu;TQRK+j7ly7vAprr{V3C5%Z_|N+*t^jz*u3SE6TL
zl(%B)C{<nQin^Qm30=7-SxN7nd7A8x^(9m)sDJ*K+Ml|fUotIpHR<8T#F>3lI!!pe
zEDoYiq3x}R$Es!bO;Q&y0xw^<^iE+6b|g1j!gL+3h|fN2LZ`u@Fs)!|Z1(DLoo1M@
zNdl*@R0gp@q>{ZWS6MimPt9W_pN#k4G^W$sMQ#~Sr<ZXuclzvT>dZizoHsYv+8K*p
zFOO|)!BL%Nk-2kV1*epgjqpQfF|waaPmN|5C$gnO*qe8fbd|AV<m!>u8{kdFz1@jI
zrF3?p2o@3I4f?CS$6#V<W@3mBG7yKO?LcrCx#fie?qU+P4U5ywAr{q!XNBY6Fb^G8
zAsV(1;J~y{YxEcs{bZam(eC6ooH9Yqft$(C&XTj=9+)ME)RCVR9QH<lUA;G8+vW~t
z1ISKiAhp}?M0Nr0zDr8Io9F+|{g=w7s2z4qwRZFG`6L2yQ;4*4Ryefk$!$><H&V9F
zUfy<W+W*)w0j;e#!X7B*-~#I0u=eLoNL$}8c(_EHgDK?m8I)tVb~;ty0_PBjo44c*
zg-`n-V^3)pl)UA>{f<b&G}xfGeJiDO)WwAkgAywz+3iMcs^4)7{>~?3T*Sd)s)IdP
z^Po4D|Bvr^7ppXTVndrlCARO(MzN3sCR*nv?r>1V)S$R0S}a*?Ud8?N7U(@J4sPY0
z`h2lnj|;)U2g;dYVg&L=VB+uFY!?<i-p)Ij_q-)~r@ie;Mqk8kb@AO*`xga+*nPj_
z?mMP;+Hl=FyPV5ssEwfQ&Ue`HSO|H=_eE?BWw(}!Wgu->mQKSHj}zE_gygmzDAFOA
zZO*KuH=GKtlG=>A;{l-LjLxUBJM-x{<Wu&I!e<FuCkX6vPJvj<+8=N5q|Pu9DjPY9
z<LN&FanE~fcRPK9Iof5%17JiuQntEMM{6+KYcFDlKjYeFCU73X^zdQqzbB`9mD9qR
zO?NMhj1C^_ErYo=yB#vndb^7~=V7lWz+PY*@P#%Jw>>acFxAPyr?ykR<uNW|A3SNq
zciL6ovWngI_qR?<-R%%lu`FbgRSxo!XhVH+>~04VNzcfKab4_r3G(3yts}>_pP1T8
z_1+I%ZB;gMuJKbkX=dlMY=r&W+s>FG&AxQD?UOp0irE(4?u^ZgJOHzGOx#mA^;5`7
z<*Wtb&*)=1MMB!)OizL#+t2Xa`{_*WkG$ROklbC))@@ay?Z=X~4w_RPZ9R#juW&rm
z;4$RgpmK`VlRXoFKGs1#?}HAc&IW0j=Z?pKkokX)=CH>6SjS@>Z|-<i$GMJ2I`SQ}
z9fvyjj;lH>nxAW)(EP3DGnx---l=(m=0%zpXy!C0@Bs7Us$!GDjk!!di$&KD;AH>a
zfVGN^23Mq)mKT<K1N&ZpA)u4uk>$O7pZ{q0$yqY8l5svC8yQZPi*xvP+Nn%0?|cM*
zFXrYknt}BXy}avTRlL0QAvs#!`k?%8zw4~(PQUXE6PMq98v7|qSf3}HMCDvzl>P2y
zY@Hxi$+n6zS!$Hdx+_dr31{ynxiSt>#a0W<q#<$1)2E(Y!t|h&HXNOFv>T@w7b@lC
z0*=yJD&@?lbeesIY^6}<mhdP}V3|z{=hmM-<tSn=2GPW#`sDnQrGWLS<j?sf+ah**
zoD>gt&sg(Frg+q4=IzTTaR_^H&nO@w;<n=q#o*R495@u|fA49^JDw+~ZcC)UTP;JY
zLB6;XkELwe_0UG~Ciaxc)`NQ<9}+$Pu7@6qQA#Ics*cUPpzq()S)6T#SoS_V!yeW7
z6j}`?Ef+lAq~)4Lt``rz`CoTr=1zlFZN?e)G^(&8VC+10BWF5u26hVpb_55>#x69%
z)PCr1r-LumoX{QxcBO~baLo2&bGBg@b+qTM__Z6x?%1tjI$sw$;+#2m^S`iLDMT%e
zOG)P|wjaCO;R^v5&sNIdj&knlF1#gTJdnfkhlvODny+(=8)|>(uKMI8(O*jGY<+`d
z7hk>m$-FIx4m0^*{y73MA?*R-Vm}DL)YzS@d51bAzQ+#DS*zoF5vLBzgKHN&G?E5q
z>X0-!f(swBwui=gTXRcPrGY#847BYh4U$o@Z3h*KSWkU_Mhswj6ni{HR($eej}>k`
z)%I&Y;<cyc;9p9H9?+wMF~-;C*kN)+Cpq7&H8`t`WRb>%oE|5BE(oV-iWTp_;Y&5*
zOG`%!w!V|Y2D0Z3wmnF0Oga;J_b>m*9|#f!<j)z2f3ioei(wZybhLF7IZmC*S2Dh&
zK4bGD&t6QDINE=YNH}LzrM7KyT6{4Q$psJpR&GV4+dqo5m$My}D1>uW<!@Y(gH`2g
z+hUhaKfj2RW-sED<Q?Hg`oPK#(2VxfM7r^<DJkKDLKi(ewud3YHq){@Eh6}zHAZT3
zS|VBX=%rZ3ZH7C=3sOPLRbhvkO{(j*T7p0-?BeWO@(N-GN-fLIQ$oAU{fO_rZMH~B
z(k?ZBuQn*V=e<u$QVsG2KaeE8>$Yz!iNRE>Io5WpUc60qnNn8CbGKk*>05F1H|2!K
zl+jHwmc2W}w%@EHQ)=UT{_LG7d9h8o!2dg~AW@BEiq%U6(Jk4wEU?pL;e{qq$ocI%
zpTw$W`&M4lXXszV8LQ&cZCl%2xIr2NCWr7#8N!}6E6iu^JR$m2)_^c8vc&h_)-a0Y
zDt=r}dcoa}`K1i(Nggb`+pMwplEm-rrJ0rA<w?(t|L<5>rc^!h?L-Oxc35PltU{Bs
z=YqW(sU0IHPj5d={DNnZUw8puyJde*v2#QB$f&6dI#{0e5HoO>W6lMS^;9QbTeiO2
zRB5Y7o~F53F<I1U_42v~g|^$Be81x=Eyet(HC<xhMNqbI>o!NTeXSD}@%C=p)6y|~
zQr~lF5xPuo!k1x~uNdt1sgRu~aH-_Bn<CzADZ`UqO(A|Lhwz8`^9(yKI8y3ByLC!?
zpGp<uc`{=S|KqFo#8;Op0KKsA!XJi}hlBU_rCFi*ZMO_lDTemzH+NWYCq5=G%iC#9
zno`H{kq+vsAL8SxZ-eZq&oAW`p&aT{DDC>PE%e;`r&pA5;EPz~Cqn3d;nKt1)=%xW
zU`#1l+UvC%kEiV`ITtZ9aN%KcGXMXl9k14K|IGaz_d)J4?)BU`?jbJ4O>+aBpX=fb
z&YwBI<NTuYV>lV$b<Vo;jC0<3*co@;;JnnScl@K{>yF1A?{&P@@f(h+qu{vDG2#d~
zu5-BT|6%`u{qy#Z+23J*y}fB)vd`Mb?6=x)w(qlBZ2xBamhJPl57{2Gz0TIKow40#
z8@JtJ+i%-v{gw5H)~{MWZGDgRcdW0lR;@+rebz(Pkkw~(T7G5ursWHk4_n@Dd9CGz
zmXhUu%ZR1V(q-v1|JwY7`77oRnIAL1&fGAcG2dq%H{W93Z{BD6mFb73ubMt>dXMR~
zrt_w=rg_thsn2xK<S`kIKQVsA_-DpHF}}t4GUFNJ1IFXVA!ER}&uB6Ho8eoA&l}!j
zc&p*%hE>CoVa9O85HwtE;Pn5b{{~Jxc(4BV^yl=?*FT`YTYp%8K!26qqWh`tJG#ep
zAJDy3_exz&m($&=JE9BguGN{fztDbH`$g?XwZEr*jdopI)~2+#YkBQeT3g4@JN~ZY
za~&V(coYSo`r%dwuvkD@84>bxt2htqdSz`y$ltk2&b*>mU4;C$RUCSCmALF8<oB%N
z+^eXxI3XCPR$g$cIQohb2*$ZpoP0$I1mm5neJX)q+_s9NpjraKc-JaUe@e&#vF*zr
zxYa1D6XRBK_7bfV>s$@1bz-(voN6TL#5}7w$Vf>@lu1Z{6^L@HI7x#Rh<2{x1Pvyq
zf>GNl4$P1QqMlWpl%WVj7=dn9Ai}L4WCbFfs|VBq5!>p`ia^A(x}O#ZGXgiU0%30T
zMphu)xr$E;uqg=JR<BnC!k*RZXn_zTa4jnk;#RL=1wx&xSE~g=wpE`Z5b~^c(E>q6
z03SxCD^rkL#rKfuG6;6A;&aGs3WBy(d=6PEgP>;>-$GW(AixOVo5-|4fLp~Ek!gWI
z=PJI3%nAf-tN1XoBoOFY#aEG)+A1tWVi)UhtIuL}cy9F)R)_Cgb*puF+iItx!+Ta;
zbV7thL9GQ(+$zTkz^<LF0PGqcqGb~TyS6I=uxor!R?evaYuEV3ER|CM*fl;iOXXAm
zc8!nDG6DhEH9kPw%Beuyvx>uK6#>Dn<rLr~T3P@GjpJx(0T?t6q-6zQ&^Vk{5`aNt
z#h4<%8Z=gp(E?GfiuGf(K(w=pg=4Hh)K<mfF-aimsbcAvBET4Q6>G?7fe2T{N-|m?
z(pklNGFBjBt71i&BoOgbv7Ss3U<|s7#bvZWn5$xW87&a*tYUE)D-gC-vA9eU2z#nn
zS*8du23^IXGFl+SRmtKqrF95|I;&V+#tMXNRV*=+1VWxFR+%XRj6qki=8P5ya@CWp
zK(Mp=fLb7EtK#quNg(K{;<ye)fHCMQPV1lr0$ddbb<imYbXLh>9CZ5@2-vDPjYAR$
zc&g;=4XODF&?^hMDh}VE1$eHSVg>ll>hshByses41b9#Nep-OB<m!E_fS;>Amlg1L
zR_|2{_-)mD6al}ddV&(*8B4C-%?R*uu6h?Ez{fkQ$5jG++*X~D1^Bq9I!y~OmRy};
z1!7!vk`;(`R_{~`#B9|GMIh#>j?)5+C0EB-0a)@VD*#I#Q47G5k0}CCSM?4o?UV|c
zCzi}rhuMf>!AIGMVZle#5yOHHD-pwj6ZD(27CgiXz=8)^0a)-MwE!#_*w(6^JS-T<
zCRb0MwP3ItRXurFFvyLn|2!-h^v2YG9u|D7A`o&_fow|F5DVt2U^Y5pST2Z-ju@5;
zYGWgY<$}|sHxIh1U^FFSV!2!ukVZ!giv^<55yN7EX>7!>Sn!z?F)S8rreq0gv4AvM
z02bTJ3czB4X{-P&7JMcNz+%B>iU4b|fHYbF77Ik9Qvizvrm+IBSn!!7;NMpTo5_or
zX@hlE!D!TK=D4#8K%<s3$6Zx08naG1ZmojNTI;0a`>Mb)Id0lkomJo&6?e>81)EWE
z$6Qt5854KRS_PK1;*RaBg2?2!X)|?JuVmtmI;+4kDsGq{$c%|QYOR9ET5(68T?LHE
zi=c(JmgOpE6>LVme#BV?m{AfDR~2l=NJOkvz*tKnvabpblV6{<Rc94EM#UX=RsmyF
z++kN0JjTQwwpPJmt+>Pcsz5L~ZrV(pRiGFZcgR@<hf#6E1c72q+#&Q^<+wxps-Q19
zZn}+iRzYD@+(Bm*2u8&XD+GlxaR;qc&{yldgU_x4yyR>bnpbtUgTp9^fU^n+qa*^P
z|No(mS8BNLaDT&njC&{d2Cl}faI@S5cN=#l=ft=F{=xYr=lh*+cfQ8C>0EZ+;~a6u
z(EERu<L8bi9Dn2ZgyWAKuXZ#XD~^m~(h+s+cU<bw*?(mJJNxJCAFw}af3^J)d(nQc
zeb^qgUuk#Reqs9u+m~$bx4qr=8r!CA**0ZM*mzr)&0+nq_1o6ZSwCd`1M5qyYeLWe
znALB+M(FwfqvbCx9}#-~bxXnWJfY`*lf_~FPod}kDf1tge@p23&zYyp2{Ui*GCNE^
zHhtUlIn#$se_(2u9yTqQj+=%|`%PDvOvZmRe#`i2<NJ)iYkawJ)mSv9jHAX|jQfoy
z!_N)h!8Z;*V)$Lds|__n$?!Zw!Vtwthn@QW)PGz5CH+VBkLiC)zouW-r}X3ce*HE2
zXX!P%AL_oQ`-tw3bZ^j|*FB_ro^Dcio9>|Qa_xU=f294o_RqBM)&7?D#oC9p4`}b!
z_G^2!S7<FAKkfKh$7eg<*YQ?l{<a@(jR3FG`;W%BH2^Q=siLvYHQ+AesiHC4+QYJ^
zipD%^;9S`iMro7h)(G%Y0#R-az)K56JJ*1_tU%PZ2Iy_M!f4d92F_Ik7{*>Bz)J~4
zxHSMTEfDEk1Mac{5!)J|R}zSL*1)-n0B!Z$8UbEPAk3`+cxi!f=NfRA6$snb0KJkx
z*s})CRRn0$=hg`DQUW1v4ZuqaggV!NyR1OSwg%{x1VWxQaIPXi+dsEPfR_>oa%%uy
zS|HfD2Ha%@g0?k4uOtxktbubC0fw>H2=Gz@0d5VzOA7=#*MPgMK)|*J=#>Nlo;7f;
zBEYoRYtLl`cy0~AOAGLwYrtJrfVZsydL;qgvj)yp1eg|kjQ}r|0zbC~;H3rpoom2d
zR={st1N2G)e$N^>R~CrSO*XeifL9TS#JM#9FC`F(cdh|<8G%ULwg%{J2}I(aHE^yX
zK)2i68UbEP0G15kr3GNgz+F}VmJH~X1YpVFT}6PkWCFgF04y2cOAEk~fxWB%EE(`C
z2}HZrz`OFuNTf{*&aDytrF3A>;9pt?1`YaUbzsn7U`Z$9S_AgVTp1w-&8-pcr6PtQ
zgL~<SVaT9fHewhu*jI`eh79aga)>o#!oQRN3>o}O3&4;;zpMZZ84N55z>tBziU4cK
zgo7yo7&17R7Jwmxf>{9=GFVs=2zIRjf0ZI=)0%T@1cxad*fVgL)`2|(hFKlhGmu!)
zfjxtQm4vYNOmLVIfIS0;X#v<XV3-wvJp+j)0p7I+3|7jR*fX~V5T+xB9fO4Fh+)S7
zVK!peF?d*t7<LQ>mft+g+A(OD5(vYNfy0zQ7<LRAW(2~pV?c3BAPhSO2rB}t9RrDJ
z0oXB^m==H?1BqDy*fGdh5`Y~8gB1bRjse890PGk<Obft{0mQ5T>=;}u37|y=3o8O_
ziwr8J1z^CyVp;$O3@T;?V8DQ5NdPS}fLIY=TV$XyEdWCX8`A<XWS}uC07C{LO9C)t
zP_ZJw8Z!8p7JwlGkZA!JGWeJkfFT2uB>@;Rm{<{D4H<My3&4;&SOFNaMlFD0Y~Y$C
z5bRn7s>y~NZfD4=KsQ<kquBsAIw2U%2E4He!Du$9P0|T?RzYk^LKs6{1-j7!7{&&;
z(E=F82E4HX7{*>!1Tc&ZVp9Z|hItj}MhjpV8{kF@U>F<l#tL8<8`LJH0K?cIHd!FV
z81yR8jS>i97#rY534}0=4R~V&LKwydwY3C7an~w{O?E{gV$j?wkd2NQ!`A>dI${i8
z1KQY#F?<bLlOo3OHAqc)bH<QYfo!w@=A!^?v;gL#0Bx)Q=A%Gsk^ttTKx&ErW5}yO
zHd+AlQ2;ht0P|6RHdX-hQJ^(R0P|5GHAR3i<W(RWEr9tb02?iU`6xgeD}ebZ(3&KG
z`6!T@BET5(>I^G@`6vJzEr9tbKpQK7`6$quB!KxSkeVXE81gERjZOjPqX2BQ0Oq3r
zZL9zc8MGz|z>q;|vLT1s8ZyX@)`1~|+h`paGT4pPfguChBpnzsfK5pVYsersS^$O&
zZleWY$Y3{C0EP@&lLTPMAT>pRHe}NOe_zK2-T!}tD{}X8!(6m&|9{pw?R<{2$9bi*
z!||_<Z#e$K@qWh}9WQk}-;sCR<2d4oJFa(J;^?q{*ZyVu$L;U3ztO&KKW$Ij@3h};
zzs`P{U2FRn+uzwfW_!2oO|}==9<e=Od#>%MEn>UQX0iU#`aSDkTR&!ftMxan8`g?-
z)_TMmw_b0(#M)u`uI0=4F5$Z@Z?vpiPFvEJJ1w_cuCrWb(VG9o{CDP$ncr=GllevF
zN6fS4Y4dZ;J?1OT9T)-ly6JJ#pJ49)oawYFW4hDSW9l+ljXyPh8~y+H8sBVuiShZy
zS>u%PHsb-K2lM{l#k~KA48L#KGMqJJ40jrCGhAc1ME@W9C-h&|e?b3s{j2rs`VxBn
z&%vy}M{m%5U-wnrCv@*Z&wou<(Is^wy14Etom2aB%=v#o`(f>4+Sh8gw9DEP+B>vi
z?KN7i<6k?z-SL;0^M4yMUH<W{15uC2L)^SzjqFg4YaPsbqrzr9A9k$+T5nY5d=TVb
z2eTfar%VuNUk~Ht1943N{`9T`SL2EpZJDlhfGeXCa;<}08I_QG9pI``3E9`dud+(W
zyAD{TRA}>btpi&bm7r@K+{&l~-Rr<sl}gaQ4tkYUf}QIi*8NIah>g0|!K_T|0oOX9
zm5DvzUI(+PVh`BYfv$4w0q;7nl}ZC`nXYvJETh7^)<Lk03h!PAz^YVu`#LyQR^h$t
zU{^|oHc!_&D3($2yVilRjEdjA4vJN&`0eX}Sy{#JT?fD_Dt@}Lb*%$sX%&CmwGNi0
zRs3=HI#8BX@yG4!AX-VqANQ?;VwH;Q7Z6%qkuOz=#a!#)T1G79UI*5y#A5b!(5);M
z^R9zvsU*>@uxlM`%Ool4S_j-RDpB`3*jA+ywXXwlWtFIR9au}L&`q&x9e~TIL|p42
zTt+40UI*Z+R3i3uaIUNp@vVbxsf=su0RX#<7(4)Iml1;p0PL#7-~qtAvRK%+4$h^-
z1P`DtC4es@21fw$WyC`68o*a27P8mCzp_}!TLbJ;`Nued8nBm93A$?FUPdM8t^s>h
zDnWY<^ed|by)_Uor6M%etrZKd8rYXn3Ak#2Uq&V1u7Q13Dgk>92rR1vd^KP%m2rYY
zP-R>V9L$LEt{Om?5#!x8aIi{@x7UEfvKa5J0fDI`F@B*27-m%bt{P~VQSrNLfMJ!2
z-(CX~%PM|P4LmHfL7a9AT#bOS(&WVBTn%7M!ACsaSpya`@DY#OYJlSwe8l6P8hBU{
zU^>+`0>+d;jH>~RX@OX04Oq+y#B4Rdu_O@l)WE}v0PO|18UbTUAj;JM#<W1Rvj!|?
z1){bZ;8+rfdTQWdMSykyT#bM+B@p3i0ApGp(pdu*vjP!Y4R9<8L_9U{up+>)c#VKD
zB@pIn0ApGp+*tz_vjSmT4R9<8ggrIzup&UW_*{*EF(nY<Y5-$eAk<j{7PA5&TMck5
z34}Z~fUqJ!+c;MvL`(?;xf+O=76^9Mz{9LS&{hK#O9DYp4Ir!t(B{q62oX~P0j>rj
zrUe3>HSjPi5U|xi#gah4QyZWK=%${lJ%<(Gx!Ucl0N+`=O)bFNYW<1;yuhu*WLt+|
z#fdd@wOiPT{ame&jo9B=0~)e#?zh#zg3_DAf`Nf@*2Gu~1`bkL6N3eV1*xow!GeK<
zj6e()3=C`u#9+Z7Kt+JHV2~g!01E~N(gLtxkRU4n3kCs70<d7fpCZ6oFd&c?fCYm9
zX#rR;fj}C1W3XUApd<hb2LCAntObJuX#rR;AdnV-1%m@w0a!5jPZEf@Y6ShH!i^CN
z=4wDcI$~HZxQ~t)mJ9S_BZlPy`J{+pxu8Ae%~{I@_0a;bTp%AU0LumSu>!DM(4Hg!
z%LV8u0<7f%_-FxGE@+PyfaL=CSOHir2u~6~gHGU1&KhF5Tn%tXM+}Pv+0hZhVgYw-
z#IRUEofI)F7CfiCIcu@tI$8i03#g+7V6osjRsa?Yo|6Q4PYo!i2+-{>R|C?~0<c{0
z94!FL1=6tsuv{>lB;fC=0pH{ShNxh<EKP7V&>W=`g#iQQD4i$_7&OP|L}9?dx0X&6
z1`KkO6B4BjnDqbO-La+Ne#Cu^`waIU?l-w6=Ks@}{||B3b1vtvo&V_ktn<UpN1d;7
z)|@Hlq_f|7vvZ&0myRD`_W$FKcRF6-*l?V3-0wJs+5el+_t)6}$^I4l<Mwykf7|{d
zd)c0`k7MQke!Ii=AGYsf?*C)9-?P2iwq{$xy8i)Nz;>0*YW=D8Z>@iB{S)h(G55c0
zowMF)z0G>S%2_p*C(!Tzgypv_FS9(~a?*0Q<yK3##bYs;e{BAe`BUb1ncrYOXU>`L
z!K{A(v;I2MPfXu1{kiGArq`Q(1MB_gOjD+)=_b=9CXMl*jGs4t)cAJeZyGm^Wn;!T
zZoCz9{zk)34S#R=OTz~YZ#2Bb@US6gIBw`O957sF(CPn0{}=iX>EEV*C1(8RvDSZ3
z@7G_Y`-Sca-IsJ9(><npxo%yzq`Oadhc2SKQRl{d{|~gE(Y{an7VS&5FVLp7(^%<$
zQ0wjZb;l1ozS8l@jz7Zrid%B0pZSM<1F$DiSvcU`0N*L>7p5z>YlDEE(%$i5-n9YH
zquDRayElM&Ec=Cd`vzc7R^h!H06a>CuHmi?pdO>*cWr?67!|*J1E{A`@!K~*e6ot)
zy8+5mRG492*9LfxR>7F<27r%N3B}zT;5}9)6t`~x`y`c6+_wSLQ_x%(>s6h^=-L4L
zF=8>-2H=koi@7(zek!q;eFF$6i^V!OfPKoaLx{9kt_^@66MNLP0rF#FkGeMieyZ4`
z_6_i#9DCHe0p_DJjBc)68=yZ%CF0ru{xK>M_Xg-sr4q4k00L!|h;IYnM`c*M9_I!~
zkP!>JHh_YRSlGP*5>$zW?Hd3>SuE_`00dG=qT4ao25^v33Ar}FgN#bZy#X9lsf6qs
zph8(C<l6uVQb`gTGuENHHh_kVSkScrHe|$t?hT-!N-SvK03pg^LGK2rkV+Dbq^=F{
zA)^v-Z2%A%m4JH#e5g_h*f)TQvI-ml5Rp=09RXmGQGp`>Eix)_1b{`A3LF8LQC8u7
z8{kAL;{->b&NzT0BL;r}a%9Bd4*-rTG57=Uqb%m{+yFBw#v|-Xa&3Sb>DYtt1HeW)
z_8|NKsF9652tNRLlwuFYy&C{VCBuSrW9QlcIx;G70ANQ(1r7k{s8WFg071$sG4BSb
zky4?N)wKbBWK`e?0FaCd90B-Ir2<C)jFeU22!N233hM{}lZ*-+0ces@fg=D+s#M?z
zz?8B|#Jd5Gq*Uncr)vX5$*8~s04W(2cmNQkN(CMOU@5DFeH(yDrHTdHjX7<AE*UX6
z0^lVh21fw8REfb605WB<kaq)sNhOJ<TGs|plTm>O0BbTT@Blzfl?prnh*MU92LNSK
zDy#<pZ!#+I002%#1s(vrsZxOl0CvhM0pA8tlgc>31E_5i?8%715dc0JF*pLSr%DWt
z00=6Jfe65xRFYUC0C_Sh@BlzhMg<-K<f&4D2LOP|Dj17?0j<L9UvjNKpH&H9Ecy{v
zC4jN$ht(<pj72}Bs08BP^#>Uh#uKccRjFVQ`ix2igV3k9sbCO#g;K#F^fIHuc!Kqc
zN(F<^Wt9pBp-bCTFbI8$Qo$hf5~IR+g7u<G1%uF_NxEDD7=#8<vgH!MAT&@?DwjaS
zyAF(0N<YAOf_3mDUHSoxK7%G16^uTEC{-#LeFjR(Dwux)Mp7ya3#@}D85ImWgC-dj
z%s+uBRVtW&0!qp%q0V(+q|(X+hzoG7gCm*PG4BM5WMap>6G&1OJLa9hj&kgncLFz3
zu@lpGtpgmH*fH+}Y-D1`yc5t-6+7mgz>ae4n0Ep<QaQvl`s)BlMg{Xuz(+;}^G-lW
zl?vvaz>cyC=AFQelnP_(>i|eb1@lh8M@9wnPC!VN3g(>vjk1d0w+>)b+?Tk+N#(xQ
z0g$v950eKz(qcSJ9tg>b@i2L?qa?<|<iU+fl6cnS0g#LeOdj~isKDfbkSZ0JJfKll
zfyo0HDHYb_L5_?HOdj0GsKDgGjw%(HJfKllfyo0HDHYb_L5_?HOdj0GsKDgGjw%(H
zJfKlliID#Pdpg!N+!NfFxleF!L;ruBD{)C~5dHry&hGp<R{wv>`7Y-hoadZN=>Lxh
zd;hKI|9{u<1;?K{-i-eL3muD?`@hZ6>$u!uvj4>Xf3Wla1NOJsUul2Pe$sy2K4|w-
zz5jRE-e_xL*MHVFZ0oaKZ*yD!)A}vz7p))0%Kz6`AF&p!C#;99L2H-QW%;G$A1r@u
zd9USB%PTCamZD|KGGytsTxqeG{|U4HpE1A3{5$4N?D$WcC(Qlk%gr{^zni{=RsU}{
z{g$b2S}~<fM@%u(wI-MG*T(M~ziRx1@m<C@7#}t+8t*nHu-pGKtoi@3;TwiOH#}x|
zli?g@{pSpmhCxG*;R=IU{{#Kk^`F+iTmReo4gG2TEav@h)%*0Fx?f@5|4X{}>3$!3
z{ns!8Fs)1I{FwK*YJaHxhW2sopJ?BVS^u-zjP_3LZJ71Hq~kw2p6K{8X8qsZ@oHqY
z`p2~e7NpBA7ISZb1lh8S#q3+)L8<IwG4B=-P^lp?rXFq)7NiCVVo}!?SddYPy0<`r
zDwU{x3p^;RM7>);KuU$Fhg*aNX_bg;3oOW}MBG~-L6u6xz6BnXRU+OkupgzuG(B4c
z0%?`7YYPy_sD#~HKtPpB*uDi2lvTpsEwCS@!ZbZw1OjQ5kZTJN$f$(eTR=dSO31zi
z5R_Fy-Yu{nrNYqX7J)!oCFt4$1Trc?_ZARPr4qDn0R&~0pmz(<N2xIMxkc!YRtdPa
zK!1!%z`X_bQ>g^(TOdGLCE(ox^ie8IQ?y0sk5=JbTcAHig?Dd({ZuNveG>#ItMJ}U
zKp&;TG)0?){%94yYZLUxsQBHRU_X_L-@XX~lvVuRO+cTbB96C8bHtm3{wS4b+_ee%
zqgA4D_a@knRf)#!n;<|*1;eqMfIbBcgwa;lCZRq$_LyrE)W^ggb8mwARI$hGn;<_q
z_Lz4Qut%kVvH49xeY8r{wF&BDRHE)pFrP{#YTpF;$tqFrCSZ?JVQhYrP#>)laczS7
z7?p^76U?VliP$$mezHo$w+Yx&&>-4w1ZtDOA1xMkZ36xnv9Nm+=%*43+cyD#vRJrt
z6YNJ73o(7yCV@XX_K<56@W;d+a&H3tRI!Kbn*cyL_K<fI>_=r7WAd8>0%?_?YZDO2
zs07`cKtPpB(7p)}lvRShO|T!8VS>r4SZb57AT1VfZGr_Ev4DFMB&ZS#*f+t0vRJ^k
z2?V6X+Vwj(2@=v`ylWFk$cXXoO#q=v3=RNTD2u@X00F7|V;ultL0Sb404&I;zyW{+
zRVr`*;6Ygh4gd(Ks4zQ$T$_XiDU}Eu09cS#iNFDX1X+~`8~}JwQi;U9n?OKHg@Mpb
z!h*C4906F6QGp`>393}!2*87~3LF6tkWyhC0bxN}1&#nL$f&>(fCN=4a0GEmCEB?e
zqpe2R806ZFs$z!&h^S(R0|;-69S$Hw#UAl)2AMQ4js9jpr2@<6RVuK2|27p^elMjG
z_HOntDomrl*{xE62RNuwfd@FSO$8p{W=aJfU_Yb6dVrf$D)0a|s#M?sZrG**4{$xD
z671XrDJotpBJ?{qfr?CN!{h;qOlia90gI~AhRK5x<vInE2O%mZA8BjyAVx+ECJ$a@
z#9;DZMwJ*$9<V5j!Q=soR0U>D9>mC~z~sS;j0#L1%&1a<$paQ;6@TX@KvBssVbhRn
z6QoGT9)_ud6Y1E)Fm<pZ8+#b04oH+@55v>}h)Np5tf_+(85Nj1IFV6-se=_&Dlm0G
zqO1Z_2Ov@^tf_+(85Nj1IFV6-se=_&Dlm0GqO5{8AAm@yux&m_kx_xkgA*AQm^@ff
zr2>-&B+4o<c>p4%!kRotkx{{5GdPh^!C*63QKf>xW<a8>g2840qEeB=g2}5I$_)S`
zBZk3d;36Z2!Db+%N(_U|U`1IBgU#SXDoKpxZvYq>6$~~57a0`{HUk+|Di~}AGs-F$
zYz8k<Dh%##02~<=3^oHB85ImR107W=!v6pFbUdQr{)ziM_fhWc=>KnWC%NZxN6`Pj
z8mIsLyYriv|9?OF|1Wkv<Xmvhp#Og}&i>On{u%xMk2~Jsc%7r}Sa!@g?!*Yd0SAZq
z|0l5a{}br{|0dS{m+VQ*{&(9wc7yH5nEn5h?OnDv*v?`0KV=)S#celW_WzgG?^?fL
z{Zq{Tzry-L>!S4@%>MUUFSnX3Kf&z(XDokgd6VTgaN=LuGG@8Oa+Af56aW6f{MY7>
znt#{)D)XwjXnro%{PS4zZ$bb6tENB0d4IoSda-HIbiZlX6hZ&rWc(TS{D02)LF1c@
zFEu`b)Bf(lj{k!=?N4v`k>Rt34;vmeyb3%1Q|SHo8*Vo2)Bh5^|G&|HT>nn}E71Et
zrN3W)Oy7&%zfJcu-FI}KLGS-9x|ix+pi86oe>-;jd$qqt@Bb^>Pip^2`zrMQ%i8B@
zM{&;IHCji<FFL;0@n^z0f3NR2kIa^S9CeW4)y3jsvXo8XgMyAau<+`W3(JLh@)g32
zwGJk{;$&($ldEL7I#}@f9KIx&oGYc~@#R5#9XQx^GLv1wH+1L9-a61vt|0+o#8djt
zqN`3AP$2?bb=ARuR1HCpyAA?mY6t@Db#P#-9^y}L9n43mF!iub;Ez@bxaxpEMkU~`
z1N~Gg0ec+)D60g#bub^L!gM?91pa6h-c<+uF)F;f4)jy0@b)?YP*&l+bub^L!Zbm3
z0)MoM-&F_vF)Ds{9q6Z0@!RVFKv~7_t%La#73Pd5SDnBgrGlZ)I^d61!O&+N=*OyH
z=(7$0lvFVESqJk`Doj&UC-6tB#9Vd2AEOd;*MWX2m6*K_0F+f?-a6QiQem2+I)Ol1
zCF-gJ0vVO4yAA|YsYLB{fS{}r_13|DlnT=n)d>XBDiK#55Xh)R+;t$JN+n{i0|aH2
zh_?>*qg0rts7@e|RtdZ6fIvni?5+a=RVrb79Uv&Hgnf0epWGA$#6zG|O;Me&AT1Vh
z)xm;{Sjb%m397_G_Bwb_77O|6KtW1OXo}Qg1Py61cmkjyBL+_ZFjR@b695loF?a%?
zAeDctCm>8ntH2Y02^kf50uZ4}1)cz0D67B|00k)())NpWq*dSvz=VtnJOPMMr2<a?
zE|gW^34nx@3hN078`3K91Yko(1)cz8s8WF^03XUKeqS9(s1%R52S;5z1Q97QY{jVq
z5os}O#i;`jSut$IsRI)wF+Usv$WTd=xD`hl?Wz+*q*dS$fQXC=90CAQr2>ZlOq5mN
z5I}~M3hNLEBGM{w2tY(e1r7m#s8WGL04B;Ra0nnnN`-L<TLckl6^uax5g8SXK?4v~
zDj0(XCdw)pg9Z{(DvU$eB5X*jU<?{;$f#fp8f2(a!5B37P*%YhG?0)|VY;JRgbisG
zj6s7985N8{gA7$F7=s2M$|@Lx1`<*#43usWHl$TB1`Rf3R4@iz*rtLp=tW8eW6*g<
zg>eB}CsisKgML7zf-&gaHWiFPFHkBNgPvzp7#FZLr&7TfbXKK;G3d-T72dv;rc`+E
z)-0pKxPYycO2zNmdY($f@7_voQ}Nrk?x$4z-mUv66`t8|<Jx*Iqk^lht$P_21i7~W
zjZEny(7pw7Y?VI#^lkwh<<jTl3=C|6BdOBIRo50kk}7=!xwin5DizE>fg)v<m~RUN
zDZ4X1F4(@xoo#_A88J*lfhQR;OhbVwRbrTi0!+$cn1%vKQb}T60Em)NfeQdnGAeKZ
zU`mw=TmWEFR)GruNKz`S3jk3vDsTbdNk#=O08FV;feQdk$|~W`Er6slC=nONqPIYj
zOzbdya3m8uOdl+%iXEm8h?HZ8=>s6CG_a-*l4Mk1`rt@L1*Q*{RH?x90g<u_OdkMA
zsj#LGl4Mk1`rt@L1*Q*{RH?x90g<u_OdkMAsj#LGl4Mk1`rt@L1*Q*{RH?x90g<u_
zOdkMAsj#LGl4Mk1`rt@L1*Q*{RH?x90g<u_OdkNLs4yFKTw5SXS|tY42S?H>F_=DB
zl2wVp^g)l3N(`nCa->vP(+5H_Dlszu|E7*KS^xh{i~xKJI{@Csy@D%a2f%S|jO*vR
zxo2~F=TET<;IFX`;E$bea{fkZ9N>_%7pDMN9RKe4mg94d4>}$dRsx*HHvsN%-0tXh
zcpZBCPwn5vIe_oC|E~Qd_7`F;!2R|+>@oYbcDL=<I0x_x_y)k+Y%jOfZD(y6+dcRS
zKoH{ro%jmCH?5zr{=Rj~nzv3`qt;6;|B7*dcUxX#d4c5t%Y-F@6#yOPZ<s$|extc&
zUNDcM?|+%;7g+iKxal#|D@^OAQ<(Xm#LE9GjlVE{!}xLIJB_b2K4g3z=KOCqa)w{v
zl)uLf@4)H)XASpbw*N+hUH>EfU*lYVa<<=sepJuvFV+2A_cyxt>&VXj1>LAFpxdYY
zmG=K=KcRh__Pn;FJ+2LET^&Ecy8iccytd;7$ikg|ybT&FcpM1BAC>y$-UhHjF0BBF
zP`T!5fG?C?8}ub#1Dv6F-e8zK#(G{)1Jofujip>l#NGx?AUsdMkgov(QDTlnx5w;j
zfJl^Ea4yC+ac={JA}5Ovg(!7T1E8Y37%lE?(9pu8uSCBzphbx?LSOSVKreEXp$PLB
zD295BzUFBFW|YTb)MK6oz(&3lV8y^S@}*dic?x_ZU&5vh<@G%caE^Ql8wQk1-Uet#
zc|{CS)7NP9;c;LZeGTZNJcqde<yuz*45aKV5|YN&4{rlVq&$r^n99@M2FQrIMkmDE
zpfQOLuo((WQW8l&=4k+z<V!(6rRHe>o8(J8oi&~Y;7PuudPf?h0z4g~w*io%-k;7j
zPXk0HN2#irAS?M&n10IJ0AEotvULTpB|jEm-yf_cUkcGNdKzFZ`4UE`mF)L4z+UpD
z5L?4QVDcp_ou{7yjmejI`YCq<6m}q2I@KHGgW>MNO8Ioo?{0v@4&;^=bKQ&O`Gr&=
zlh2ks4Um`|Ntlkr(*TdjmjY}KfX(DfLAoM(8bCAo62`vh7Y3rqmqK&_dKy4A`BIS1
zQda}Oc4PT$xsqMXbT4D@GvjFh+LXK58VP1oF3|<h)d0K6CW7_ocr(^SJPn|n@-Ukj
z06OIoUDKTnz}>aE*<>M~ET=F`Yioe)u0p_KI#sT8HUM?|bF<y);^I>Ga$&an^eIOJ
zRCl!$cKVd30ics(=jqt@H2`<=al&-QxEnyb15(C3P+Tq*Qh84Ua3{wUp!3+<0OV0s
znk_Z3p8OcoKzJJr_c8U%(*XA=kI@C;ZGit2HJswER0MAWAgEkpysftZ9;B|(h2U!d
z4wZ&TOdVT<T@5gzT*&x9K$}7aGAi#(SL=NZprf4Ebk*J006)rC=y%%J07}YN=v2BJ
z0LcRn%w__;g_XrDU*MMl-TN9qN%?l#33wYIN+sbq5=hA~UjtyNB-}4l12*BF24GW8
zR+z3RT@A3NoF|yG+?FR@4WOrThmdl0^dM0sdODr^8sJemNp#)yHW)NzJiV_0G*yx$
zdQnz$U*kF|V!EKbjcb{_qOW-x*HCZDG!yQ|)hLndnM$a;R9=BW7FMz)cf&^)lV2z%
zYoiMjF|e(CaX#a1JeyIYD~7pol}@uScV>PzYieAn(_ESh`LpiE6^JsI&UP<Vmb(4;
z>5By%jmu&4i}^F*Y%*1vE1Mf$JSqI`Zg_A%`DZe{m`Mr`WZaE?+XB<>#%0?AQ|`v4
z+XCb6#<R8shTV-zwgrZq4L3O=oTz8Zr{TZcjm~X%1-OQbY(pk@EvzJ07SgHC1_#F`
zgv^~zR!XUKwq$KMk#AxcUe+PSgBwcOGG?-}&W2r9TgetGWp~3S-6bcUcQ>q3;8JQH
z8J5o%5uZg0T*#*Kl?9SfoeeYIf*4qLCY#SzvT(1ih6zoE5GJT1$l5UC#e^V|Km#I5
zFQiKI*-~;bRe(gPv!SQ@=*uCp1($2+kmv`?r&CMa<%LqNaMIk+qSQ{7E2Sk@qXR0r
zrIkoBmC2M)o96a4G*peH9jvkb0-ffP#eBwHe?GKV=5obuw9j*y?sPtza@QY0U@E<o
zOI8-LrNvY}xwPo2KTP6BBOVKPFQs$Yg(X)VJqs}?BnP2GAqEBIAoL@|pnx2N{(}${
zQSL&2K@3vvLO($a;^ha?JrINZauB)$LQq(V3-~VvDRF`N#ULdv(7qU?#0AI~f<iGl
zda%716p@3#^kR^d6Sg`~{;HFeg;KFXG8OcGAe%0oU8>BLyGd|1WvzqTuQ*8xFT-2w
zAobQC{(W_@x$Lp%Hqu@Pns=Q}RniL?SiYkU8owIIF;~i-f@L`CAn<FmnN+%ash9^o
z8S239&c%$i4!FJ|RY@hwb90V5X!`2P(qa-%;;F7W2wL{80eAzxJ3U`2E-&E*)TH9s
z&N?`H|7`wbdOo?dT&N^xb46<%0DVPk{N7myGGBW#SEyv?OS#I~jHwP#zVu{y5$^~t
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

literal 0
HcmV?d00001