From ecc24bfd71448790f5eb31ee2b7118b9a122cb9d Mon Sep 17 00:00:00 2001
From: Bimal Gaudel <bimalgaudel@gmail.com>
Date: Mon, 11 May 2026 12:19:34 -0400
Subject: [PATCH 1/6] feature: log per-op left/right/result memory and cache
 high-water mark

---
 SeQuant/core/eval/cache_manager.hpp | 13 ++++-
 SeQuant/core/eval/eval.hpp          | 73 +++++++++++++++++++++++++++--
 2 files changed, 79 insertions(+), 7 deletions(-)

diff --git a/SeQuant/core/eval/cache_manager.hpp b/SeQuant/core/eval/cache_manager.hpp
index 6ce8f54b2e..f1185dce36 100644
--- a/SeQuant/core/eval/cache_manager.hpp
+++ b/SeQuant/core/eval/cache_manager.hpp
@@ -83,8 +83,9 @@ class CacheManager {
   std::unordered_map<TreeNode, entry, hasher_type, comparator_type> cache_map_;
 
  public:
-  template <typename Iterable1>
-  explicit CacheManager(Iterable1&& decaying) noexcept {
+  template <typename Iterable>
+    requires(!std::same_as<std::remove_cvref_t<Iterable>, CacheManager>)
+  explicit CacheManager(Iterable&& decaying) noexcept {
     for (auto&& [k, c] : decaying) cache_map_.try_emplace(k, entry{c});
   }
 
@@ -145,6 +146,14 @@ class CacheManager {
     return iter == end ? -1 : static_cast<int>(iter->second.max_life_count());
   }
 
+  /// \return true iff the key is registered for caching and currently holds
+  ///         stored data (i.e. has been stored and not yet drained by its
+  ///         final access).
+  [[nodiscard]] bool alive(key_type const& key) const noexcept {
+    auto iter = cache_map_.find(key);
+    return iter != cache_map_.end() && iter->second.alive();
+  }
+
   ///
   /// \return The number of entries with life_count greater than zero.
   ///
diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index db7e02020f..07c3b5c4c7 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -110,6 +110,21 @@ struct EvalStat {
   Bytes memory;
 };
 
+struct EvalDetailBinary {
+  EvalMode mode;
+  Duration time;
+  Bytes mem_left;
+  Bytes mem_right;
+  Bytes mem_result;
+  Bytes mem_hwmark;
+};
+
+struct CacheDetail {
+  CacheMode mode;
+  size_t key;
+  Bytes memory;
+};
+
 struct CacheStat {
   CacheMode mode;
   size_t key;
@@ -133,6 +148,27 @@ auto eval(EvalStat const& stat, Args const&... args) {
       args...);
 }
 
+template <typename... Args>
+auto eval(EvalDetailBinary const& stat, Args const&... args) {
+  log("EvalDetail",                                          //
+      to_string(stat.mode),                                  //
+      stat.time,                                             //
+      std::format("left={}", to_string(stat.mem_left)),      //
+      std::format("right={}", to_string(stat.mem_right)),    //
+      std::format("result={}", to_string(stat.mem_result)),  //
+      std::format("hw={}", to_string(stat.mem_hwmark)),      //
+      args...);
+}
+
+template <typename... Args>
+auto cache(CacheDetail const& stat, Args const&... args) {
+  log("CacheDetail",           //
+      to_string(stat.mode),    //
+      stat.key,                //
+      to_string(stat.memory),  //
+      args...);
+}
+
 template <typename... Args>
 auto cache(CacheStat const& stat, Args const&... args) {
   log("Cache",                                              //
@@ -278,14 +314,28 @@ ResultPtr evaluate(Node const& node,  //
     };
 
     if (auto ptr = cache.access(node); ptr) {
-      if constexpr (trace(EvalTrace)) log::cache(node, cache);
+      if constexpr (trace(EvalTrace)) {
+        log::cache(node, cache);
+        log::cache(log::CacheDetail{.mode = cache.life(node) == 0
+                                                ? log::CacheMode::Release
+                                                : log::CacheMode::Access,
+                                    .key = node->hash_value(),
+                                    .memory = log::bytes(ptr)},
+                   log::label(node));
+      }
 
       return mult_by_phase(ptr);
     } else if (cache.exists(node)) {
       auto ptr = cache.store(
           node, mult_by_phase(evaluate<EvalTrace, CacheCheck::Unchecked>(
                     node, le, cache)));
-      if constexpr (trace(EvalTrace)) log::cache(node, cache);
+      if constexpr (trace(EvalTrace)) {
+        log::cache(node, cache);
+        log::cache(log::CacheDetail{.mode = log::CacheMode::Store,
+                                    .key = node->hash_value(),
+                                    .memory = log::bytes(ptr)},
+                   log::label(node));
+      }
 
       return mult_by_phase(ptr);
     } else {
@@ -326,12 +376,25 @@ ResultPtr evaluate(Node const& node,  //
 
   // logging
   if constexpr (trace(EvalTrace)) {
-    auto stat =
+    log::eval(
         log::EvalStat{.mode = log::eval_mode(node),
                       .time = time,
                       .memory = node.leaf() ? log::bytes(result)
-                                            : log::bytes(left, right, result)};
-    log::eval(stat, log::label(node));
+                                            : log::bytes(left, right, result)},
+        log::label(node));
+
+    if (!node.leaf()) {
+      auto hwmark = log::bytes(cache) + log::bytes(result).value;
+      if (!cache.alive(node.left())) hwmark += log::bytes(left).value;
+      if (!cache.alive(node.right())) hwmark += log::bytes(right).value;
+      auto stat = log::EvalDetailBinary{.mode = log::eval_mode(node),
+                                        .time = time,
+                                        .mem_left = log::bytes(left),
+                                        .mem_right = log::bytes(right),
+                                        .mem_result = log::bytes(result),
+                                        .mem_hwmark = {hwmark}};
+      log::eval(stat, log::label(node));
+    }
   }
 
   return result;

From 1c95f60304474ff443ecfc5035a25e7b23d231a7 Mon Sep 17 00:00:00 2001
From: Bimal Gaudel <bimalgaudel@gmail.com>
Date: Tue, 12 May 2026 10:58:34 -0400
Subject: [PATCH 2/6] refactor: unify eval log format and add cache liveness
 queries

---
 SeQuant/core/eval/cache_manager.hpp |  7 +++
 SeQuant/core/eval/eval.hpp          | 82 +++++++++++------------------
 tests/unit/test_cache_manager.cpp   | 48 +++++++++++++++++
 3 files changed, 86 insertions(+), 51 deletions(-)

diff --git a/SeQuant/core/eval/cache_manager.hpp b/SeQuant/core/eval/cache_manager.hpp
index f1185dce36..52dbe4657c 100644
--- a/SeQuant/core/eval/cache_manager.hpp
+++ b/SeQuant/core/eval/cache_manager.hpp
@@ -154,6 +154,13 @@ class CacheManager {
     return iter != cache_map_.end() && iter->second.alive();
   }
 
+  /// \return size in bytes of the data currently held for @p key, or 0 if
+  ///         the key is not registered or no data is currently stored.
+  [[nodiscard]] size_t entry_size_in_bytes(key_type const& key) const noexcept {
+    auto iter = cache_map_.find(key);
+    return iter == cache_map_.end() ? 0 : iter->second.size_in_bytes();
+  }
+
   ///
   /// \return The number of entries with life_count greater than zero.
   ///
diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index 07c3b5c4c7..ea6fa1d5aa 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -33,15 +33,15 @@ struct Bytes {
   size_t value;
 };
 
-template <typename... T>
-  requires((std::same_as<ResultPtr, T> && ...))
-[[nodiscard]] auto bytes(T const&... args) {
-  return Bytes{(args->size_in_bytes() + ...)};
-}
-
-template <typename N, bool F>
-[[nodiscard]] inline auto bytes(CacheManager<N, F> const& cman) {
-  return cman.size_in_bytes();
+template <typename T, typename... Ts>
+[[nodiscard]] inline auto bytes(T const& arg, Ts const&... args) {
+  auto one = [](auto const& a) -> size_t {
+    if constexpr (requires { a->size_in_bytes(); })
+      return a->size_in_bytes();
+    else
+      return a.size_in_bytes();
+  };
+  return Bytes{(one(arg) + ... + one(args))};
 }
 
 [[nodiscard]] inline auto to_string(Bytes bs) noexcept {
@@ -119,18 +119,13 @@ struct EvalDetailBinary {
   Bytes mem_hwmark;
 };
 
-struct CacheDetail {
-  CacheMode mode;
-  size_t key;
-  Bytes memory;
-};
-
 struct CacheStat {
   CacheMode mode;
   size_t key;
   int curr_life, max_life;
   size_t num_alive;
-  Bytes memory;
+  Bytes entry_memory;
+  Bytes total_memory;
 };
 
 template <typename Arg, typename... Args>
@@ -160,23 +155,15 @@ auto eval(EvalDetailBinary const& stat, Args const&... args) {
       args...);
 }
 
-template <typename... Args>
-auto cache(CacheDetail const& stat, Args const&... args) {
-  log("CacheDetail",           //
-      to_string(stat.mode),    //
-      stat.key,                //
-      to_string(stat.memory),  //
-      args...);
-}
-
 template <typename... Args>
 auto cache(CacheStat const& stat, Args const&... args) {
-  log("Cache",                                              //
-      to_string(stat.mode),                                 //
-      stat.key,                                             //
-      std::format("{}/{}", stat.curr_life, stat.max_life),  //
-      stat.num_alive,                                       //
-      to_string(stat.memory),                               //
+  log("Cache",                                                   //
+      to_string(stat.mode),                                      //
+      std::format("key={}", stat.key),                           //
+      std::format("life={}/{}", stat.curr_life, stat.max_life),  //
+      std::format("alive={}", stat.num_alive),                   //
+      std::format("entry={}", to_string(stat.entry_memory)),     //
+      std::format("total={}", to_string(stat.total_memory)),     //
       args...);
 }
 
@@ -197,7 +184,8 @@ auto cache(N const& node, CacheManager<N, F>& cm, Args const&... args) {
                   .curr_life = cur_l,
                   .max_life = max_l,
                   .num_alive = cm.alive_count(),
-                  .memory = {bytes(cm)}},
+                  .entry_memory = {cm.entry_size_in_bytes(node)},
+                  .total_memory = {bytes(cm)}},
         args...);
 }
 
@@ -314,28 +302,14 @@ ResultPtr evaluate(Node const& node,  //
     };
 
     if (auto ptr = cache.access(node); ptr) {
-      if constexpr (trace(EvalTrace)) {
-        log::cache(node, cache);
-        log::cache(log::CacheDetail{.mode = cache.life(node) == 0
-                                                ? log::CacheMode::Release
-                                                : log::CacheMode::Access,
-                                    .key = node->hash_value(),
-                                    .memory = log::bytes(ptr)},
-                   log::label(node));
-      }
+      if constexpr (trace(EvalTrace)) log::cache(node, cache, log::label(node));
 
       return mult_by_phase(ptr);
     } else if (cache.exists(node)) {
       auto ptr = cache.store(
           node, mult_by_phase(evaluate<EvalTrace, CacheCheck::Unchecked>(
                     node, le, cache)));
-      if constexpr (trace(EvalTrace)) {
-        log::cache(node, cache);
-        log::cache(log::CacheDetail{.mode = log::CacheMode::Store,
-                                    .key = node->hash_value(),
-                                    .memory = log::bytes(ptr)},
-                   log::label(node));
-      }
+      if constexpr (trace(EvalTrace)) log::cache(node, cache, log::label(node));
 
       return mult_by_phase(ptr);
     } else {
@@ -384,9 +358,15 @@ ResultPtr evaluate(Node const& node,  //
         log::label(node));
 
     if (!node.leaf()) {
-      auto hwmark = log::bytes(cache) + log::bytes(result).value;
-      if (!cache.alive(node.left())) hwmark += log::bytes(left).value;
-      if (!cache.alive(node.right())) hwmark += log::bytes(right).value;
+      // A cached child is *distinct* from the local left/right when its
+      // canon_phase != 1, because mult_by_phase allocates a fresh buffer
+      // while the cache still holds the pre-phase data. So only skip the
+      // local's bytes when the cache aliases the same buffer (phase == 1).
+      size_t hwmark = log::bytes(cache).value + log::bytes(result).value;
+      if (!cache.alive(node.left()) || node.left()->canon_phase() != 1)
+        hwmark += log::bytes(left).value;
+      if (!cache.alive(node.right()) || node.right()->canon_phase() != 1)
+        hwmark += log::bytes(right).value;
       auto stat = log::EvalDetailBinary{.mode = log::eval_mode(node),
                                         .time = time,
                                         .mem_left = log::bytes(left),
diff --git a/tests/unit/test_cache_manager.cpp b/tests/unit/test_cache_manager.cpp
index cf66102630..51a9a3acfe 100644
--- a/tests/unit/test_cache_manager.cpp
+++ b/tests/unit/test_cache_manager.cpp
@@ -111,6 +111,54 @@ TEST_CASE("cache_manager", "[cache_manager]") {
     }
   }
 
+  SECTION("alive and entry_size_in_bytes") {
+    auto man = man_const;
+
+    // A key never registered in the manager.
+    auto const stray = make_node(L"R = B");
+    REQUIRE_FALSE(man.exists(stray));
+    REQUIRE_FALSE(man.alive(stray));
+    REQUIRE(man.entry_size_in_bytes(stray) == 0);
+
+    // Registered but never stored: not alive, zero size.
+    for (auto&& k : decaying_keys) {
+      REQUIRE(man.exists(k));
+      REQUIRE_FALSE(man.alive(k));
+      REQUIRE(man.entry_size_in_bytes(k) == 0);
+    }
+
+    // After store(): alive, size matches the stored data.
+    for (auto&& [k, v] : zip(decaying_keys, decaying_vals)) {
+      REQUIRE(man.store(k, v));
+      REQUIRE(man.alive(k));
+      REQUIRE(man.entry_size_in_bytes(k) == v->size_in_bytes());
+    }
+
+    // Drain each entry's remaining life. store() consumed one access already,
+    // so r - 1 accesses remain before data_p is moved out.
+    for (auto&& [k, r] : zip(decaying_keys, decaying_repeats)) {
+      for (auto i = r - 1; i > 0; --i) {
+        REQUIRE(man.alive(k));  // still holds data before this access
+        REQUIRE(man.access(k));
+      }
+      // Final access has drained life to 0 and moved data_p out.
+      REQUIRE_FALSE(man.alive(k));
+      REQUIRE(man.entry_size_in_bytes(k) == 0);
+    }
+
+    // reset() restores life counts; re-store, confirm alive, then reset()
+    // and confirm entries are not-alive again.
+    man.reset();
+    for (auto&& [k, v] : zip(decaying_keys, decaying_vals))
+      REQUIRE(man.store(k, v));
+    for (auto&& k : decaying_keys) REQUIRE(man.alive(k));
+    man.reset();
+    for (auto&& k : decaying_keys) {
+      REQUIRE_FALSE(man.alive(k));
+      REQUIRE(man.entry_size_in_bytes(k) == 0);
+    }
+  }
+
   SECTION("Hash collision safety") {
     // Two structurally different nodes
     auto const n1 = make_node(L"R{a1;i1} = f{a1;i1}");

From f31ddaa725c987eab8b1d8d93604ae4dfe2b72bd Mon Sep 17 00:00:00 2001
From: Bimal Gaudel <bimalgaudel@gmail.com>
Date: Tue, 12 May 2026 14:33:21 -0400
Subject: [PATCH 3/6] refactor: unify per-op Eval log record and tighten
 high-water mark
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Drop EvalDetailBinary; collapse to a single Eval line per op, with
optional left/right populated only for Sum/Product. Add an alloc field
that distinguishes fresh-allocation ops from SumInplace (alloc=0B), so
summing the column gives total bytes allocated and `grep alloc=0B`
isolates inplace ops. Fix hwmark undercounts in Permute and SumInplace
for cached inputs whose canon_phase != 1 or that the permute wrapper
turned into a fresh buffer — previously these silently biased hw down.
---
 SeQuant/core/eval/eval.hpp | 160 +++++++++++++++++++++++++------------
 1 file changed, 111 insertions(+), 49 deletions(-)

diff --git a/SeQuant/core/eval/eval.hpp b/SeQuant/core/eval/eval.hpp
index ea6fa1d5aa..6e31bc09fc 100644
--- a/SeQuant/core/eval/eval.hpp
+++ b/SeQuant/core/eval/eval.hpp
@@ -20,6 +20,7 @@
 
 #include <any>
 #include <iostream>
+#include <optional>
 #include <stdexcept>
 #include <type_traits>
 
@@ -104,19 +105,45 @@ enum struct TermMode { Begin, End };
   return (mode == TermMode::Begin) ? "Begin" : "End";
 }
 
+/// One log record per eval op. Line format:
+///
+// clang-format off
+/// Eval | <mode> | <time> | [left=L | right=R |] result=X | alloc=A | hw=H | <label>
+// clang-format on
+///
+/// Which fields are set depends on the op's arity:
+///
+///   mode                                          | left/right | alloc
+///   ----------------------------------------------+------------+--------
+///   Constant / Variable / Tensor (leaf)           | —          | result
+///   Permute / MultByPhase /                       | —          | result
+///     Symmetrize / Antisymmetrize                 |            |
+///   SumInplace                                    | —          | 0B
+///   Sum / Product                                 | set        | result
+///
+/// Only Sum and Product set left/right, since their operand sizes can
+/// differ from the result. Other modes omit those fields rather than
+/// zeroing them, so a logged 0B always means an empty buffer.
+///
+/// mem_result is the size of the buffer the op produces; for SumInplace
+/// it's the size of the accumulator after the add. mem_alloc is what the
+/// op allocated — equal to mem_result everywhere except SumInplace,
+/// which writes into the accumulator and allocates nothing. mem_hwmark
+/// is the live working set during the op:
+///
+///   bytes(cache) + bytes(result) + bytes of each operand not aliased
+///                                  to a cache entry
+///
+/// Aliasing is evaluated at each call site using cache.alive,
+/// canon_phase, and the requested layout.
 struct EvalStat {
   EvalMode mode;
   Duration time;
-  Bytes memory;
-};
-
-struct EvalDetailBinary {
-  EvalMode mode;
-  Duration time;
-  Bytes mem_left;
-  Bytes mem_right;
-  Bytes mem_result;
-  Bytes mem_hwmark;
+  Bytes mem_result{};
+  Bytes mem_alloc{};
+  Bytes mem_hwmark{};
+  std::optional<Bytes> mem_left;
+  std::optional<Bytes> mem_right;
 };
 
 struct CacheStat {
@@ -136,23 +163,24 @@ void log(Arg const& arg, Args const&... args) {
 
 template <typename... Args>
 auto eval(EvalStat const& stat, Args const&... args) {
-  log("Eval",                  //
-      to_string(stat.mode),    //
-      stat.time,               //
-      to_string(stat.memory),  //
-      args...);
-}
-
-template <typename... Args>
-auto eval(EvalDetailBinary const& stat, Args const&... args) {
-  log("EvalDetail",                                          //
-      to_string(stat.mode),                                  //
-      stat.time,                                             //
-      std::format("left={}", to_string(stat.mem_left)),      //
-      std::format("right={}", to_string(stat.mem_right)),    //
-      std::format("result={}", to_string(stat.mem_result)),  //
-      std::format("hw={}", to_string(stat.mem_hwmark)),      //
-      args...);
+  auto const result_s = std::format("result={}", to_string(stat.mem_result));
+  auto const alloc_s = std::format("alloc={}", to_string(stat.mem_alloc));
+  auto const hw_s = std::format("hw={}", to_string(stat.mem_hwmark));
+  if (stat.mem_left) {
+    SEQUANT_ASSERT(stat.mem_right);
+    log("Eval",                                               //
+        to_string(stat.mode),                                 //
+        stat.time,                                            //
+        std::format("left={}", to_string(*stat.mem_left)),    //
+        std::format("right={}", to_string(*stat.mem_right)),  //
+        result_s, alloc_s, hw_s,                              //
+        args...);
+  } else {
+    log("Eval",                //
+        to_string(stat.mode),  //
+        stat.time,             //
+        result_s, alloc_s, hw_s, args...);
+  }
 }
 
 template <typename... Args>
@@ -284,7 +312,7 @@ ResultPtr evaluate(Node const& node,  //
                    CacheManager<N, FHC>& cache) {
   if constexpr (Cache == CacheCheck::Checked) {  // return from cache if found
 
-    auto mult_by_phase = [&node](ResultPtr res) {
+    auto mult_by_phase = [&node, &cache](ResultPtr res) {
       auto phase = node->canon_phase();
       if (phase == 1) return res;
 
@@ -293,9 +321,13 @@ ResultPtr evaluate(Node const& node,  //
           timed_eval_inplace([&]() { post = res->mult_by_phase(phase); });
 
       if constexpr (trace(EvalTrace)) {
+        size_t hwmark = log::bytes(cache, post).value;
+        if (!cache.alive(node)) hwmark += log::bytes(res).value;
         auto stat = log::EvalStat{.mode = log::EvalMode::MultByPhase,
                                   .time = time,
-                                  .memory = log::bytes(res, post)};
+                                  .mem_result = log::bytes(post),
+                                  .mem_alloc = log::bytes(post),
+                                  .mem_hwmark = {hwmark}};
         log::eval(stat, std::format("{} * {}", phase, node->label()));
       }
       return post;
@@ -350,30 +382,31 @@ ResultPtr evaluate(Node const& node,  //
 
   // logging
   if constexpr (trace(EvalTrace)) {
-    log::eval(
-        log::EvalStat{.mode = log::eval_mode(node),
-                      .time = time,
-                      .memory = node.leaf() ? log::bytes(result)
-                                            : log::bytes(left, right, result)},
-        log::label(node));
-
-    if (!node.leaf()) {
+    if (node.leaf()) {
+      log::eval(log::EvalStat{.mode = log::eval_mode(node),
+                              .time = time,
+                              .mem_result = log::bytes(result),
+                              .mem_alloc = log::bytes(result),
+                              .mem_hwmark = log::bytes(cache, result)},
+                log::label(node));
+    } else {
       // A cached child is *distinct* from the local left/right when its
       // canon_phase != 1, because mult_by_phase allocates a fresh buffer
       // while the cache still holds the pre-phase data. So only skip the
       // local's bytes when the cache aliases the same buffer (phase == 1).
-      size_t hwmark = log::bytes(cache).value + log::bytes(result).value;
+      size_t hwmark = log::bytes(cache, result).value;
       if (!cache.alive(node.left()) || node.left()->canon_phase() != 1)
         hwmark += log::bytes(left).value;
       if (!cache.alive(node.right()) || node.right()->canon_phase() != 1)
         hwmark += log::bytes(right).value;
-      auto stat = log::EvalDetailBinary{.mode = log::eval_mode(node),
-                                        .time = time,
-                                        .mem_left = log::bytes(left),
-                                        .mem_right = log::bytes(right),
-                                        .mem_result = log::bytes(result),
-                                        .mem_hwmark = {hwmark}};
-      log::eval(stat, log::label(node));
+      log::eval(log::EvalStat{.mode = log::eval_mode(node),
+                              .time = time,
+                              .mem_result = log::bytes(result),
+                              .mem_alloc = log::bytes(result),
+                              .mem_hwmark = {hwmark},
+                              .mem_left = log::bytes(left),
+                              .mem_right = log::bytes(right)},
+                log::label(node));
     }
   }
 
@@ -426,9 +459,17 @@ ResultPtr evaluate(Node const& node,           //
   // logging
   if constexpr (trace(EvalTrace)) {
     if (perm) {
+      // result.pre aliases the cache only when the inner evaluate returned
+      // the cached buffer unchanged — i.e. the node is cached AND no
+      // mult_by_phase fresh allocation happened (phase == 1).
+      size_t hwmark = log::bytes(cache, result.post).value;
+      if (!cache.alive(node) || node->canon_phase() != 1)
+        hwmark += log::bytes(result.pre).value;
       auto stat = log::EvalStat{.mode = log::EvalMode::Permute,
                                 .time = time,
-                                .memory = log::bytes(result.pre, result.post)};
+                                .mem_result = log::bytes(result.post),
+                                .mem_alloc = log::bytes(result.post),
+                                .mem_hwmark = {hwmark}};
       log::eval(stat, node->label());
     }
     log::term(log::TermMode::End, xpr);
@@ -462,6 +503,11 @@ ResultPtr evaluate(Nodes const& nodes,  //
                    F const& le, CacheManager<N, FHC>& cache) {
   ResultPtr result;
 
+  // pre comes back from the permute-wrapping evaluate; it aliases the
+  // cache only when the inner evaluate returned the cached buffer
+  // unchanged — i.e. node cached, phase == 1, AND no permute happened.
+  bool const layout_is_default = (layout == decltype(layout){});
+
   for (auto&& n : nodes) {
     if (!result) {
       result = evaluate<EvalTrace>(n, layout, le, cache);
@@ -473,9 +519,17 @@ ResultPtr evaluate(Nodes const& nodes,  //
 
     // logging
     if constexpr (trace(EvalTrace)) {
+      // SumInplace allocates nothing: it writes into the accumulator.
+      // hwmark counts the cache plus both operands live at this moment;
+      // skip pre's bytes only when pre is the cached buffer itself.
+      size_t hwmark = log::bytes(cache, result).value;
+      if (!cache.alive(n) || n->canon_phase() != 1 || !layout_is_default)
+        hwmark += log::bytes(pre).value;
       auto stat = log::EvalStat{.mode = log::EvalMode::SumInplace,
                                 .time = time,
-                                .memory = log::bytes(result, pre)};
+                                .mem_result = log::bytes(result),
+                                .mem_alloc = {0},
+                                .mem_hwmark = {hwmark}};
       log::eval(stat, n->label());
     }
   }
@@ -550,9 +604,14 @@ ResultPtr evaluate_symm(Args&&... args) {
 
   // logging
   if constexpr (trace(EvalTrace)) {
+    // cache is owned by the inner evaluate call and out of scope here;
+    // hwmark reflects only the local working set (pre + freshly allocated
+    // result both live during the symmetrize op).
     auto stat = log::EvalStat{.mode = log::EvalMode::Symmetrize,
                               .time = time,
-                              .memory = log::bytes(pre, result)};
+                              .mem_result = log::bytes(result),
+                              .mem_alloc = log::bytes(result),
+                              .mem_hwmark = log::bytes(pre, result)};
     log::eval(stat, node0(arg0(std::forward<Args>(args)...))->label());
   }
 
@@ -582,9 +641,12 @@ ResultPtr evaluate_antisymm(Args&&... args) {
 
   // logging
   if constexpr (trace(EvalTrace)) {
+    // See Symmetrize for the rationale on hwmark.
     auto stat = log::EvalStat{.mode = log::EvalMode::Antisymmetrize,
                               .time = time,
-                              .memory = log::bytes(pre, result)};
+                              .mem_result = log::bytes(result),
+                              .mem_alloc = log::bytes(result),
+                              .mem_hwmark = log::bytes(pre, result)};
     log::eval(stat, n0->label());
   }
   return result;

From 3398d0856eb05149081acd82c238481ecf9485d7 Mon Sep 17 00:00:00 2001
From: Bimal Gaudel <bimalgaudel@gmail.com>
Date: Tue, 12 May 2026 15:49:15 -0400
Subject: [PATCH 4/6] docs: switch eval trace analysis from Nushell to Python
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the sequant.nu helper with sequant_trace.py — a stdlib-only
parser exposing trace_eval/trace_cache/trace_term plus a one-pass
parse() that returns NamedTuple rows (EvalRow/CacheRow/TermRow with
an extras dict for unrecognized fields). Rewrite evaluation.rst with
Python recipes and regenerated example outputs that reflect the new
trace columns (alloc, hw, left/right) and the per-mode field-population
rules. Add a note that the parser is iteration-blind: callers must
slice rows by line range or term before aggregating across repeated
contexts (the sample mpqc_out.txt is capped at one iteration for this
reason).
---
 doc/user/guide/evaluation.rst   |  428 ++---
 doc/user/guide/mpqc_out.txt     | 2576 ++++++++++++++++++++++++++++---
 doc/user/guide/sequant.nu       |   87 --
 doc/user/guide/sequant_trace.py |  312 ++++
 doc/user/guide/trace.txt        |  800 ----------
 5 files changed, 2861 insertions(+), 1342 deletions(-)
 delete mode 100644 doc/user/guide/sequant.nu
 create mode 100644 doc/user/guide/sequant_trace.py
 delete mode 100644 doc/user/guide/trace.txt

diff --git a/doc/user/guide/evaluation.rst b/doc/user/guide/evaluation.rst
index df9a9984b4..188ff392d0 100644
--- a/doc/user/guide/evaluation.rst
+++ b/doc/user/guide/evaluation.rst
@@ -1,263 +1,287 @@
-***************************************
-Evaluation Trace Analysis Using Nushell
-***************************************
+*************************
+Evaluation Trace Analysis
+*************************
+
+When the evaluator is built with ``SEQUANT_EVAL_TRACE``, it emits one
+log line per operation. A trace line is one of three kinds, identified
+by its first token:
+
+* ``Eval | <mode> | <time> | [left=L | right=R |] result=X | alloc=A | hw=H | <label>``
+* ``Cache | <mode> | key=K | life=c/m | alive=N | entry=E | total=T | <label>``
+* ``Term | Begin | <expr>`` / ``Term | End | <expr>``
+
+The trace may be embedded in a larger log; the parsers in this guide
+ignore non-trace lines.
+
+Setup
+=====
+
+:download:`Save this helper </user/guide/sequant_trace.py>` next to
+your trace file. It uses only the Python 3 standard library.
+
+The sample trace below is :download:`from this file
+</user/guide/mpqc_out.txt>`, produced by an ``mpqc4`` CCSDT calculation
+on a He chain. The same file holds the surrounding mpqc output; the
+parsers skip non-trace lines automatically.
+
+.. note::
+
+   The parsers don't know about iterations. If your trace spans more
+   than one CC iteration (or any other repeated context), aggregates
+   like peak memory or total time blend across them — slice the row
+   lists by line range or by term first. The sample here was capped at
+   a single iteration to keep the examples clean.
+
+Throughout the rest of this page, assume:
+
+.. code:: python
+
+   import sequant_trace as st
+   eval_rows, cache_rows, term_rows = st.parse("mpqc_out.txt")
+
+``parse`` walks the file once and returns three lists. Each list holds
+``NamedTuple`` rows (``EvalRow``, ``CacheRow``, ``TermRow``) so columns
+are accessed by attribute (``r.mode``, ``r.time_ns``, …). For one-stream
+use the generators ``st.trace_eval(path)`` and ``st.trace_cache(path)``,
+and the list-returning ``st.trace_term(path)``.
+
+Reading evaluation steps
+========================
+
+Each ``EvalRow`` has the fields:
+
+``mode``
+    one of ``Tensor``, ``Constant``, ``Variable``, ``Permute``,
+    ``MultByPhase``, ``Sum``, ``Product``, ``SumInplace``,
+    ``Symmetrize``, ``Antisymmetrize``.
+``time_ns``
+    wall time in nanoseconds.
+``result``
+    bytes of the buffer this op produces (for ``SumInplace``, the
+    accumulator after the add).
+``alloc``
+    bytes of fresh allocation by this op. ``0`` for ``SumInplace``;
+    equal to ``result`` for every other mode.
+``hw``
+    live working-set bytes at the moment of the op — cache contents +
+    result + each operand not aliased to a cache entry.
+``left`` / ``right``
+    operand bytes, set only for ``Sum`` and ``Product``.
+``label``
+    the operation's textual label.
+``line``
+    1-indexed source line in the trace file.
+``extras``
+    a dict capturing any ``key=value`` fields the parser didn't
+    recognize. Empty today; populated automatically if the evaluator
+    starts logging additional columns.
+
+Distinct modes in this trace:
+
+.. code:: python
+
+   sorted({r.mode for r in eval_rows})
 
-Follow the official instructions to install `Nushell <https://www.nushell.sh/book/installation.html>`__.
-
-:download:`Save this file </user/guide/sequant.nu>` in the same directory
-where the trace output file is present. We will call this directory
-'working directory'.
-
-This nu script exports the functions: ``trace eval``, ``trace cache``,
-and ``trace term``.
-
-If you are using a different shell (eg. bash, zsh, etc.), launch the
-nushell from the working directory. Make sure the executable ``nu``  is
-on your path.
-
-.. code:: sh
-
-   nu
+::
 
-Then import the functions from the script.
+    ['Constant', 'Permute', 'Product', 'SumInplace', 'Symmetrize', 'Tensor']
 
-.. code:: nu
+First few entries:
 
-   use sequant.nu *
+.. code:: python
 
-Now we analyze :download:`the trace from this file </user/guide/trace.txt>` in steps.
-This trace was generated by ``mpqc4`` CCSD calculation for ``He16`` chain using
-``cc-pVTZ`` basis. The trace is for the very first iteration. The mpqc output file without
-the SeQuant evaluation trace is :download:`here </user/guide/mpqc_out.txt>`.
+   st.print_table(eval_rows, max_rows=5)
 
-A trace line produced by the evaluator is one of the three kinds: an **evaluation**,
-a **cache** interaction, and a term indicator when the evaluation of a **term** starts
-or ends.
+::
 
-Analysis of evaluation steps
-=============================
+    mode    | time_ns   | result    | alloc     | hw        | left      | right | label                                         | line
+    --------+-----------+-----------+-----------+-----------+-----------+-------+-----------------------------------------------+-----
+    Tensor  | 412107750 | 163879224 | 163879224 | 163879224 |      None |  None | g(i_2,a_1,a_2,a_3)                            |  346
+    Tensor  |      1291 |       640 |       640 |       640 |      None |  None | t(a_3,i_2)                                    |  347
+    Product |   3307083 |      4992 |      4992 | 163884856 | 163879224 |   640 | g(i_2,a_1,a_2,a_3) * t(a_3,i_2) -> I(a_1,a_2) |  348
+    Tensor  |       750 |       640 |       640 |       640 |      None |  None | t(a_2,i_1)                                    |  349
+    Product |     68917 |       640 |       640 |      6272 |      4992 |   640 | I(a_1,a_2) * t(a_2,i_1) -> I(a_1,i_1)         |  350
 
-.. code:: nu
+``left`` and ``right`` are populated only for ``Sum`` and ``Product`` —
+the only ops whose operand sizes can differ from the result. For other
+modes those fields are ``None`` (omitted from the trace), not zero, so
+a logged ``0B`` always means an empty buffer.
 
-   let eval = trace eval trace.txt
+Top five time-consuming steps:
 
-The ``$eval`` variable is a table that contains trace from evaluation
-steps.
+.. code:: python
 
-.. code:: nu
+   top_t = sorted(eval_rows, key=lambda r: r.time_ns, reverse=True)[:5]
+   st.print_table(top_t,
+                  columns=["mode","time_ns","result","alloc","hw","label","line"])
 
-   $eval | columns
 ::
 
-    ╭───┬────────╮
-    │ 0 │ tag0   │
-    │ 1 │ tag1   │
-    │ 2 │ time   │
-    │ 3 │ memory │
-    │ 4 │ annot  │
-    │ 5 │ line   │
-    ╰───┴────────╯
-
-Let's look at the unique entries of the ``tag1`` column:
-
-.. code:: nu
+    mode   | time_ns     | result     | alloc      | hw         | label              | line
+    -------+-------------+------------+------------+------------+--------------------+-----
+    Tensor | 10352466209 | 3100868920 | 3100868920 | 3100889240 | g(a_1,a_2,a_3,a_4) |  688
+    Tensor |   412107750 |  163879224 |  163879224 |  163879224 | g(i_2,a_1,a_2,a_3) |  346
+    Tensor |   263996250 |  163879224 |  163879224 |  163900616 | g(a_1,a_2,i_1,a_3) |  797
+    Tensor |   237571833 |  163879224 |  163879224 |  163900616 | g(i_3,a_2,a_3,a_4) |  806
+    Tensor |   225673167 |  163879224 |  163879224 |  163924632 | g(a_3,a_2,i_3,a_4) | 1829
 
-   $eval | get tag1 | uniq
-::
-
-    ╭───┬────────────╮
-    │ 0 │ Tensor     │
-    │ 1 │ Permute    │
-    │ 2 │ Product    │
-    │ 3 │ Constant   │
-    │ 4 │ SumInplace │
-    │ 5 │ Symmetrize │
-    ╰───┴────────────╯
+Top five by working-set peak. ``hw`` is the most useful memory column
+for "what was the worst moment of this run"; ``result`` answers "what
+is the biggest tensor produced" and ``alloc`` answers "what allocated
+the most fresh memory":
 
-Now let's look at the first few entries. Note that the last column ``line`` is the line number
-in the output file (``trace.txt`` in our case).
+.. code:: python
 
-.. code:: nu
+   top_h = sorted(eval_rows, key=lambda r: r.hw, reverse=True)[:5]
+   st.print_table(top_h,
+                  columns=["mode","time_ns","result","alloc","hw","label","line"])
 
-   $eval | first 10
 ::
 
-    ╭───┬──────┬────────────┬───────────────────┬─────────┬───────────────────────────────────────┬──────╮
-    │ # │ tag0 │    tag1    │       time        │ memory  │                 annot                 │ line │
-    ├───┼──────┼────────────┼───────────────────┼─────────┼───────────────────────────────────────┼──────┤
-    │ 0 │ Eval │ Tensor     │     6ms 3µs 295ns │ 36.7 kB │ f(a_1,i_1)                            │    2 │
-    │ 1 │ Eval │ Permute    │       195µs 598ns │ 73.5 kB │ f(a_1,i_1)                            │    3 │
-    │ 2 │ Eval │ Tensor     │ 119ms 317µs 395ns │ 10.7 kB │ f(i_2,i_1)                            │    6 │
-    │ 3 │ Eval │ Tensor     │         1µs 613ns │ 36.7 kB │ t(a_1,i_2)                            │    7 │
-    │ 4 │ Eval │ Product    │   6ms 789µs 630ns │ 84.2 kB │ f(i_2,i_1) * t(a_1,i_2) -> I(a_1,i_1) │    8 │
-    │ 5 │ Eval │ Constant   │         3µs 296ns │     8 B │ {{{-1}}}                              │    9 │
-    │ 6 │ Eval │ Product    │       199µs 284ns │ 73.5 kB │ I(a_1,i_1) * {{{-1}}} -> I(a_1,i_1)   │   10 │
-    │ 7 │ Eval │ Permute    │       755µs 948ns │ 73.5 kB │ I(a_1,i_1)                            │   11 │
-    │ 8 │ Eval │ SumInplace │    3ms 32µs 326ns │ 73.5 kB │ I(a_1,i_1)                            │   13 │
-    │ 9 │ Eval │ Tensor     │   6ms 265µs 660ns │ 36.7 kB │ f(i_2,a_2)                            │   15 │
-    ╰───┴──────┴────────────┴───────────────────┴─────────┴───────────────────────────────────────┴──────╯
-
-Listing top five time-consuming steps:
-
-.. code:: nu
-
-   $eval | sort-by time --reverse | first 5
-::
+    mode    | time_ns  | result     | alloc      | hw         | label                                                                         | line
+    --------+----------+------------+------------+------------+-------------------------------------------------------------------------------+-----
+    Product | 72411125 |    1258096 |    1258096 | 3103424296 | g(a_1,a_2,a_4,a_5) * t(a_3,a_4,a_5,i_3,i_1,i_2) -> I(a_3,a_2,a_1,i_2,i_1,i_3) | 1532
+    Product | 50984709 |     314800 |     314800 | 3101229768 | g(a_2,a_3,a_4,a_5) * t(a_5,i_3) -> I(a_2,a_3,i_3,a_4)                         | 1840
+    Product | 54562167 |     314800 |     314800 | 3101205752 | g(a_1,a_2,a_3,a_4) * t(a_3,i_1) -> I(a_2,a_1,i_1,a_4)                         |  790
+    Product | 52750125 |      18864 |      18864 | 3100926968 | g(a_1,a_2,a_3,a_4) * t(a_3,a_4,i_1,i_2) -> I(a_2,a_1,i_2,i_1)                 |  690
+    Tensor  |    13875 | 3100868920 | 3100868920 | 3100914328 | g(a_2,a_3,a_4,a_5)                                                            | 1838
 
-    ╭───┬──────┬─────────┬────────────────────────┬─────────┬───────────────────────────────────────────────────────────────┬──────╮
-    │ # │ tag0 │  tag1   │          time          │ memory  │                             annot                             │ line │
-    ├───┼──────┼─────────┼────────────────────────┼─────────┼───────────────────────────────────────────────────────────────┼──────┤
-    │ 0 │ Eval │ Tensor  │ 2sec 732ms 827µs 727ns │ 14.9 GB │ g(a_1,a_2,a_3,a_4)                                            │  260 │
-    │ 1 │ Eval │ Product │ 1sec 302ms 417µs 788ns │ 15.1 GB │ g(a_1,a_2,a_3,a_4) * t(a_3,a_4,i_1,i_2) -> I(a_2,a_1,i_2,i_1) │  262 │
-    │ 2 │ Eval │ Product │  1sec 95ms 839µs 314ns │ 16.1 GB │ g(a_1,a_2,a_3,a_4) * t(a_3,i_1) -> I(a_2,a_1,i_1,a_4)         │  382 │
-    │ 3 │ Eval │ Tensor  │      688ms 998µs 813ns │ 88.7 MB │ g(i_2,a_1,i_1,a_2)                                            │   24 │
-    │ 4 │ Eval │ Tensor  │      280ms 151µs 443ns │  1.1 GB │ g(i_2,a_1,a_2,a_3)                                            │   51 │
-    ╰───┴──────┴─────────┴────────────────────────┴─────────┴───────────────────────────────────────────────────────────────┴──────╯
+Total time spent in the evaluator:
 
-Listing top five memory-consuming steps:
+.. code:: python
 
-.. code:: nu
+   total_ns = sum(r.time_ns for r in eval_rows)
+   print(f"{total_ns / 1e9:.6f} s")
 
-   $eval | sort-by memory --reverse | first 5
 ::
 
-    ╭───┬──────┬─────────┬────────────────────────┬─────────┬───────────────────────────────────────────────────────────────┬──────╮
-    │ # │ tag0 │  tag1   │          time          │ memory  │                             annot                             │ line │
-    ├───┼──────┼─────────┼────────────────────────┼─────────┼───────────────────────────────────────────────────────────────┼──────┤
-    │ 0 │ Eval │ Product │  1sec 95ms 839µs 314ns │ 16.1 GB │ g(a_1,a_2,a_3,a_4) * t(a_3,i_1) -> I(a_2,a_1,i_1,a_4)         │  382 │
-    │ 1 │ Eval │ Product │ 1sec 302ms 417µs 788ns │ 15.1 GB │ g(a_1,a_2,a_3,a_4) * t(a_3,a_4,i_1,i_2) -> I(a_2,a_1,i_2,i_1) │  262 │
-    │ 2 │ Eval │ Tensor  │             25µs 840ns │ 14.9 GB │ g(a_1,a_2,a_3,a_4)                                            │  380 │
-    │ 3 │ Eval │ Tensor  │ 2sec 732ms 827µs 727ns │ 14.9 GB │ g(a_1,a_2,a_3,a_4)                                            │  260 │
-    │ 4 │ Eval │ Product │      188ms 365µs 620ns │  1.2 GB │ g(i_3,a_1,a_3,a_4) * t(a_3,a_4,i_2,i_1) -> I(i_3,a_1,i_2,i_1) │  466 │
-    ╰───┴──────┴─────────┴────────────────────────┴─────────┴───────────────────────────────────────────────────────────────┴──────╯
+    20.070343 s
 
-The sum total of the time column:
+Reading cache interactions
+==========================
 
-.. code:: nu
+Each ``CacheRow`` has the fields:
 
-   $eval | get time | math sum
-::
+``mode``
+    one of ``Store``, ``Access``, ``Release``.
+``key``
+    hash identifying the cached intermediate.
+``life_curr`` / ``life_max``
+    remaining and total number of accesses for this entry.
+``alive``
+    number of entries in the cache after this interaction.
+``entry``
+    bytes occupied by this entry (``0`` for a release).
+``total``
+    bytes occupied by all live entries combined.
+``label``
+    label of the node touching the cache.
+``line``
+    source line in the trace file.
+``extras``
+    dict for any unrecognized ``key=value`` fields (empty today).
 
-   16sec 693ms 188µs 413ns
+First few entries:
 
+.. code:: python
 
-Analysis of cache interaction
-=============================
+   st.print_table(cache_rows, max_rows=5)
 
-Parsing the cache trace:
+::
 
-.. code:: nu
+    mode    | key                  | life_curr | life_max | alive | entry | total | label                                         | line
+    --------+----------------------+-----------+----------+-------+-------+-------+-----------------------------------------------+-----
+    Store   | 13613060045528791584 |         2 |        3 |     2 |   640 |   640 | g(i_2,i_3,a_2,a_3) * t(a_3,i_2) -> I(i_3,a_2) |  397
+    Access  | 13613060045528791584 |         1 |        3 |     1 |   640 |   640 | g(i_2,i_3,a_2,a_3) * t(a_3,i_2) -> I(i_3,a_2) |  413
+    Store   | 12860816093799665187 |         2 |        3 |     3 |   640 |  1280 | g(i_2,i_3,a_2,a_3) * t(a_3,i_3) -> I(i_2,a_2) |  425
+    Access  | 12860816093799665187 |         1 |        3 |     2 |   640 |  1280 | g(i_2,i_3,a_2,a_3) * t(a_2,i_2) -> I(i_3,a_3) |  434
+    Release | 13613060045528791584 |         0 |        3 |     1 |     0 |   640 | g(i_2,i_3,a_2,a_3) * t(a_3,i_2) -> I(i_3,a_2) |  445
 
-   let cache = trace cache trace.txt
+The first row stores an intermediate with three allowed accesses; the
+``Store`` event itself counts as an access, so ``life`` is ``2/3``. The
+``total`` column tracks the rolling cache footprint — sum of every live
+entry — and the ``entry`` column the size of the single entry this row
+refers to. ``Release`` rows show ``entry=0`` because the entry is gone
+by the time the row is recorded.
 
-Let's take a look at the first few lines:
+Peak cache footprint over the whole trace:
 
-.. code:: nu
+.. code:: python
 
-   $cache | first 5
-::
+   peak = max(cache_rows, key=lambda r: r.total)
+   st.print_table([peak],
+                  columns=["mode","key","alive","entry","total","line"])
 
-    ╭───┬───────┬─────────┬──────────────────────┬──────┬────────┬─────────┬──────╮
-    │ # │ tag0  │  tag1   │         key          │ life │ nalive │ memory  │ line │
-    ├───┼───────┼─────────┼──────────────────────┼──────┼────────┼─────────┼──────┤
-    │ 0 │ Cache │ Store   │ 6443766742777296727  │ 2/3  │      2 │ 36.7 kB │   95 │
-    │ 1 │ Cache │ Store   │ 14406268377898944426 │ 1/2  │      3 │  6.9 MB │  116 │
-    │ 2 │ Cache │ Store   │ 4354995230928331310  │ 2/3  │      5 │  7.0 MB │  137 │
-    │ 3 │ Cache │ Access  │ 4354995230928331310  │ 1/3  │      4 │  7.0 MB │  155 │
-    │ 4 │ Cache │ Release │ 14406268377898944426 │ 0/2  │      3 │ 73.5 kB │  195 │
-    ╰───┴───────┴─────────┴──────────────────────┴──────┴────────┴─────────┴──────╯
-
-An entry is identified by the ``key`` in the cache. From the table we
-see that the first cache interaction was to store an intermediate. Turns out the
-intermediate is allowed only three accesses before it is released from the cache.
-Since we stored, and immediately accessed it as part of the evaluation step, we see the
-life of this intermediate is ``2/3``. Because no other entries have been added to the
-cache at this point the total number of alive entries is ``2`` as seen from the
-``nalive`` column. The memory used by the cache which is the sum of the alive entries
-is given in the ``memory`` column.
-
-Next, another intermediate is stored in the cache. Since there are two alive entries
-already, this brings the ``nalive`` to three. The cache memory reaches to 6.9 MB,
-implying the intermediate that was just stored is ~6.8 MB in size. We can see from
-the last row the same intermediate is released.
-
-We can see what was the peak memory use by the cache:
-
-.. code:: nu
-
-   $cache | sort-by memory --reverse | take 1
 ::
 
+    mode  | key               | alive | entry | total | line
+    ------+-------------------+-------+-------+-------+-----
+    Store | 47978033300314424 |    11 |  4720 | 87856 | 2026
 
-    ╭───┬───────┬───────┬─────────────────────┬──────┬────────┬──────────┬──────╮
-    │ # │ tag0  │ tag1  │         key         │ life │ nalive │  memory  │ line │
-    ├───┼───────┼───────┼─────────────────────┼──────┼────────┼──────────┼──────┤
-    │ 0 │ Cache │ Store │ 1502144429761737779 │ 1/2  │      5 │ 267.4 MB │  575 │
-    ╰───┴───────┴───────┴─────────────────────┴──────┴────────┴──────────┴──────╯
-
+Reading terms
+=============
 
-Analysis of the terms
-=====================
+``trace_term`` matches each ``Term | End`` with the most recent
+unclosed ``Term | Begin`` and returns one ``TermRow`` per pair:
 
-We can see when the evaluation of a term began and ended. Let's start by parsing
-the terms related trace.
+``begin_line``
+    source line of the ``Term | Begin``.
+``end_line``
+    source line of the ``Term | End``.
+``expr``
+    expression text shared by the matched pair.
 
-.. code:: nu
+First few:
 
-   let term = trace term trace.txt
+.. code:: python
 
-Let's take a look at the first few entries:
+   st.print_table(term_rows, max_rows=5)
 
-.. code:: nu
-
-   $term | first 5
 ::
 
-    ╭───┬──────┬───────┬─────┬────────────────────────────────────────────────╮
-    │ # │ tag0 │ begin │ end │                      expr                      │
-    ├───┼──────┼───────┼─────┼────────────────────────────────────────────────┤
-    │ 0 │ Term │     1 │   4 │ f{a_1;i_1}:N-C-S                               │
-    │ 1 │ Term │     5 │  12 │ -1 f{i_2;i_1}:N-C-S * t{a_1;i_2}:N-C-S         │
-    │ 2 │ Term │    14 │  21 │ 2 f{i_2;a_2}:N-C-S * t{a_1,a_2;i_1,i_2}:N-C-S  │
-    │ 3 │ Term │    23 │  30 │ -1 g{i_2,a_1;i_1,a_2}:N-C-S * t{a_2;i_2}:N-C-S │
-    │ 4 │ Term │    32 │  39 │ 2 g{i_2,a_1;a_2,i_1}:N-C-S * t{a_2;i_2}:N-C-S  │
-    ╰───┴──────┴───────┴─────┴────────────────────────────────────────────────╯
+    begin_line | end_line | expr
+    -----------+----------+--------------------------------------------------------------------
+           345 |      354 | -1 (g{i_2,a_1;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2;i_1}:N-C-S
+           355 |      364 | -1 (f{i_2;a_2}:N-C-S * t{a_2;i_1}:N-C-S) * t{a_1;i_2}:N-C-S
+           366 |      373 | 2 g{i_2,a_1;a_2,i_1}:N-C-S * t{a_2;i_2}:N-C-S
+           375 |      382 | -2 g{i_2,i_3;a_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_3,i_2,i_1}:N-C-S
+           384 |      391 | 2 g{i_2,i_3;a_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_2,i_3}:N-C-S
 
-From this table we can identify which term did the particular evaluation step,
-or the cache interaction step belonged to. The ``expr`` column has the term printed out
-as a string that can be parsed by SeQuant. For example, the second last entry
-tells that the trace produced between the line numbers 23 and 30 belongs to
-the term ``-1 g{i_2,a_1;i_1,a_2}:N-C-S * t{a_2;i_2}:N-C-S``.
+The line numbers cross-reference into ``eval_rows`` and ``cache_rows``.
+For example, every evaluation step inside the first term:
 
-The evaluation steps that belong to this term are:
+.. code:: python
 
-.. code:: nu
+   first = term_rows[0]
+   inside = [r for r in eval_rows
+             if first.begin_line <= r.line <= first.end_line]
+   st.print_table(inside,
+                  columns=["mode","time_ns","result","alloc","hw","label","line"])
 
-   $eval | where line in 23..30
 ::
 
-    ╭───┬──────┬──────────┬───────────────────┬─────────┬───────────────────────────────────────────────┬──────╮
-    │ # │ tag0 │   tag1   │       time        │ memory  │                     annot                     │ line │
-    ├───┼──────┼──────────┼───────────────────┼─────────┼───────────────────────────────────────────────┼──────┤
-    │ 0 │ Eval │ Tensor   │ 688ms 998µs 813ns │ 88.7 MB │ g(i_2,a_1,i_1,a_2)                            │   24 │
-    │ 1 │ Eval │ Tensor   │         2µs 424ns │ 36.7 kB │ t(a_2,i_2)                                    │   25 │
-    │ 2 │ Eval │ Product  │  31ms 669µs 619ns │ 88.8 MB │ g(i_2,a_1,i_1,a_2) * t(a_2,i_2) -> I(a_1,i_1) │   26 │
-    │ 3 │ Eval │ Constant │         1µs 553ns │     8 B │ {{{-1}}}                                      │   27 │
-    │ 4 │ Eval │ Product  │       181µs 701ns │ 73.5 kB │ I(a_1,i_1) * {{{-1}}} -> I(a_1,i_1)           │   28 │
-    │ 5 │ Eval │ Permute  │    1ms 18µs 213ns │ 73.5 kB │ I(a_1,i_1)                                    │   29 │
-    ╰───┴──────┴──────────┴───────────────────┴─────────┴───────────────────────────────────────────────┴──────╯
+    mode     | time_ns   | result    | alloc     | hw        | label                                         | line
+    ---------+-----------+-----------+-----------+-----------+-----------------------------------------------+-----
+    Tensor   | 412107750 | 163879224 | 163879224 | 163879224 | g(i_2,a_1,a_2,a_3)                            |  346
+    Tensor   |      1291 |       640 |       640 |       640 | t(a_3,i_2)                                    |  347
+    Product  |   3307083 |      4992 |      4992 | 163884856 | g(i_2,a_1,a_2,a_3) * t(a_3,i_2) -> I(a_1,a_2) |  348
+    Tensor   |       750 |       640 |       640 |       640 | t(a_2,i_1)                                    |  349
+    Product  |     68917 |       640 |       640 |      6272 | I(a_1,a_2) * t(a_2,i_1) -> I(a_1,i_1)         |  350
+    Constant |       541 |         8 |         8 |         8 | -1                                            |  351
+    Product  |     31625 |       640 |       640 |      1288 | I(a_1,i_1) * -1 -> I(a_1,i_1)                 |  352
+    Permute  |     11625 |       640 |       640 |      1280 | I(a_1,i_1)                                    |  353
+
+The reverse lookup also works. Earlier we found that the peak cache
+footprint was reached at line 2026; the term responsible is:
 
-We can also go in reverse. We saw from the result of ``$cache | first 5`` that an
-intermediate of ~6.8 MB size is stored to the cache at line number 116. We can find
-out what term produced this intermediate.
+.. code:: python
 
-.. code:: nu
+   owner = next(t for t in term_rows
+                if t.begin_line <= peak.line <= t.end_line)
+   st.print_table([owner], columns=["begin_line","end_line","expr"])
 
-   $term | where begin < 116 | where end > 116
 ::
 
-    ╭───┬──────┬───────┬─────┬──────────────────────────────────────────────────────────────────────────╮
-    │ # │ tag0 │ begin │ end │                                   expr                                   │
-    ├───┼──────┼───────┼─────┼──────────────────────────────────────────────────────────────────────────┤
-    │ 0 │ Term │   112 │ 120 │ (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2;i_1}:N-C-S) * t{a_1,a_3;i_3,i_2}:N-C-S │
-    ╰───┴──────┴───────┴─────┴──────────────────────────────────────────────────────────────────────────╯
+    begin_line | end_line | expr
+    -----------+----------+--------------------------------------------------------------------------------------------------------
+          2022 |     2032 | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_2}:N-C-S) * t{a_1,a_4;i_1,i_3}:N-C-S) * t{a_2,a_3;i_5,i_4}:N-C-S
diff --git a/doc/user/guide/mpqc_out.txt b/doc/user/guide/mpqc_out.txt
index 763400f417..764d9b2cab 100644
--- a/doc/user/guide/mpqc_out.txt
+++ b/doc/user/guide/mpqc_out.txt
@@ -1,97 +1,63 @@
 
                      MPQC: Massively Parallel Quantum Chemistry
                                 Version 4.0.0-beta.1
-                 Revision 4d9dbd6775bc171b9f4671c5a3c1f24736f93b7a
+                 Revision 36f7f65c0a32857fb72193f8e2aa89f5b555cbc9
 
-  Machine:          Linux-5.14.21-150500.55.65_13.0.73-cray_shasta_c-x86_64
-  User:             bimalg@nid004179
-  Start Time:       Tue 15 Apr 2025 12:46:41 PM GMT GMT
-  Default World:    8 MPI processes
-  ThreadPool:       29 worker threads + 1 main thread + 1 communication thread [type = PaRSEC]
+  Machine:          Darwin-25.4.0-arm64
+  User:             bimal@his.macbook.local
+  Start Time:       Tue May 12 19:13:07 2026 UTC
+  Default World:    1 MPI process
+  ThreadPool:       7 worker threads + 1 main thread [type = PaRSEC]
 
   Input KeyVal (format=JSON):
   {
       "units": "2010CODATA",
-      "molecule": {
-          "type": "Molecule",
-          "file_name": "he16.xyz",
-          "charge": "0"
+      "atoms": {
+          "file_name": "C2H6.xyz",
+          "sort_input": "true",
+          "charge": "0",
+          "n_cluster": "1",
+          "tile_size": "4"
       },
       "obs": {
-          "type": "Basis",
           "name": "cc-pVTZ",
-          "molecule": "$:molecule"
+          "atoms": "$:atoms"
       },
       "dfbs": {
-          "type": "Basis",
           "name": "cc-pVTZ-RI",
-          "molecule": "$:molecule"
+          "atoms": "$:atoms"
       },
       "wfn_world": {
-          "molecule": "$:molecule",
+          "atoms": "$:atoms",
           "basis": "$:obs",
           "df_basis": "$:dfbs"
       },
-      "localizer": {
-          "type": "FBLocalizer",
-          "max_iter": "1000",
-          "convergence": "1e-5",
-          "wfn_world": "$:wfn_world"
-      },
       "scf": {
           "type": "DirectDF-RHF",
-          "wfn_world": "$:wfn_world",
-          "localizer": "$:localizer"
-      },
-      "pno": {
-          "type": "PaoPnoRMP2",
-          "atoms": "$:atoms",
-          "wfn_world": "$:wfn_world",
-          "ref": "$:scf",
-          "unit_csv_tile_size": "true",
-          "use osvs": "true",
-          "tpno": "1e-7",
-          "tosv": "1e-9",
-          "tC": "1e-4",
-          "ldf integrals": "true",
-          "Fast E": "false",
-          "Fast Zir": "false",
-          "Fast Zia": "false",
-          "tSpao": "1e-8",
-          "tIA": "7e-4",
-          "tIX": "1e-4",
-          "tIJ": "1e-6",
-          "tRS": "1e-9",
-          "tFIJ": "1e-4"
+          "wfn_world": "$:wfn_world"
       },
       "wfn": {
           "type": "CCk",
-          "_csv": {
-              "provider": "$:pno",
-              "tIJ": "3e-5"
-          },
-          "method": "df",
           "wfn_world": "$:wfn_world",
-          "molecule": "$:molecule",
+          "atoms": "$:atoms",
+          "method": "df",
           "ref": "$:scf",
-          "localizer": "$:localizer",
+          "frozen_core": "true",
           "occ_tile_size": "4",
-          "uocc_tile_size": "50",
-          "tile_size": "200",
-          "export_orbitals": "false",
-          "max_iter": "50",
-          "seq_opt": "true",
-          "cache_imeds": "true",
-          "k": "2",
+          "uocc_tile_size": "4",
+          "k": "3",
+          "spinorbital": "false",
+          "max_iter": "1",
           "sequant": {
               "trace": {
-                  "eval": "true"
+                  "eval": "true",
+                  "eval_level": "1"
               }
           }
       },
       "property": {
           "type": "Energy",
-          "precision": "1e-7",
+          "precision": "1e-10",
           "wfn": "$:wfn"
       }
   }
@@ -101,259 +67,2363 @@
 
   Constructing Gaussian Basis Registry:
     OBS Basis = cc-pVTZ
-      ( tiles = [ 0, 16 ), elements = [ 0, 224 ) )
-      {min,max,mean} tile size = {14,14,14}
-      tile hashmarks: [0, 14, 28, 42, 56, 70, 84, 98, 112, 126, 140, 154, 168, 182, 196, 210, 224]
+      ( tiles = [ 0, 1 ), elements = [ 0, 144 ) )
+      {min,max,mean} tile size = {144,144,144}
+      tile hashmarks: [0, 144]
     DF Basis = cc-pVTZ-RI
-      ( tiles = [ 0, 16 ), elements = [ 0, 432 ) )
-      {min,max,mean} tile size = {27,27,27}
-      tile hashmarks: [0, 27, 54, 81, 108, 135, 162, 189, 216, 243, 270, 297, 324, 351, 378, 405, 432]
-    Minimum Basis = 
-      ( tiles = [ 0, 16 ), elements = [ 0, 16 ) )
-      {min,max,mean} tile size = {1,1,1}
-      tile hashmarks: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
+      ( tiles = [ 0, 1 ), elements = [ 0, 342 ) )
+      {min,max,mean} tile size = {342,342,342}
+      tile hashmarks: [0, 342]
+    Minimal Basis =
+      ( tiles = [ 0, 1 ), elements = [ 0, 16 ) )
+      {min,max,mean} tile size = {16,16,16}
+      tile hashmarks: [0, 16]
 
-  Constructing gaussian::AOFactory: 
+  Constructing gaussian::AOFactory:
   Screen = dist
   ScreenThreshold = 2.2204460492503131e-16
   Engine precision = 2.2204460492503131e-16
-  Orthogonalizer target condition number = 100,000,000
+  Orthogonalizer target condition number = 100000000
   Inverse square root method = cholesky_then_canonical
-
-  Constructing LCAOFactory: 
-  Keep partial transform = true
-  Accurate time = false
-  Verbose = false
-
-  frontier orbital energies (eV): -24.827 -24.819 -24.814 | 14.968 15.073 15.248 
-  Non-pivoted Jacobi solver for Foster-Boys localized MOs converged in 8 rotations [P=10,927.469772893877]
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.263[x2] -12.663 -11.251[x2] | 2.346 3.625 4.407[x2]
   Starting SCF:
-    Convergence target: 1.0000000000000001e-09
+    Convergence target: 9.9999999999999998e-13
     Maximum number of iterations: 30
-  nuclear repulsion energy = 26.876320609990355
-  frontier orbital energies (eV): -24.851 -24.842 -24.836 | 14.917 15.022 15.196 
-  Non-pivoted Jacobi solver for Foster-Boys localized MOs converged in 8 rotations [P=10,927.455620094319]
+  Nuclear repulsion energy  = 42.426887451907746
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.348[x2] -13.675 -13.149[x2] | 3.785 4.918 5.589[x2]
   iteration: 0
-    Energy: -45.778244437196832
-    abs(Energy Change): 0.019145770368311332
-    (Gradient Norm)/n^2: 3.9704954759758388e-07
-    Scf Time: 2.6048519689999998
-      Density Time: 0.35479997600000002
-      Fock Build Time: 2.1100216029999999
+    Energy: -79.241112371676877
+    abs(Energy Change): 0.98120958041111805
+    (Gradient Norm)/n^2: 2.3361490740876906e-05
+    Scf Time: 0.13299625000000001
+      Density Time: 0.0040018340000000001
+      Fock Build Time: 0.12873066599999999
     DFFockBuilder:
-      W time: 0.36845177699999998
-      J time: 0.46171980800000001
-      K time: 1.239954539
-      Total exchange time: 1.6084063159999999
-  frontier orbital energies (eV): -24.874 -24.865 -24.859 | 14.909 15.013 15.187 
-  Non-pivoted Jacobi solver for Foster-Boys localized MOs converged in 8 rotations [P=10,927.453271946077]
+      W time: 0.065888666999999998
+      J time: 0.061876166000000003
+      K time: 0.00078837500000000001
+      Total exchange time: 0.066677041999999992
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.368[x2] -13.911 -13.231[x2] | 3.821 4.984 5.629[x2]
   iteration: 1
-    Energy: -45.778741933915612
-    abs(Energy Change): 0.000497496718779189
-    (Gradient Norm)/n^2: 6.4140175796853832e-08
-    Scf Time: 2.5512959230000001
-      Density Time: 0.35205769999999997
-      Fock Build Time: 2.0599485820000001
+    Energy: -79.258060472690758
+    abs(Energy Change): 0.016948101013881001
+    (Gradient Norm)/n^2: 5.5418803657285932e-06
+    Scf Time: 0.132256334
+      Density Time: 0.0039773339999999999
+      Fock Build Time: 0.128084792
     DFFockBuilder:
-      W time: 0.37331315900000001
-      J time: 0.44726686300000001
-      K time: 1.1986652630000001
-      Total exchange time: 1.5719784220000002
-  frontier orbital energies (eV): -24.876 -24.867 -24.861 | 14.908 15.013 15.187 
-  Non-pivoted Jacobi solver for Foster-Boys localized MOs converged in 8 rotations [P=10,927.453300290477]
+      W time: 0.064552374999999995
+      J time: 0.062581165999999994
+      K time: 0.00082466699999999996
+      Total exchange time: 0.065377041999999996
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.277[x2] -13.799 -13.165[x2] | 3.845 5.001 5.655[x2]
   iteration: 2
-    Energy: -45.778756208571679
-    abs(Energy Change): 1.4274656066959324e-05
-    (Gradient Norm)/n^2: 1.8409428346301774e-09
-    Scf Time: 2.5192797050000002
-      Density Time: 0.37876752600000002
-      Fock Build Time: 2.0126905079999999
+    Energy: -79.259367433448318
+    abs(Energy Change): 0.0013069607575602049
+    (Gradient Norm)/n^2: 1.0759232909075424e-06
+    Scf Time: 0.13396708299999999
+      Density Time: 0.0040747500000000002
+      Fock Build Time: 0.12969083300000001
     DFFockBuilder:
-      W time: 0.36833837899999999
-      J time: 0.44135681799999998
-      K time: 1.1565475700000001
-      Total exchange time: 1.5248859490000002
-  frontier orbital energies (eV): -24.876 -24.867 -24.861 | 14.908 15.013 15.187 
-  Non-pivoted Jacobi solver for Foster-Boys localized MOs converged in 8 rotations [P=10,927.453301642196]
+      W time: 0.065899625000000003
+      J time: 0.062861209000000001
+      K time: 0.00082129100000000003
+      Total exchange time: 0.066720916000000005
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.305[x2] -13.847 -13.193[x2] | 3.839 4.996 5.650[x2]
   iteration: 3
-    Energy: -45.778756218118303
-    abs(Energy Change): 9.5466248239972629e-09
-    (Gradient Norm)/n^2: 9.396762071992351e-11
-    Scf Time: 2.4946104519999999
-      Density Time: 0.36997132700000002
-      Fock Build Time: 2.0005540380000002
+    Energy: -79.259413440696335
+    abs(Energy Change): 4.6007248016621816e-05
+    (Gradient Norm)/n^2: 3.2505997460042718e-07
+    Scf Time: 0.132698292
+      Density Time: 0.0041783749999999998
+      Fock Build Time: 0.128319458
     DFFockBuilder:
-      W time: 0.36399125700000001
-      J time: 0.44502908899999999
-      K time: 1.153224512
-      Total exchange time: 1.5172157689999999
+      W time: 0.064819834000000007
+      J time: 0.062570041000000007
+      K time: 0.00081137500000000003
+      Total exchange time: 0.06563120900000001
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.303[x2] -13.847 -13.192[x2] | 3.839 4.996 5.650[x2]
   iteration: 4
-    Energy: -45.77875621814475
-    abs(Energy Change): 2.6446400624990929e-11
-    (Gradient Norm)/n^2: 1.3771901327265616e-12
-    Scf Time: 2.1723524869999999
-      Fock Build Time: 2.0379874509999998
+    Energy: -79.259418514729703
+    abs(Energy Change): 5.0740333676912996e-06
+    (Gradient Norm)/n^2: 4.2868448065302767e-08
+    Scf Time: 0.13191512499999999
+      Density Time: 0.0041627089999999997
+      Fock Build Time: 0.12751599999999999
+    DFFockBuilder:
+      W time: 0.064078499999999997
+      J time: 0.062510167000000005
+      K time: 0.00079045799999999996
+      Total exchange time: 0.06486895799999999
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.304[x2] -13.848 -13.193[x2] | 3.839 4.996 5.650[x2]
+  iteration: 5
+    Energy: -79.259418669032812
+    abs(Energy Change): 1.5430310895681032e-07
+    (Gradient Norm)/n^2: 1.0064416178002255e-08
+    Scf Time: 0.131401875
+      Density Time: 0.0041764999999999997
+      Fock Build Time: 0.12702212500000001
+    DFFockBuilder:
+      W time: 0.063797959000000001
+      J time: 0.062334291
+      K time: 0.00078995900000000002
+      Total exchange time: 0.064587918000000008
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.304[x2] -13.848 -13.193[x2] | 3.839 4.996 5.650[x2]
+  iteration: 6
+    Energy: -79.259418673601616
+    abs(Energy Change): 4.5688040017921594e-09
+    (Gradient Norm)/n^2: 1.3063937879718927e-09
+    Scf Time: 0.13372387499999999
+      Density Time: 0.0037444169999999999
+      Fock Build Time: 0.12977266600000001
+    DFFockBuilder:
+      W time: 0.064880959000000002
+      J time: 0.064001583000000001
+      K time: 0.00078162499999999998
+      Total exchange time: 0.065662583999999996
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.304[x2] -13.848 -13.193[x2] | 3.839 4.996 5.650[x2]
+  iteration: 7
+    Energy: -79.25941867367483
+    abs(Energy Change): 7.3214323492720723e-11
+    (Gradient Norm)/n^2: 1.6175222251916475e-10
+    Scf Time: 0.13170870800000001
+      Density Time: 0.0042350829999999997
+      Fock Build Time: 0.1272355
+    DFFockBuilder:
+      W time: 0.063850624999999994
+      J time: 0.062519624999999995
+      K time: 0.00075100000000000004
+      Total exchange time: 0.064601624999999996
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.304[x2] -13.848 -13.193[x2] | 3.839 4.996 5.650[x2]
+  iteration: 8
+    Energy: -79.259418673676819
+    abs(Energy Change): 1.9895196601282805e-12
+    (Gradient Norm)/n^2: 3.4450983965491415e-11
+    Scf Time: 0.13197445799999999
+      Density Time: 0.0040665420000000002
+      Fock Build Time: 0.12769329099999999
+    DFFockBuilder:
+      W time: 0.064155749999999998
+      J time: 0.062649750000000004
+      K time: 0.00078708300000000005
+      Total exchange time: 0.064942832999999991
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.304[x2] -13.848 -13.193[x2] | 3.839 4.996 5.650[x2]
+  iteration: 9
+    Energy: -79.259418673675569
+    abs(Energy Change): 1.2505552149377763e-12
+    (Gradient Norm)/n^2: 8.9666302602031637e-12
+    Scf Time: 0.13067895800000001
+      Density Time: 0.0040773329999999998
+      Fock Build Time: 0.12641337499999999
     DFFockBuilder:
-      W time: 0.39302941299999999
-      J time: 0.43065620700000001
-      K time: 1.1721870430000001
-      Total exchange time: 1.5652164560000001
+      W time: 0.063781667
+      J time: 0.061928833000000003
+      K time: 0.00060670899999999998
+      Total exchange time: 0.064388375999999997
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.304[x2] -13.848 -13.193[x2] | 3.839 4.996 5.650[x2]
+  iteration: 10
+    Energy: -79.259418673677942
+    abs(Energy Change): 2.3732127374387346e-12
+    (Gradient Norm)/n^2: 3.1882037429291646e-12
+    Scf Time: 0.13079970799999999
+      Density Time: 0.0040713750000000003
+      Fock Build Time: 0.12653283300000001
+    DFFockBuilder:
+      W time: 0.063622291999999997
+      J time: 0.062021290999999999
+      K time: 0.00079408400000000002
+      Total exchange time: 0.064416375999999997
+  WARNING: Degenerate HOMO detected! Consider enabling ensemble_scf=true
+  frontier orbital energies (eV): -16.304[x2] -13.848 -13.193[x2] | 3.839 4.996 5.650[x2]
+  iteration: 11
+    Energy: -79.259418673676919
+    abs(Energy Change): 1.0231815394945443e-12
+    (Gradient Norm)/n^2: 4.9229814983590943e-13
+    Scf Time: 0.13097204200000001
+      Density Time: 0.0040855839999999997
+      Fock Build Time: 0.12667266699999999
+    DFFockBuilder:
+      W time: 0.063733916000000002
+      J time: 0.062120042
+      K time: 0.00071662500000000003
+      Total exchange time: 0.064450541
+  iteration: 12
+    Energy: -79.259418673676848
+    abs(Energy Change): 7.1054273576010019e-14
+    (Gradient Norm)/n^2: 1.8872129369060349e-13
+    Scf Time: 0.127297875
+      Fock Build Time: 0.127115375
+    DFFockBuilder:
+      W time: 0.063785999999999995
+      J time: 0.062448792000000003
+      K time: 0.00078474999999999997
+      Total exchange time: 0.064570749999999996
+
+  Dipole Moment (atomic units)
+  ------------------------------------------------------------
+    Component     Electronic      Nuclear        Total
+  ------------------------------------------------------------
+    X                0.000002    -0.000002     0.000000
+    Y               -0.000001     0.000001    -0.000000
+    Z               -0.000000     0.000000    -0.000000
+  ------------------------------------------------------------
+    Magnitude                                 0.000000
+
   SP spaces:
-    Non-pivoted Jacobi solver for Foster-Boys localized MOs converged in 9 rotations [P=10,927.453301642192]
+    frozen_occupied
+      ( tiles = [ 0, 1 ), elements = [ 0, 2 ) )
+      {min,max,mean} tile size = {2,2,2}
+      tile hashmarks: [0, 2]
     active_occupied
-      ( tiles = [ 0, 4 ), elements = [ 0, 16 ) )
-      {min,max,mean} tile size = {3,5,4}
-      tile hashmarks: [0, 4, 9, 12, 16]
-    total_occupied
-      ( tiles = [ 0, 4 ), elements = [ 0, 16 ) )
-      {min,max,mean} tile size = {3,5,4}
-      tile hashmarks: [0, 4, 9, 12, 16]
+      ( tiles = [ 0, 2 ), elements = [ 2, 9 ) )
+      {min,max,mean} tile size = {3,4,3}
+      tile hashmarks: [2, 6, 9]
     occupied
-      ( tiles = [ 0, 4 ), elements = [ 0, 16 ) )
-      {min,max,mean} tile size = {4,4,4}
-      tile hashmarks: [0, 4, 8, 12, 16]
-    frozen_unoccupied
-      ( tiles = [ 0, 0 ), elements = [ 224, 224 ) )
+      ( tiles = [ 0, 3 ), elements = [ 0, 9 ) )
+      {min,max,mean} tile size = {3,3,3}
+      tile hashmarks: [0, 3, 6, 9]
+    total_occupied
+      ( tiles = [ 0, 3 ), elements = [ 0, 9 ) )
+      {min,max,mean} tile size = {2,4,3}
+      tile hashmarks: [0, 2, 6, 9]
     active_unoccupied
-      ( tiles = [ 0, 5 ), elements = [ 16, 224 ) )
-      {min,max,mean} tile size = {41,42,41}
-      tile hashmarks: [16, 58, 100, 142, 183, 224]
-    total_unoccupied
-      ( tiles = [ 0, 5 ), elements = [ 16, 224 ) )
-      {min,max,mean} tile size = {41,42,41}
-      tile hashmarks: [16, 58, 100, 142, 183, 224]
+      ( tiles = [ 0, 34 ), elements = [ 9, 144 ) )
+      {min,max,mean} tile size = {3,4,3}
+      tile hashmarks: [9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 144]
+    frozen_unoccupied
+      ( tiles = [ 0, 0 ), elements = [ 144, 144 ) )
     unoccupied
-      ( tiles = [ 0, 5 ), elements = [ 16, 224 ) )
-      {min,max,mean} tile size = {41,42,41}
-      tile hashmarks: [16, 58, 100, 142, 183, 224]
-    total_active_any
-      ( tiles = [ 0, 9 ), elements = [ 0, 224 ) )
-      {min,max,mean} tile size = {3,42,24}
-      tile hashmarks: [0, 4, 9, 12, 16, 58, 100, 142, 183, 224]
+      ( tiles = [ 0, 34 ), elements = [ 9, 144 ) )
+      {min,max,mean} tile size = {3,4,3}
+      tile hashmarks: [9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 144]
+    total_unoccupied
+      ( tiles = [ 0, 34 ), elements = [ 9, 144 ) )
+      {min,max,mean} tile size = {3,4,3}
+      tile hashmarks: [9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 144]
     active_any
-      ( tiles = [ 0, 5 ), elements = [ 0, 224 ) )
-      {min,max,mean} tile size = {44,45,44}
-      tile hashmarks: [0, 45, 90, 135, 180, 224]
-    total_any
-      ( tiles = [ 0, 9 ), elements = [ 0, 224 ) )
-      {min,max,mean} tile size = {3,42,24}
-      tile hashmarks: [0, 4, 9, 12, 16, 58, 100, 142, 183, 224]
+      ( tiles = [ 0, 36 ), elements = [ 2, 144 ) )
+      {min,max,mean} tile size = {3,4,3}
+      tile hashmarks: [2, 6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 141, 144]
+    total_active_any
+      ( tiles = [ 0, 36 ), elements = [ 2, 144 ) )
+      {min,max,mean} tile size = {3,4,3}
+      tile hashmarks: [2, 6, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 144]
+    possible_uocc
+      ( tiles = [ 0, 36 ), elements = [ 2, 144 ) )
+      {min,max,mean} tile size = {3,4,3}
+      tile hashmarks: [2, 6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 141, 144]
     any
-      ( tiles = [ 0, 5 ), elements = [ 0, 224 ) )
-      {min,max,mean} tile size = {44,45,44}
-      tile hashmarks: [0, 45, 90, 135, 180, 224]
+      ( tiles = [ 0, 36 ), elements = [ 0, 144 ) )
+      {min,max,mean} tile size = {4,4,4}
+      tile hashmarks: [0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144]
+    total_any
+      ( tiles = [ 0, 37 ), elements = [ 0, 144 ) )
+      {min,max,mean} tile size = {2,4,3}
+      tile hashmarks: [0, 2, 6, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 144]
   Using closed-shell CCk to calculate correlation energy.
-  Integral Prepare Time: 0.48107070699999999 sec.
+  Integral Prepare Time: 0.090955833999999999 sec.
   Initialized T_
-  CC R1 size: 26 time: 0.012 sec.
-  CC R2 size: 55 time: 0.091 sec.
-  Max Iteration: 50
-  Target precision: 9.9999999999999995e-08
+  CC R1 size: 30 time: 0.004 sec.
+  CC R2 size: 73 time: 0.024 sec.
+  CC R3 size: 93 time: 0.248 sec.
+  Max Iteration: 1
+  Target precision: 1e-10
   AccurateTime: 0
   Verbose: 0
-  iter         delta      residual             energy    total time/s 
-    1    7.63507e-01    1.92479e-07   -0.763507207764          18.4
-    2    1.51102e-01    7.83937e-08   -0.612404930394          12.5
-    3    7.34063e-02    4.53847e-08   -0.685811254423          14.5
-    4    1.32819e-02    2.35135e-08   -0.672529350911          14.4
-    5    2.14434e-02    9.65914e-09   -0.651085930019          14.4
-    6    1.63231e-02    3.80617e-09   -0.634762864486          14.2
-    7    4.15878e-03    1.77067e-09   -0.630604089211          14.3
-    8    9.67438e-04    1.02665e-09   -0.629636651363          14.3
-    9    2.05167e-04    6.85702e-10   -0.629431484342          14.4
-   10    6.03583e-05    4.02560e-10   -0.629371126047          14.4
-   11    5.49322e-05    1.89934e-10   -0.629316193799          14.5
-   12    1.19413e-05    8.06262e-11   -0.629304252548          14.2
-   13    2.89066e-07    3.73656e-11   -0.629303963481          14.2
-   14    7.88708e-09    1.87705e-11   -0.629303955594          14.3
-  CCk Energy  -0.62930395559402297
-  Time in CCk: 217.55428529299999 S
+  Term | Begin | -1 (g{i_2,a_1;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2;i_1}:N-C-S
+  Eval | Tensor | 412107750ns | result=163879224B | alloc=163879224B | hw=163879224B | g(i_2,a_1,a_2,a_3)
+  Eval | Tensor | 1291ns | result=640B | alloc=640B | hw=640B | t(a_3,i_2)
+  Eval | Product | 3307083ns | left=163879224B | right=640B | result=4992B | alloc=4992B | hw=163884856B | g(i_2,a_1,a_2,a_3) * t(a_3,i_2) -> I(a_1,a_2)
+  Eval | Tensor | 750ns | result=640B | alloc=640B | hw=640B | t(a_2,i_1)
+  Eval | Product | 68917ns | left=4992B | right=640B | result=640B | alloc=640B | hw=6272B | I(a_1,a_2) * t(a_2,i_1) -> I(a_1,i_1)
+  Eval | Constant | 541ns | result=8B | alloc=8B | hw=8B | -1
+  Eval | Product | 31625ns | left=640B | right=8B | result=640B | alloc=640B | hw=1288B | I(a_1,i_1) * -1 -> I(a_1,i_1)
+  Eval | Permute | 11625ns | result=640B | alloc=640B | hw=1280B | I(a_1,i_1)
+  Term | End | -1 (g{i_2,a_1;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2;i_1}:N-C-S
+  Term | Begin | -1 (f{i_2;a_2}:N-C-S * t{a_2;i_1}:N-C-S) * t{a_1;i_2}:N-C-S
+  Eval | Tensor | 7708ns | result=30504B | alloc=30504B | hw=30504B | f(i_2,a_2)
+  Eval | Tensor | 291ns | result=640B | alloc=640B | hw=640B | t(a_2,i_1)
+  Eval | Product | 38291ns | left=30504B | right=640B | result=384B | alloc=384B | hw=31528B | f(i_2,a_2) * t(a_2,i_1) -> I(i_2,i_1)
+  Eval | Tensor | 166ns | result=640B | alloc=640B | hw=640B | t(a_1,i_2)
+  Eval | Product | 24667ns | left=384B | right=640B | result=640B | alloc=640B | hw=1664B | I(i_2,i_1) * t(a_1,i_2) -> I(a_1,i_1)
+  Eval | Constant | 125ns | result=8B | alloc=8B | hw=8B | -1
+  Eval | Product | 8458ns | left=640B | right=8B | result=640B | alloc=640B | hw=1288B | I(a_1,i_1) * -1 -> I(a_1,i_1)
+  Eval | Permute | 13500ns | result=640B | alloc=640B | hw=1280B | I(a_1,i_1)
+  Term | End | -1 (f{i_2;a_2}:N-C-S * t{a_2;i_1}:N-C-S) * t{a_1;i_2}:N-C-S
+  Eval | SumInplace | 22375ns | result=640B | alloc=0B | hw=1280B | I(a_1,i_1)
+  Term | Begin | 2 g{i_2,a_1;a_2,i_1}:N-C-S * t{a_2;i_2}:N-C-S
+  Eval | Tensor | 15695250ns | result=8679736B | alloc=8679736B | hw=8679736B | g(i_2,a_1,a_2,i_1)
+  Eval | Tensor | 250ns | result=640B | alloc=640B | hw=640B | t(a_2,i_2)
+  Eval | Product | 284708ns | left=8679736B | right=640B | result=640B | alloc=640B | hw=8681016B | g(i_2,a_1,a_2,i_1) * t(a_2,i_2) -> I(a_1,i_1)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=8B | 2
+  Eval | Product | 9667ns | left=640B | right=8B | result=640B | alloc=640B | hw=1288B | I(a_1,i_1) * 2 -> I(a_1,i_1)
+  Eval | Permute | 9375ns | result=640B | alloc=640B | hw=1280B | I(a_1,i_1)
+  Term | End | 2 g{i_2,a_1;a_2,i_1}:N-C-S * t{a_2;i_2}:N-C-S
+  Eval | SumInplace | 16917ns | result=640B | alloc=0B | hw=1280B | I(a_1,i_1)
+  Term | Begin | -2 g{i_2,i_3;a_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_3,i_2,i_1}:N-C-S
+  Eval | Tensor | 14096417ns | result=8679736B | alloc=8679736B | hw=8679736B | g(i_2,i_3,a_2,a_3)
+  Eval | Tensor | 625ns | result=1258096B | alloc=1258096B | hw=1258096B | t(a_1,a_2,a_3,i_3,i_2,i_1)
+  Eval | Product | 15987875ns | left=8679736B | right=1258096B | result=640B | alloc=640B | hw=9938472B | g(i_2,i_3,a_2,a_3) * t(a_1,a_2,a_3,i_3,i_2,i_1) -> I(a_1,i_1)
+  Eval | Constant | 417ns | result=8B | alloc=8B | hw=8B | -2
+  Eval | Product | 10417ns | left=640B | right=8B | result=640B | alloc=640B | hw=1288B | I(a_1,i_1) * -2 -> I(a_1,i_1)
+  Eval | Permute | 10375ns | result=640B | alloc=640B | hw=1280B | I(a_1,i_1)
+  Term | End | -2 g{i_2,i_3;a_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_3,i_2,i_1}:N-C-S
+  Eval | SumInplace | 22667ns | result=640B | alloc=0B | hw=1280B | I(a_1,i_1)
+  Term | Begin | 2 g{i_2,i_3;a_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_2,i_3}:N-C-S
+  Eval | Tensor | 9333ns | result=8679736B | alloc=8679736B | hw=8679736B | g(i_2,i_3,a_2,a_3)
+  Eval | Tensor | 167ns | result=1258096B | alloc=1258096B | hw=1258096B | t(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Product | 12939916ns | left=8679736B | right=1258096B | result=640B | alloc=640B | hw=9938472B | g(i_2,i_3,a_2,a_3) * t(a_1,a_2,a_3,i_1,i_2,i_3) -> I(a_1,i_1)
+  Eval | Constant | 583ns | result=8B | alloc=8B | hw=8B | 2
+  Eval | Product | 15166ns | left=640B | right=8B | result=640B | alloc=640B | hw=1288B | I(a_1,i_1) * 2 -> I(a_1,i_1)
+  Eval | Permute | 9958ns | result=640B | alloc=640B | hw=1280B | I(a_1,i_1)
+  Term | End | 2 g{i_2,i_3;a_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_2,i_3}:N-C-S
+  Eval | SumInplace | 25333ns | result=640B | alloc=0B | hw=1280B | I(a_1,i_1)
+  Term | Begin | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_3,i_1}:N-C-S
+  Eval | Tensor | 8792ns | result=8679736B | alloc=8679736B | hw=8679736B | g(i_2,i_3,a_2,a_3)
+  Eval | Tensor | 375ns | result=640B | alloc=640B | hw=640B | t(a_3,i_2)
+  Eval | Product | 257959ns | left=8679736B | right=640B | result=640B | alloc=640B | hw=8681016B | g(i_2,i_3,a_2,a_3) * t(a_3,i_2) -> I(i_3,a_2)
+  Cache | Store | key=13613060045528791584 | life=2/3 | alive=2 | entry=640B | total=640B | g(i_2,i_3,a_2,a_3) * t(a_3,i_2) -> I(i_3,a_2)
+  Eval | Tensor | 208ns | result=18864B | alloc=18864B | hw=19504B | t(a_1,a_2,i_3,i_1)
+  Eval | Product | 158209ns | left=640B | right=18864B | result=640B | alloc=640B | hw=20144B | I(i_3,a_2) * t(a_1,a_2,i_3,i_1) -> I(a_1,i_1)
+  Eval | Permute | 7084ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_3,i_1}:N-C-S
+  Eval | SumInplace | 20917ns | result=640B | alloc=0B | hw=1920B | I(a_1,i_1)
+  Term | Begin | -2 g{i_2,i_3;i_1,a_2}:N-C-S * t{a_1,a_2;i_2,i_3}:N-C-S
+  Eval | Tensor | 1988708ns | result=461112B | alloc=461112B | hw=461752B | g(i_2,i_3,i_1,a_2)
+  Eval | Tensor | 250ns | result=18864B | alloc=18864B | hw=19504B | t(a_1,a_2,i_2,i_3)
+  Eval | Product | 229083ns | left=461112B | right=18864B | result=640B | alloc=640B | hw=481256B | g(i_2,i_3,i_1,a_2) * t(a_1,a_2,i_2,i_3) -> I(a_1,i_1)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=648B | -2
+  Eval | Product | 11667ns | left=640B | right=8B | result=640B | alloc=640B | hw=1928B | I(a_1,i_1) * -2 -> I(a_1,i_1)
+  Eval | Permute | 12625ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | -2 g{i_2,i_3;i_1,a_2}:N-C-S * t{a_1,a_2;i_2,i_3}:N-C-S
+  Eval | SumInplace | 23750ns | result=640B | alloc=0B | hw=1920B | I(a_1,i_1)
+  Term | Begin | ((g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
+  Cache | Access | key=13613060045528791584 | life=1/3 | alive=1 | entry=640B | total=640B | g(i_2,i_3,a_2,a_3) * t(a_3,i_2) -> I(i_3,a_2)
+  Eval | Tensor | 166ns | result=640B | alloc=640B | hw=1280B | t(a_2,i_1)
+  Eval | Product | 21167ns | left=640B | right=640B | result=384B | alloc=384B | hw=1664B | I(i_3,a_2) * t(a_2,i_1) -> I(i_3,i_1)
+  Eval | Tensor | 42ns | result=640B | alloc=640B | hw=1280B | t(a_1,i_3)
+  Eval | Product | 20666ns | left=384B | right=640B | result=640B | alloc=640B | hw=2304B | I(i_3,i_1) * t(a_1,i_3) -> I(a_1,i_1)
+  Eval | Permute | 14000ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | ((g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | SumInplace | 16500ns | result=640B | alloc=0B | hw=1920B | I(a_1,i_1)
+  Term | Begin | 4 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_1,i_2}:N-C-S
+  Eval | Tensor | 5208ns | result=8679736B | alloc=8679736B | hw=8680376B | g(i_2,i_3,a_2,a_3)
+  Eval | Tensor | 250ns | result=640B | alloc=640B | hw=1280B | t(a_3,i_3)
+  Eval | Product | 235792ns | left=8679736B | right=640B | result=640B | alloc=640B | hw=8681656B | g(i_2,i_3,a_2,a_3) * t(a_3,i_3) -> I(i_2,a_2)
+  Cache | Store | key=12860816093799665187 | life=2/3 | alive=3 | entry=640B | total=1280B | g(i_2,i_3,a_2,a_3) * t(a_3,i_3) -> I(i_2,a_2)
+  Eval | Tensor | 84ns | result=18864B | alloc=18864B | hw=20144B | t(a_1,a_2,i_1,i_2)
+  Eval | Product | 148291ns | left=640B | right=18864B | result=640B | alloc=640B | hw=20784B | I(i_2,a_2) * t(a_1,a_2,i_1,i_2) -> I(a_1,i_1)
+  Eval | Constant | 167ns | result=8B | alloc=8B | hw=1288B | 4
+  Eval | Product | 9875ns | left=640B | right=8B | result=640B | alloc=640B | hw=2568B | I(a_1,i_1) * 4 -> I(a_1,i_1)
+  Eval | Permute | 12416ns | result=640B | alloc=640B | hw=2560B | I(a_1,i_1)
+  Term | End | 4 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_1,i_2}:N-C-S
+  Eval | SumInplace | 17583ns | result=640B | alloc=0B | hw=2560B | I(a_1,i_1)
+  Term | Begin | -2 ((g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_3;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
+  Cache | Access | key=12860816093799665187 | life=1/3 | alive=2 | entry=640B | total=1280B | g(i_2,i_3,a_2,a_3) * t(a_2,i_2) -> I(i_3,a_3)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=1920B | t(a_3,i_1)
+  Eval | Product | 18042ns | left=640B | right=640B | result=384B | alloc=384B | hw=2304B | I(i_3,a_3) * t(a_3,i_1) -> I(i_3,i_1)
+  Eval | Tensor | 83ns | result=640B | alloc=640B | hw=1920B | t(a_1,i_3)
+  Eval | Product | 29333ns | left=384B | right=640B | result=640B | alloc=640B | hw=2944B | I(i_3,i_1) * t(a_1,i_3) -> I(a_1,i_1)
+  Eval | Constant | 41ns | result=8B | alloc=8B | hw=1288B | -2
+  Eval | Product | 8208ns | left=640B | right=8B | result=640B | alloc=640B | hw=2568B | I(a_1,i_1) * -2 -> I(a_1,i_1)
+  Eval | Permute | 4833ns | result=640B | alloc=640B | hw=2560B | I(a_1,i_1)
+  Term | End | -2 ((g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_3;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | SumInplace | 12792ns | result=640B | alloc=0B | hw=2560B | I(a_1,i_1)
+  Term | Begin | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
+  Cache | Release | key=13613060045528791584 | life=0/3 | alive=1 | entry=0B | total=640B | g(i_2,i_3,a_2,a_3) * t(a_3,i_2) -> I(i_3,a_2)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=19504B | t(a_1,a_2,i_1,i_3)
+  Eval | Product | 182791ns | left=640B | right=18864B | result=640B | alloc=640B | hw=20784B | I(i_3,a_2) * t(a_1,a_2,i_1,i_3) -> I(a_1,i_1)
+  Eval | Constant | 42ns | result=8B | alloc=8B | hw=648B | -2
+  Eval | Product | 5875ns | left=640B | right=8B | result=640B | alloc=640B | hw=1928B | I(a_1,i_1) * -2 -> I(a_1,i_1)
+  Eval | Permute | 8167ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
+  Eval | SumInplace | 15667ns | result=640B | alloc=0B | hw=1920B | I(a_1,i_1)
+  Term | Begin | -2 (g{i_2,i_3;i_1,a_2}:N-C-S * t{a_2;i_3}:N-C-S) * t{a_1;i_2}:N-C-S
+  Eval | Tensor | 2833ns | result=461112B | alloc=461112B | hw=461752B | g(i_2,i_3,i_1,a_2)
+  Eval | Tensor | 42ns | result=640B | alloc=640B | hw=1280B | t(a_2,i_3)
+  Eval | Product | 54500ns | left=461112B | right=640B | result=384B | alloc=384B | hw=462776B | g(i_2,i_3,i_1,a_2) * t(a_2,i_3) -> I(i_2,i_1)
+  Eval | Tensor | 42ns | result=640B | alloc=640B | hw=1280B | t(a_1,i_2)
+  Eval | Product | 14125ns | left=384B | right=640B | result=640B | alloc=640B | hw=2304B | I(i_2,i_1) * t(a_1,i_2) -> I(a_1,i_1)
+  Eval | Constant | 83ns | result=8B | alloc=8B | hw=648B | -2
+  Eval | Product | 6042ns | left=640B | right=8B | result=640B | alloc=640B | hw=1928B | I(a_1,i_1) * -2 -> I(a_1,i_1)
+  Eval | Permute | 7834ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | -2 (g{i_2,i_3;i_1,a_2}:N-C-S * t{a_2;i_3}:N-C-S) * t{a_1;i_2}:N-C-S
+  Eval | SumInplace | 15833ns | result=640B | alloc=0B | hw=1920B | I(a_1,i_1)
+  Term | Begin | -1 f{i_2;i_1}:N-C-S * t{a_1;i_2}:N-C-S
+  Eval | Tensor | 1427333ns | result=2088B | alloc=2088B | hw=2728B | f(i_2,i_1)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=1280B | t(a_1,i_2)
+  Eval | Product | 19084ns | left=2088B | right=640B | result=640B | alloc=640B | hw=4008B | f(i_2,i_1) * t(a_1,i_2) -> I(a_1,i_1)
+  Eval | Constant | 166ns | result=8B | alloc=8B | hw=648B | -1
+  Eval | Product | 7542ns | left=640B | right=8B | result=640B | alloc=640B | hw=1928B | I(a_1,i_1) * -1 -> I(a_1,i_1)
+  Eval | Permute | 5916ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | -1 f{i_2;i_1}:N-C-S * t{a_1;i_2}:N-C-S
+  Eval | SumInplace | 18041ns | result=640B | alloc=0B | hw=1920B | I(a_1,i_1)
+  Term | Begin | -1 f{i_2;a_2}:N-C-S * t{a_1,a_2;i_2,i_1}:N-C-S
+  Eval | Tensor | 1792ns | result=30504B | alloc=30504B | hw=31144B | f(i_2,a_2)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=19504B | t(a_1,a_2,i_2,i_1)
+  Eval | Product | 212083ns | left=30504B | right=18864B | result=640B | alloc=640B | hw=50648B | f(i_2,a_2) * t(a_1,a_2,i_2,i_1) -> I(a_1,i_1)
+  Eval | Constant | 83ns | result=8B | alloc=8B | hw=648B | -1
+  Eval | Product | 5833ns | left=640B | right=8B | result=640B | alloc=640B | hw=1928B | I(a_1,i_1) * -1 -> I(a_1,i_1)
+  Eval | Permute | 6708ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | -1 f{i_2;a_2}:N-C-S * t{a_1,a_2;i_2,i_1}:N-C-S
+  Eval | SumInplace | 17792ns | result=640B | alloc=0B | hw=1920B | I(a_1,i_1)
+  Term | Begin | 2 (g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_3;i_1}:N-C-S
+  Eval | Tensor | 1625ns | result=163879224B | alloc=163879224B | hw=163879864B | g(i_2,a_1,a_2,a_3)
+  Eval | Tensor | 542ns | result=640B | alloc=640B | hw=1280B | t(a_2,i_2)
+  Eval | Product | 3145458ns | left=163879224B | right=640B | result=4992B | alloc=4992B | hw=163885496B | g(i_2,a_1,a_2,a_3) * t(a_2,i_2) -> I(a_1,a_3)
+  Eval | Tensor | 583ns | result=640B | alloc=640B | hw=1280B | t(a_3,i_1)
+  Eval | Product | 60125ns | left=4992B | right=640B | result=640B | alloc=640B | hw=6912B | I(a_1,a_3) * t(a_3,i_1) -> I(a_1,i_1)
+  Eval | Constant | 375ns | result=8B | alloc=8B | hw=648B | 2
+  Eval | Product | 8250ns | left=640B | right=8B | result=640B | alloc=640B | hw=1928B | I(a_1,i_1) * 2 -> I(a_1,i_1)
+  Eval | Permute | 19792ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | 2 (g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_3;i_1}:N-C-S
+  Eval | SumInplace | 19083ns | result=640B | alloc=0B | hw=1920B | I(a_1,i_1)
+  Term | Begin | -1 g{i_2,i_3;a_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_3,i_2}:N-C-S
+  Eval | Tensor | 6625ns | result=8679736B | alloc=8679736B | hw=8680376B | g(i_2,i_3,a_2,a_3)
+  Eval | Tensor | 292ns | result=1258096B | alloc=1258096B | hw=1258736B | t(a_1,a_2,a_3,i_1,i_3,i_2)
+  Eval | Product | 13194417ns | left=8679736B | right=1258096B | result=640B | alloc=640B | hw=9939112B | g(i_2,i_3,a_2,a_3) * t(a_1,a_2,a_3,i_1,i_3,i_2) -> I(a_1,i_1)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=648B | -1
+  Eval | Product | 6667ns | left=640B | right=8B | result=640B | alloc=640B | hw=1928B | I(a_1,i_1) * -1 -> I(a_1,i_1)
+  Eval | Permute | 10125ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | -1 g{i_2,i_3;a_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_3,i_2}:N-C-S
+  Eval | SumInplace | 21459ns | result=640B | alloc=0B | hw=1920B | I(a_1,i_1)
+  Term | Begin | f{a_1;i_1}:N-C-S
+  Eval | Tensor | 188209ns | result=30504B | alloc=30504B | hw=31144B | f(a_1,i_1)
+  Eval | Permute | 59000ns | result=30504B | alloc=30504B | hw=61648B | f(a_1,i_1)
+  Term | End | f{a_1;i_1}:N-C-S
+  Eval | SumInplace | 105750ns | result=30504B | alloc=0B | hw=61648B | f(a_1,i_1)
+  Term | Begin | g{i_2,i_3;i_1,a_2}:N-C-S * t{a_1,a_2;i_3,i_2}:N-C-S
+  Eval | Tensor | 4875ns | result=461112B | alloc=461112B | hw=461752B | g(i_2,i_3,i_1,a_2)
+  Eval | Tensor | 250ns | result=18864B | alloc=18864B | hw=19504B | t(a_1,a_2,i_3,i_2)
+  Eval | Product | 222125ns | left=461112B | right=18864B | result=640B | alloc=640B | hw=481256B | g(i_2,i_3,i_1,a_2) * t(a_1,a_2,i_3,i_2) -> I(a_1,i_1)
+  Eval | Permute | 6333ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | g{i_2,i_3;i_1,a_2}:N-C-S * t{a_1,a_2;i_3,i_2}:N-C-S
+  Eval | SumInplace | 83958ns | result=30504B | alloc=0B | hw=31784B | I(a_1,i_1)
+  Term | Begin | g{i_2,i_3;a_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_3,i_1,i_2}:N-C-S
+  Eval | Tensor | 2291ns | result=8679736B | alloc=8679736B | hw=8680376B | g(i_2,i_3,a_2,a_3)
+  Eval | Tensor | 167ns | result=1258096B | alloc=1258096B | hw=1258736B | t(a_1,a_2,a_3,i_3,i_1,i_2)
+  Eval | Product | 13599250ns | left=8679736B | right=1258096B | result=640B | alloc=640B | hw=9939112B | g(i_2,i_3,a_2,a_3) * t(a_1,a_2,a_3,i_3,i_1,i_2) -> I(a_1,i_1)
+  Eval | Permute | 6292ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | g{i_2,i_3;a_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_3,i_1,i_2}:N-C-S
+  Eval | SumInplace | 88791ns | result=30504B | alloc=0B | hw=31784B | I(a_1,i_1)
+  Term | Begin | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1,a_2;i_3,i_2}:N-C-S
+  Eval | Tensor | 3667ns | result=8679736B | alloc=8679736B | hw=8680376B | g(i_2,i_3,a_2,a_3)
+  Eval | Tensor | 250ns | result=640B | alloc=640B | hw=1280B | t(a_3,i_1)
+  Eval | Product | 240375ns | left=8679736B | right=640B | result=1456B | alloc=1456B | hw=8682472B | g(i_2,i_3,a_2,a_3) * t(a_3,i_1) -> I(i_3,i_2,i_1,a_2)
+  Cache | Store | key=6322769425051513756 | life=1/2 | alive=2 | entry=1456B | total=2096B | g(i_2,i_3,a_2,a_3) * t(a_3,i_1) -> I(i_3,i_2,i_1,a_2)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=20960B | t(a_1,a_2,i_3,i_2)
+  Eval | Product | 139750ns | left=1456B | right=18864B | result=640B | alloc=640B | hw=21600B | I(i_3,i_2,i_1,a_2) * t(a_1,a_2,i_3,i_2) -> I(a_1,i_1)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=2104B | -2
+  Eval | Product | 8833ns | left=640B | right=8B | result=640B | alloc=640B | hw=3384B | I(a_1,i_1) * -2 -> I(a_1,i_1)
+  Eval | Permute | 9416ns | result=640B | alloc=640B | hw=3376B | I(a_1,i_1)
+  Term | End | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1,a_2;i_3,i_2}:N-C-S
+  Eval | SumInplace | 115791ns | result=30504B | alloc=0B | hw=33240B | I(a_1,i_1)
+  Term | Begin | 2 f{i_2;a_2}:N-C-S * t{a_1,a_2;i_1,i_2}:N-C-S
+  Eval | Tensor | 195250ns | result=30504B | alloc=30504B | hw=32600B | f(i_2,a_2)
+  Eval | Tensor | 208ns | result=18864B | alloc=18864B | hw=20960B | t(a_1,a_2,i_1,i_2)
+  Eval | Product | 181542ns | left=30504B | right=18864B | result=640B | alloc=640B | hw=52104B | f(i_2,a_2) * t(a_1,a_2,i_1,i_2) -> I(a_1,i_1)
+  Eval | Constant | 42ns | result=8B | alloc=8B | hw=2104B | 2
+  Eval | Product | 9750ns | left=640B | right=8B | result=640B | alloc=640B | hw=3384B | I(a_1,i_1) * 2 -> I(a_1,i_1)
+  Eval | Permute | 5916ns | result=640B | alloc=640B | hw=3376B | I(a_1,i_1)
+  Term | End | 2 f{i_2;a_2}:N-C-S * t{a_1,a_2;i_1,i_2}:N-C-S
+  Eval | SumInplace | 91541ns | result=30504B | alloc=0B | hw=33240B | I(a_1,i_1)
+  Term | Begin | (g{i_2,i_3;i_1,a_2}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | Tensor | 1583ns | result=461112B | alloc=461112B | hw=463208B | g(i_2,i_3,i_1,a_2)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=2736B | t(a_2,i_2)
+  Eval | Product | 51417ns | left=461112B | right=640B | result=384B | alloc=384B | hw=464232B | g(i_2,i_3,i_1,a_2) * t(a_2,i_2) -> I(i_3,i_1)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=2736B | t(a_1,i_3)
+  Eval | Product | 14334ns | left=384B | right=640B | result=640B | alloc=640B | hw=3760B | I(i_3,i_1) * t(a_1,i_3) -> I(a_1,i_1)
+  Eval | Permute | 5292ns | result=640B | alloc=640B | hw=3376B | I(a_1,i_1)
+  Term | End | (g{i_2,i_3;i_1,a_2}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | SumInplace | 95459ns | result=30504B | alloc=0B | hw=33240B | I(a_1,i_1)
+  Term | Begin | -1 g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2,a_3;i_1,i_2}:N-C-S
+  Eval | Tensor | 1500ns | result=163879224B | alloc=163879224B | hw=163881320B | g(i_2,a_1,a_2,a_3)
+  Eval | Tensor | 542ns | result=18864B | alloc=18864B | hw=20960B | t(a_2,a_3,i_1,i_2)
+  Eval | Product | 3942292ns | left=163879224B | right=18864B | result=640B | alloc=640B | hw=163900824B | g(i_2,a_1,a_2,a_3) * t(a_2,a_3,i_1,i_2) -> I(a_1,i_1)
+  Eval | Constant | 458ns | result=8B | alloc=8B | hw=2104B | -1
+  Eval | Product | 21250ns | left=640B | right=8B | result=640B | alloc=640B | hw=3384B | I(a_1,i_1) * -1 -> I(a_1,i_1)
+  Eval | Permute | 14500ns | result=640B | alloc=640B | hw=3376B | I(a_1,i_1)
+  Term | End | -1 g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2,a_3;i_1,i_2}:N-C-S
+  Eval | SumInplace | 113375ns | result=30504B | alloc=0B | hw=33240B | I(a_1,i_1)
+  Term | Begin | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1,a_2;i_2,i_3}:N-C-S
+  Cache | Release | key=6322769425051513756 | life=0/2 | alive=1 | entry=0B | total=640B | g(i_2,i_3,a_2,a_3) * t(a_3,i_1) -> I(i_3,i_2,i_1,a_2)
+  Eval | Tensor | 458ns | result=18864B | alloc=18864B | hw=19504B | t(a_1,a_2,i_2,i_3)
+  Eval | Product | 166958ns | left=1456B | right=18864B | result=640B | alloc=640B | hw=21600B | I(i_3,i_2,i_1,a_2) * t(a_1,a_2,i_2,i_3) -> I(a_1,i_1)
+  Eval | Permute | 16459ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1,a_2;i_2,i_3}:N-C-S
+  Eval | SumInplace | 84458ns | result=30504B | alloc=0B | hw=31784B | I(a_1,i_1)
+  Term | Begin | -1 g{i_2,a_1;i_1,a_2}:N-C-S * t{a_2;i_2}:N-C-S
+  Eval | Tensor | 14960791ns | result=8679736B | alloc=8679736B | hw=8680376B | g(i_2,a_1,i_1,a_2)
+  Eval | Tensor | 709ns | result=640B | alloc=640B | hw=1280B | t(a_2,i_2)
+  Eval | Product | 282166ns | left=8679736B | right=640B | result=640B | alloc=640B | hw=8681656B | g(i_2,a_1,i_1,a_2) * t(a_2,i_2) -> I(a_1,i_1)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=648B | -1
+  Eval | Product | 12708ns | left=640B | right=8B | result=640B | alloc=640B | hw=1928B | I(a_1,i_1) * -1 -> I(a_1,i_1)
+  Eval | Permute | 11084ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | -1 g{i_2,a_1;i_1,a_2}:N-C-S * t{a_2;i_2}:N-C-S
+  Eval | SumInplace | 110667ns | result=30504B | alloc=0B | hw=31784B | I(a_1,i_1)
+  Term | Begin | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2,a_3;i_1,i_2}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | Tensor | 5250ns | result=8679736B | alloc=8679736B | hw=8680376B | g(i_2,i_3,a_2,a_3)
+  Eval | Tensor | 167ns | result=18864B | alloc=18864B | hw=19504B | t(a_2,a_3,i_1,i_2)
+  Eval | Product | 1122417ns | left=8679736B | right=18864B | result=384B | alloc=384B | hw=8699624B | g(i_2,i_3,a_2,a_3) * t(a_2,a_3,i_1,i_2) -> I(i_3,i_1)
+  Eval | Tensor | 84ns | result=640B | alloc=640B | hw=1280B | t(a_1,i_3)
+  Eval | Product | 22125ns | left=384B | right=640B | result=640B | alloc=640B | hw=2304B | I(i_3,i_1) * t(a_1,i_3) -> I(a_1,i_1)
+  Eval | Permute | 8625ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2,a_3;i_1,i_2}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | SumInplace | 99459ns | result=30504B | alloc=0B | hw=31784B | I(a_1,i_1)
+  Term | Begin | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2,a_3;i_2,i_1}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | Tensor | 2625ns | result=8679736B | alloc=8679736B | hw=8680376B | g(i_2,i_3,a_2,a_3)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=19504B | t(a_2,a_3,i_2,i_1)
+  Eval | Product | 1035000ns | left=8679736B | right=18864B | result=384B | alloc=384B | hw=8699624B | g(i_2,i_3,a_2,a_3) * t(a_2,a_3,i_2,i_1) -> I(i_3,i_1)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=1280B | t(a_1,i_3)
+  Eval | Product | 15792ns | left=384B | right=640B | result=640B | alloc=640B | hw=2304B | I(i_3,i_1) * t(a_1,i_3) -> I(a_1,i_1)
+  Eval | Constant | 166ns | result=8B | alloc=8B | hw=648B | -2
+  Eval | Product | 7583ns | left=640B | right=8B | result=640B | alloc=640B | hw=1928B | I(a_1,i_1) * -2 -> I(a_1,i_1)
+  Eval | Permute | 12250ns | result=640B | alloc=640B | hw=1920B | I(a_1,i_1)
+  Term | End | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2,a_3;i_2,i_1}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | SumInplace | 140084ns | result=30504B | alloc=0B | hw=31784B | I(a_1,i_1)
+  Term | Begin | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_2,i_1}:N-C-S
+  Cache | Release | key=12860816093799665187 | life=0/3 | alive=0 | entry=0B | total=0B | g(i_2,i_3,a_2,a_3) * t(a_3,i_3) -> I(i_2,a_2)
+  Eval | Tensor | 208ns | result=18864B | alloc=18864B | hw=18864B | t(a_1,a_2,i_2,i_1)
+  Eval | Product | 169000ns | left=640B | right=18864B | result=640B | alloc=640B | hw=20144B | I(i_2,a_2) * t(a_1,a_2,i_2,i_1) -> I(a_1,i_1)
+  Eval | Constant | 125ns | result=8B | alloc=8B | hw=8B | -2
+  Eval | Product | 7083ns | left=640B | right=8B | result=640B | alloc=640B | hw=1288B | I(a_1,i_1) * -2 -> I(a_1,i_1)
+  Eval | Permute | 9334ns | result=640B | alloc=640B | hw=1280B | I(a_1,i_1)
+  Term | End | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_2,i_1}:N-C-S
+  Eval | SumInplace | 75834ns | result=30504B | alloc=0B | hw=31144B | I(a_1,i_1)
+  Term | Begin | f{a_1;a_2}:N-C-S * t{a_2;i_1}:N-C-S
+  Eval | Tensor | 5187958ns | result=529960B | alloc=529960B | hw=529960B | f(a_1,a_2)
+  Eval | Tensor | 250ns | result=640B | alloc=640B | hw=640B | t(a_2,i_1)
+  Eval | Product | 75583ns | left=529960B | right=640B | result=640B | alloc=640B | hw=531240B | f(a_1,a_2) * t(a_2,i_1) -> I(a_1,i_1)
+  Eval | Permute | 5875ns | result=640B | alloc=640B | hw=1280B | I(a_1,i_1)
+  Term | End | f{a_1;a_2}:N-C-S * t{a_2;i_1}:N-C-S
+  Eval | SumInplace | 95833ns | result=30504B | alloc=0B | hw=31144B | I(a_1,i_1)
+  Term | Begin | 2 g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2,a_3;i_2,i_1}:N-C-S
+  Eval | Tensor | 2625ns | result=163879224B | alloc=163879224B | hw=163879224B | g(i_2,a_1,a_2,a_3)
+  Eval | Tensor | 1417ns | result=18864B | alloc=18864B | hw=18864B | t(a_2,a_3,i_2,i_1)
+  Eval | Product | 4265042ns | left=163879224B | right=18864B | result=640B | alloc=640B | hw=163898728B | g(i_2,a_1,a_2,a_3) * t(a_2,a_3,i_2,i_1) -> I(a_1,i_1)
+  Eval | Constant | 542ns | result=8B | alloc=8B | hw=8B | 2
+  Eval | Product | 17375ns | left=640B | right=8B | result=640B | alloc=640B | hw=1288B | I(a_1,i_1) * 2 -> I(a_1,i_1)
+  Eval | Permute | 13625ns | result=640B | alloc=640B | hw=1280B | I(a_1,i_1)
+  Term | End | 2 g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2,a_3;i_2,i_1}:N-C-S
+  Eval | SumInplace | 83584ns | result=30504B | alloc=0B | hw=31144B | I(a_1,i_1)
+  Eval | Symmetrize | 151458ns | result=30504B | alloc=30504B | hw=61008B | I(a_1,i_1)
+  Term | Begin | -4 g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_3,i_4}:N-C-S
+  Eval | Tensor | 11208ns | result=461112B | alloc=461112B | hw=461112B | g(i_3,i_4,i_2,a_3)
+  Eval | Tensor | 333ns | result=1258096B | alloc=1258096B | hw=1258096B | t(a_1,a_2,a_3,i_1,i_3,i_4)
+  Eval | Product | 11885416ns | left=461112B | right=1258096B | result=18864B | alloc=18864B | hw=1738072B | g(i_3,i_4,i_2,a_3) * t(a_1,a_2,a_3,i_1,i_3,i_4) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 750ns | result=8B | alloc=8B | hw=8B | -4
+  Eval | Product | 152834ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=37736B | I(a_1,a_2,i_1,i_2) * -4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 141417ns | result=18864B | alloc=18864B | hw=37728B | I(a_1,a_2,i_1,i_2)
+  Term | End | -4 g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_3,i_4}:N-C-S
+  Term | Begin | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_3,i_2}:N-C-S) * t{a_2,a_3;i_4,i_1}:N-C-S
+  Eval | Tensor | 6459ns | result=8679736B | alloc=8679736B | hw=8679736B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 375ns | result=18864B | alloc=18864B | hw=18864B | t(a_1,a_4,i_3,i_2)
+  Eval | Product | 465292ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8717464B | g(i_3,i_4,a_3,a_4) * t(a_1,a_4,i_3,i_2) -> I(i_4,a_1,i_2,a_3)
+  Cache | Store | key=13982275274528923534 | life=1/2 | alive=1 | entry=18864B | total=18864B | g(i_3,i_4,a_3,a_4) * t(a_1,a_4,i_3,i_2) -> I(i_4,a_1,i_2,a_3)
+  Eval | Tensor | 84ns | result=18864B | alloc=18864B | hw=37728B | t(a_2,a_3,i_4,i_1)
+  Eval | Product | 358042ns | left=18864B | right=18864B | result=18864B | alloc=18864B | hw=56592B | I(i_4,a_1,i_2,a_3) * t(a_2,a_3,i_4,i_1) -> I(a_2,a_1,i_1,i_2)
+  Eval | Permute | 171083ns | result=18864B | alloc=18864B | hw=56592B | I(a_2,a_1,i_1,i_2)
+  Term | End | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_3,i_2}:N-C-S) * t{a_2,a_3;i_4,i_1}:N-C-S
+  Eval | SumInplace | 366875ns | result=18864B | alloc=0B | hw=56592B | I(a_2,a_1,i_1,i_2)
+  Term | Begin | 2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1,a_4;i_3,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | Tensor | 2750ns | result=8679736B | alloc=8679736B | hw=8698600B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 500ns | result=640B | alloc=640B | hw=19504B | t(a_3,i_1)
+  Eval | Product | 234875ns | left=8679736B | right=640B | result=1456B | alloc=1456B | hw=8700696B | g(i_3,i_4,a_3,a_4) * t(a_3,i_1) -> I(i_3,i_4,i_1,a_4)
+  Cache | Store | key=6322769425051513756 | life=7/8 | alive=8 | entry=1456B | total=20320B | g(i_3,i_4,a_3,a_4) * t(a_3,i_1) -> I(i_3,i_4,i_1,a_4)
+  Eval | Tensor | 333ns | result=18864B | alloc=18864B | hw=39184B | t(a_1,a_4,i_3,i_2)
+  Eval | Product | 157709ns | left=1456B | right=18864B | result=1456B | alloc=1456B | hw=40640B | I(i_3,i_4,i_1,a_4) * t(a_1,a_4,i_3,i_2) -> I(i_4,a_1,i_2,i_1)
+  Eval | Tensor | 83ns | result=640B | alloc=640B | hw=20960B | t(a_2,i_4)
+  Eval | Product | 124291ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=41280B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_2,a_1,i_1,i_2)
+  Eval | Constant | 125ns | result=8B | alloc=8B | hw=20328B | 2
+  Eval | Product | 172542ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=58056B | I(a_2,a_1,i_1,i_2) * 2 -> I(a_2,a_1,i_1,i_2)
+  Eval | Permute | 159625ns | result=18864B | alloc=18864B | hw=58048B | I(a_2,a_1,i_1,i_2)
+  Term | End | 2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1,a_4;i_3,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | SumInplace | 395417ns | result=18864B | alloc=0B | hw=58048B | I(a_2,a_1,i_1,i_2)
+  Term | Begin | 2 (g{i_3,i_4;i_1,a_3}:N-C-S * t{a_1,a_3;i_3,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | Tensor | 3834ns | result=461112B | alloc=461112B | hw=481432B | g(i_3,i_4,i_1,a_3)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=39184B | t(a_1,a_3,i_3,i_2)
+  Eval | Product | 207125ns | left=461112B | right=18864B | result=1456B | alloc=1456B | hw=501752B | g(i_3,i_4,i_1,a_3) * t(a_1,a_3,i_3,i_2) -> I(i_4,a_1,i_2,i_1)
+  Eval | Tensor | 83ns | result=640B | alloc=640B | hw=20960B | t(a_2,i_4)
+  Eval | Product | 125791ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=41280B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 84ns | result=8B | alloc=8B | hw=20328B | 2
+  Eval | Product | 168458ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=58056B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 159459ns | result=18864B | alloc=18864B | hw=58048B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;i_1,a_3}:N-C-S * t{a_1,a_3;i_3,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | SumInplace | 390417ns | result=18864B | alloc=0B | hw=58048B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_1,i_4,i_2}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | Tensor | 1875ns | result=8679736B | alloc=8679736B | hw=8700056B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 292ns | result=1258096B | alloc=1258096B | hw=1278416B | t(a_1,a_3,a_4,i_1,i_4,i_2)
+  Eval | Product | 15815417ns | left=8679736B | right=1258096B | result=1456B | alloc=1456B | hw=9959608B | g(i_3,i_4,a_3,a_4) * t(a_1,a_3,a_4,i_1,i_4,i_2) -> I(i_3,a_1,i_2,i_1)
+  Eval | Tensor | 292ns | result=640B | alloc=640B | hw=20960B | t(a_2,i_3)
+  Eval | Product | 110916ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=41280B | I(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 375ns | result=8B | alloc=8B | hw=20328B | 2
+  Eval | Product | 196917ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=58056B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 166459ns | result=18864B | alloc=18864B | hw=58048B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_1,i_4,i_2}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | SumInplace | 378000ns | result=18864B | alloc=0B | hw=58048B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_4,i_1}:N-C-S) * t{a_1,a_2;i_3,i_2}:N-C-S
+  Eval | Tensor | 5542ns | result=8679736B | alloc=8679736B | hw=8700056B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 167ns | result=18864B | alloc=18864B | hw=39184B | t(a_3,a_4,i_4,i_1)
+  Eval | Product | 985958ns | left=8679736B | right=18864B | result=384B | alloc=384B | hw=8719304B | g(i_3,i_4,a_3,a_4) * t(a_3,a_4,i_4,i_1) -> I(i_3,i_1)
+  Eval | Tensor | 0ns | result=18864B | alloc=18864B | hw=39184B | t(a_1,a_2,i_3,i_2)
+  Eval | Product | 247625ns | left=384B | right=18864B | result=18864B | alloc=18864B | hw=58432B | I(i_3,i_1) * t(a_1,a_2,i_3,i_2) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 0ns | result=8B | alloc=8B | hw=20328B | 2
+  Eval | Product | 167625ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=58056B | I(a_2,a_1,i_2,i_1) * 2 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 178958ns | result=18864B | alloc=18864B | hw=58048B | I(a_2,a_1,i_2,i_1)
+  Term | End | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_4,i_1}:N-C-S) * t{a_1,a_2;i_3,i_2}:N-C-S
+  Eval | SumInplace | 394458ns | result=18864B | alloc=0B | hw=58048B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | g{a_1,a_2;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S
+  Eval | Tensor | 10352466209ns | result=3100868920B | alloc=3100868920B | hw=3100889240B | g(a_1,a_2,a_3,a_4)
+  Eval | Tensor | 1833ns | result=18864B | alloc=18864B | hw=39184B | t(a_3,a_4,i_1,i_2)
+  Eval | Product | 52750125ns | left=3100868920B | right=18864B | result=18864B | alloc=18864B | hw=3100926968B | g(a_1,a_2,a_3,a_4) * t(a_3,a_4,i_1,i_2) -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 225750ns | result=18864B | alloc=18864B | hw=58048B | I(a_2,a_1,i_2,i_1)
+  Term | End | g{a_1,a_2;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S
+  Eval | SumInplace | 411041ns | result=18864B | alloc=0B | hw=58048B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_2,a_3;i_3,i_4,i_1}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=6/8 | alive=7 | entry=1456B | total=20320B | g(i_3,i_4,a_3,a_4) * t(a_4,i_2) -> I(i_4,i_3,i_2,a_3)
+  Eval | Tensor | 625ns | result=1258096B | alloc=1258096B | hw=1278416B | t(a_1,a_2,a_3,i_3,i_4,i_1)
+  Eval | Product | 13791042ns | left=1456B | right=1258096B | result=18864B | alloc=18864B | hw=1297280B | I(i_4,i_3,i_2,a_3) * t(a_1,a_2,a_3,i_3,i_4,i_1) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 459ns | result=8B | alloc=8B | hw=20328B | 2
+  Eval | Product | 187792ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=58056B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 158708ns | result=18864B | alloc=18864B | hw=58048B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_2,a_3;i_3,i_4,i_1}:N-C-S
+  Eval | SumInplace | 393625ns | result=18864B | alloc=0B | hw=58048B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_4,i_2}:N-C-S
+  Eval | Tensor | 11958ns | result=8679736B | alloc=8679736B | hw=8700056B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 375ns | result=640B | alloc=640B | hw=20960B | t(a_4,i_3)
+  Eval | Product | 239458ns | left=8679736B | right=640B | result=640B | alloc=640B | hw=8701336B | g(i_3,i_4,a_3,a_4) * t(a_4,i_3) -> I(i_4,a_3)
+  Cache | Store | key=13613060045528791584 | life=3/4 | alive=10 | entry=640B | total=20960B | g(i_3,i_4,a_3,a_4) * t(a_4,i_3) -> I(i_4,a_3)
+  Eval | Tensor | 125ns | result=1258096B | alloc=1258096B | hw=1279056B | t(a_1,a_2,a_3,i_1,i_4,i_2)
+  Eval | Product | 14621167ns | left=640B | right=1258096B | result=18864B | alloc=18864B | hw=1297920B | I(i_4,a_3) * t(a_1,a_2,a_3,i_1,i_4,i_2) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 208ns | result=8B | alloc=8B | hw=20968B | 2
+  Eval | Product | 185041ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=58696B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 172500ns | result=18864B | alloc=18864B | hw=58688B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_4,i_2}:N-C-S
+  Eval | SumInplace | 390542ns | result=18864B | alloc=0B | hw=58688B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S
+  Eval | Tensor | 4042ns | result=163879224B | alloc=163879224B | hw=163900184B | g(i_3,a_2,a_3,a_4)
+  Eval | Tensor | 833ns | result=640B | alloc=640B | hw=21600B | t(a_4,i_3)
+  Eval | Product | 3218625ns | left=163879224B | right=640B | result=4992B | alloc=4992B | hw=163905816B | g(i_3,a_2,a_3,a_4) * t(a_4,i_3) -> I(a_2,a_3)
+  Eval | Tensor | 792ns | result=18864B | alloc=18864B | hw=39824B | t(a_1,a_3,i_1,i_2)
+  Eval | Product | 308500ns | left=4992B | right=18864B | result=18864B | alloc=18864B | hw=63680B | I(a_2,a_3) * t(a_1,a_3,i_1,i_2) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 291ns | result=8B | alloc=8B | hw=20968B | -2
+  Eval | Product | 171458ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=58696B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 166333ns | result=18864B | alloc=18864B | hw=58688B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S
+  Eval | SumInplace | 377750ns | result=18864B | alloc=0B | hw=58688B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
+  Eval | Tensor | 7208ns | result=8679736B | alloc=8679736B | hw=8700696B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 167ns | result=18864B | alloc=18864B | hw=39824B | t(a_3,a_4,i_1,i_2)
+  Eval | Product | 712292ns | left=8679736B | right=18864B | result=432B | alloc=432B | hw=8719992B | g(i_3,i_4,a_3,a_4) * t(a_3,a_4,i_1,i_2) -> I(i_4,i_3,i_2,i_1)
+  Cache | Store | key=8037026140499556789 | life=1/2 | alive=11 | entry=432B | total=21392B | g(i_3,i_4,a_3,a_4) * t(a_3,a_4,i_1,i_2) -> I(i_4,i_3,i_2,i_1)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=40256B | t(a_1,a_2,i_3,i_4)
+  Eval | Product | 207958ns | left=432B | right=18864B | result=18864B | alloc=18864B | hw=59120B | I(i_4,i_3,i_2,i_1) * t(a_1,a_2,i_3,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 192750ns | result=18864B | alloc=18864B | hw=59120B | I(a_2,a_1,i_2,i_1)
+  Term | End | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
+  Eval | SumInplace | 400375ns | result=18864B | alloc=0B | hw=59120B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | 4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S) * t{a_2,a_4;i_2,i_4}:N-C-S
+  Eval | Tensor | 2375ns | result=8679736B | alloc=8679736B | hw=8701128B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=40256B | t(a_1,a_3,i_1,i_3)
+  Eval | Product | 469042ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8738856B | g(i_3,i_4,a_3,a_4) * t(a_1,a_3,i_1,i_3) -> I(i_4,a_1,i_1,a_4)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=40256B | t(a_2,a_4,i_2,i_4)
+  Eval | Product | 366375ns | left=18864B | right=18864B | result=18864B | alloc=18864B | hw=77984B | I(i_4,a_1,i_1,a_4) * t(a_2,a_4,i_2,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=21400B | 4
+  Eval | Product | 171250ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59128B | I(a_2,a_1,i_2,i_1) * 4 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 180625ns | result=18864B | alloc=18864B | hw=59120B | I(a_2,a_1,i_2,i_1)
+  Term | End | 4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S) * t{a_2,a_4;i_2,i_4}:N-C-S
+  Eval | SumInplace | 384291ns | result=18864B | alloc=0B | hw=59120B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_3,i_1,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | Tensor | 1833ns | result=8679736B | alloc=8679736B | hw=8701128B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 500ns | result=1258096B | alloc=1258096B | hw=1279488B | t(a_1,a_3,a_4,i_3,i_1,i_2)
+  Eval | Product | 12472167ns | left=8679736B | right=1258096B | result=1456B | alloc=1456B | hw=9960680B | g(i_3,i_4,a_3,a_4) * t(a_1,a_3,a_4,i_3,i_1,i_2) -> I(i_4,a_1,i_2,i_1)
+  Eval | Tensor | 208ns | result=640B | alloc=640B | hw=22032B | t(a_2,i_4)
+  Eval | Product | 137917ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=42352B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 291ns | result=8B | alloc=8B | hw=21400B | 2
+  Eval | Product | 170542ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59128B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 160375ns | result=18864B | alloc=18864B | hw=59120B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_3,i_1,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | SumInplace | 403917ns | result=18864B | alloc=0B | hw=59120B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_4,i_1}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | Tensor | 4083ns | result=461112B | alloc=461112B | hw=482504B | g(i_3,i_4,i_2,a_3)
+  Eval | Tensor | 250ns | result=18864B | alloc=18864B | hw=40256B | t(a_1,a_3,i_4,i_1)
+  Eval | Product | 212917ns | left=461112B | right=18864B | result=1456B | alloc=1456B | hw=502824B | g(i_3,i_4,i_2,a_3) * t(a_1,a_3,i_4,i_1) -> I(i_3,a_1,i_1,i_2)
+  Eval | Tensor | 166ns | result=640B | alloc=640B | hw=22032B | t(a_2,i_3)
+  Eval | Product | 128292ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=42352B | I(i_3,a_1,i_1,i_2) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 125ns | result=8B | alloc=8B | hw=21400B | 2
+  Eval | Product | 176958ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59128B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 155042ns | result=18864B | alloc=18864B | hw=59120B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_4,i_1}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | SumInplace | 411625ns | result=18864B | alloc=0B | hw=59120B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 f{i_3;a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_2,i_3}:N-C-S
+  Eval | Tensor | 2333ns | result=30504B | alloc=30504B | hw=51896B | f(i_3,a_3)
+  Eval | Tensor | 167ns | result=1258096B | alloc=1258096B | hw=1279488B | t(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Product | 13134625ns | left=30504B | right=1258096B | result=18864B | alloc=18864B | hw=1328856B | f(i_3,a_3) * t(a_1,a_2,a_3,i_1,i_2,i_3) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 125ns | result=8B | alloc=8B | hw=21400B | 2
+  Eval | Product | 168792ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59128B | I(a_2,a_1,i_2,i_1) * 2 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 163875ns | result=18864B | alloc=18864B | hw=59120B | I(a_2,a_1,i_2,i_1)
+  Term | End | 2 f{i_3;a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_2,i_3}:N-C-S
+  Eval | SumInplace | 382459ns | result=18864B | alloc=0B | hw=59120B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_2,a_3;i_1,i_3,i_4}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=5/8 | alive=10 | entry=1456B | total=21392B | g(i_3,i_4,a_3,a_4) * t(a_4,i_2) -> I(i_4,i_3,i_2,a_3)
+  Eval | Tensor | 83ns | result=1258096B | alloc=1258096B | hw=1279488B | t(a_1,a_2,a_3,i_1,i_3,i_4)
+  Eval | Product | 10279292ns | left=1456B | right=1258096B | result=18864B | alloc=18864B | hw=1298352B | I(i_4,i_3,i_2,a_3) * t(a_1,a_2,a_3,i_1,i_3,i_4) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 125ns | result=8B | alloc=8B | hw=21400B | 2
+  Eval | Product | 153916ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59128B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 161250ns | result=18864B | alloc=18864B | hw=59120B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_2,a_3;i_1,i_3,i_4}:N-C-S
+  Eval | SumInplace | 383792ns | result=18864B | alloc=0B | hw=59120B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | (g{a_1,a_2;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S
+  Eval | Tensor | 3083ns | result=3100868920B | alloc=3100868920B | hw=3100890312B | g(a_1,a_2,a_3,a_4)
+  Eval | Tensor | 1041ns | result=640B | alloc=640B | hw=22032B | t(a_3,i_1)
+  Eval | Product | 54562167ns | left=3100868920B | right=640B | result=314800B | alloc=314800B | hw=3101205752B | g(a_1,a_2,a_3,a_4) * t(a_3,i_1) -> I(a_2,a_1,i_1,a_4)
+  Eval | Tensor | 917ns | result=640B | alloc=640B | hw=22032B | t(a_4,i_2)
+  Eval | Product | 1976875ns | left=314800B | right=640B | result=18864B | alloc=18864B | hw=355696B | I(a_2,a_1,i_1,a_4) * t(a_4,i_2) -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 240708ns | result=18864B | alloc=18864B | hw=59120B | I(a_2,a_1,i_2,i_1)
+  Term | End | (g{a_1,a_2;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S
+  Eval | SumInplace | 402834ns | result=18864B | alloc=0B | hw=59120B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | 2 g{a_1,a_2;i_1,a_3}:N-C-S * t{a_3;i_2}:N-C-S
+  Eval | Tensor | 263996250ns | result=163879224B | alloc=163879224B | hw=163900616B | g(a_1,a_2,i_1,a_3)
+  Eval | Tensor | 1625ns | result=640B | alloc=640B | hw=22032B | t(a_3,i_2)
+  Eval | Product | 3284875ns | left=163879224B | right=640B | result=18864B | alloc=18864B | hw=163920120B | g(a_1,a_2,i_1,a_3) * t(a_3,i_2) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 959ns | result=8B | alloc=8B | hw=21400B | 2
+  Eval | Product | 207916ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59128B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 159167ns | result=18864B | alloc=18864B | hw=59120B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 g{a_1,a_2;i_1,a_3}:N-C-S * t{a_3;i_2}:N-C-S
+  Eval | SumInplace | 422667ns | result=18864B | alloc=0B | hw=59120B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 4 g{i_3,a_2;a_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_1,i_3,i_2}:N-C-S
+  Eval | Tensor | 237571833ns | result=163879224B | alloc=163879224B | hw=163900616B | g(i_3,a_2,a_3,a_4)
+  Eval | Tensor | 1625ns | result=1258096B | alloc=1258096B | hw=1279488B | t(a_1,a_3,a_4,i_1,i_3,i_2)
+  Eval | Product | 19796125ns | left=163879224B | right=1258096B | result=18864B | alloc=18864B | hw=165177576B | g(i_3,a_2,a_3,a_4) * t(a_1,a_3,a_4,i_1,i_3,i_2) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 1125ns | result=8B | alloc=8B | hw=21400B | 4
+  Eval | Product | 216167ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59128B | I(a_1,a_2,i_1,i_2) * 4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 170125ns | result=18864B | alloc=18864B | hw=59120B | I(a_1,a_2,i_1,i_2)
+  Term | End | 4 g{i_3,a_2;a_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_1,i_3,i_2}:N-C-S
+  Eval | SumInplace | 397000ns | result=18864B | alloc=0B | hw=59120B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | g{a_1,a_2;i_1,i_2}:N-C-S
+  Eval | Tensor | 18798875ns | result=8679736B | alloc=8679736B | hw=8701128B | g(a_1,a_2,i_1,i_2)
+  Eval | Permute | 3992208ns | result=8679736B | alloc=8679736B | hw=17380864B | g(a_1,a_2,i_1,i_2)
+  Term | End | g{a_1,a_2;i_1,i_2}:N-C-S
+  Eval | SumInplace | 10186292ns | result=8679736B | alloc=0B | hw=17380864B | g(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_3,i_1}:N-C-S
+  Eval | Tensor | 14291ns | result=163879224B | alloc=163879224B | hw=163900616B | g(i_3,a_2,a_3,a_4)
+  Eval | Tensor | 1708ns | result=640B | alloc=640B | hw=22032B | t(a_4,i_2)
+  Eval | Product | 3439208ns | left=163879224B | right=640B | result=18864B | alloc=18864B | hw=163920120B | g(i_3,a_2,a_3,a_4) * t(a_4,i_2) -> I(i_3,a_2,i_2,a_3)
+  Cache | Store | key=8576080722563157927 | life=1/2 | alive=11 | entry=18864B | total=40256B | g(i_3,a_2,a_3,a_4) * t(a_4,i_2) -> I(i_3,a_2,i_2,a_3)
+  Eval | Tensor | 875ns | result=18864B | alloc=18864B | hw=59120B | t(a_1,a_3,i_3,i_1)
+  Eval | Product | 441459ns | left=18864B | right=18864B | result=18864B | alloc=18864B | hw=77984B | I(i_3,a_2,i_2,a_3) * t(a_1,a_3,i_3,i_1) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 708ns | result=8B | alloc=8B | hw=40264B | -2
+  Eval | Product | 197000ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=77992B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 168417ns | result=18864B | alloc=18864B | hw=77984B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_3,i_1}:N-C-S
+  Eval | SumInplace | 7044000ns | result=8679736B | alloc=0B | hw=8738856B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_2,a_3;i_1,i_4,i_3}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=4/8 | alive=10 | entry=1456B | total=40256B | g(i_3,i_4,a_3,a_4) * t(a_4,i_2) -> I(i_4,i_3,i_2,a_3)
+  Eval | Tensor | 833ns | result=1258096B | alloc=1258096B | hw=1298352B | t(a_1,a_2,a_3,i_1,i_4,i_3)
+  Eval | Product | 10168833ns | left=1456B | right=1258096B | result=18864B | alloc=18864B | hw=1317216B | I(i_4,i_3,i_2,a_3) * t(a_1,a_2,a_3,i_1,i_4,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=40264B | -4
+  Eval | Product | 178583ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=77992B | I(a_1,a_2,i_1,i_2) * -4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 156084ns | result=18864B | alloc=18864B | hw=77984B | I(a_1,a_2,i_1,i_2)
+  Term | End | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_2,a_3;i_1,i_4,i_3}:N-C-S
+  Eval | SumInplace | 6479708ns | result=8679736B | alloc=0B | hw=8738856B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 (g{i_3,a_2;a_3,i_2}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | Tensor | 12000041ns | result=8679736B | alloc=8679736B | hw=8719992B | g(i_3,a_2,a_3,i_2)
+  Eval | Tensor | 1000ns | result=640B | alloc=640B | hw=40896B | t(a_3,i_1)
+  Eval | Product | 229792ns | left=8679736B | right=640B | result=1456B | alloc=1456B | hw=8722088B | g(i_3,a_2,a_3,i_2) * t(a_3,i_1) -> I(i_3,a_2,i_1,i_2)
+  Eval | Tensor | 250ns | result=640B | alloc=640B | hw=40896B | t(a_1,i_3)
+  Eval | Product | 121375ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=61216B | I(i_3,a_2,i_1,i_2) * t(a_1,i_3) -> I(a_2,a_1,i_1,i_2)
+  Eval | Constant | 458ns | result=8B | alloc=8B | hw=40264B | -2
+  Eval | Product | 148208ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=77992B | I(a_2,a_1,i_1,i_2) * -2 -> I(a_2,a_1,i_1,i_2)
+  Eval | Permute | 156917ns | result=18864B | alloc=18864B | hw=77984B | I(a_2,a_1,i_1,i_2)
+  Term | End | -2 (g{i_3,a_2;a_3,i_2}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | SumInplace | 6923917ns | result=8679736B | alloc=0B | hw=8738856B | I(a_2,a_1,i_1,i_2)
+  Term | Begin | -2 (g{i_3,a_1;a_3,a_4}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2,a_4;i_3,i_1}:N-C-S
+  Eval | Tensor | 8459ns | result=163879224B | alloc=163879224B | hw=163919480B | g(i_3,a_1,a_3,a_4)
+  Eval | Tensor | 1917ns | result=640B | alloc=640B | hw=40896B | t(a_3,i_2)
+  Eval | Product | 3316917ns | left=163879224B | right=640B | result=18864B | alloc=18864B | hw=163938984B | g(i_3,a_1,a_3,a_4) * t(a_3,i_2) -> I(i_3,a_1,i_2,a_4)
+  Cache | Store | key=2837560362229546273 | life=2/3 | alive=12 | entry=18864B | total=59120B | g(i_3,a_1,a_3,a_4) * t(a_3,i_2) -> I(i_3,a_1,i_2,a_4)
+  Eval | Tensor | 750ns | result=18864B | alloc=18864B | hw=77984B | t(a_2,a_4,i_3,i_1)
+  Eval | Product | 441250ns | left=18864B | right=18864B | result=18864B | alloc=18864B | hw=96848B | I(i_3,a_1,i_2,a_4) * t(a_2,a_4,i_3,i_1) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 541ns | result=8B | alloc=8B | hw=59128B | -2
+  Eval | Product | 190166ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=96856B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 179417ns | result=18864B | alloc=18864B | hw=96848B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 (g{i_3,a_1;a_3,a_4}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2,a_4;i_3,i_1}:N-C-S
+  Eval | SumInplace | 6182458ns | result=8679736B | alloc=0B | hw=8757720B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 g{i_3,a_2;a_3,i_2}:N-C-S * t{a_1,a_3;i_3,i_1}:N-C-S
+  Eval | Tensor | 12125ns | result=8679736B | alloc=8679736B | hw=8738856B | g(i_3,a_2,a_3,i_2)
+  Eval | Tensor | 500ns | result=18864B | alloc=18864B | hw=77984B | t(a_1,a_3,i_3,i_1)
+  Eval | Product | 565875ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8776584B | g(i_3,a_2,a_3,i_2) * t(a_1,a_3,i_3,i_1) -> I(a_2,a_1,i_1,i_2)
+  Eval | Constant | 125ns | result=8B | alloc=8B | hw=59128B | -2
+  Eval | Product | 189334ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=96856B | I(a_2,a_1,i_1,i_2) * -2 -> I(a_2,a_1,i_1,i_2)
+  Eval | Permute | 183833ns | result=18864B | alloc=18864B | hw=96848B | I(a_2,a_1,i_1,i_2)
+  Term | End | -2 g{i_3,a_2;a_3,i_2}:N-C-S * t{a_1,a_3;i_3,i_1}:N-C-S
+  Eval | SumInplace | 6425500ns | result=8679736B | alloc=0B | hw=8757720B | I(a_2,a_1,i_1,i_2)
+  Term | Begin | -2 ((g{i_3,a_1;a_3,a_4}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_4;i_1}:N-C-S) * t{a_2;i_3}:N-C-S
+  Cache | Access | key=2837560362229546273 | life=1/3 | alive=11 | entry=18864B | total=59120B | g(i_3,a_1,a_3,a_4) * t(a_3,i_2) -> I(i_3,a_1,i_2,a_4)
+  Eval | Tensor | 625ns | result=640B | alloc=640B | hw=59760B | t(a_4,i_1)
+  Eval | Product | 159000ns | left=18864B | right=640B | result=1456B | alloc=1456B | hw=61216B | I(i_3,a_1,i_2,a_4) * t(a_4,i_1) -> I(i_3,a_1,i_2,i_1)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=59760B | t(a_2,i_3)
+  Eval | Product | 121166ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=80080B | I(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 291ns | result=8B | alloc=8B | hw=59128B | -2
+  Eval | Product | 193000ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=96856B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 161583ns | result=18864B | alloc=18864B | hw=96848B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 ((g{i_3,a_1;a_3,a_4}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_4;i_1}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | SumInplace | 6173834ns | result=8679736B | alloc=0B | hw=8757720B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 (g{i_3,i_4;i_1,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
+  Eval | Tensor | 9667ns | result=461112B | alloc=461112B | hw=520232B | g(i_3,i_4,i_1,a_3)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=59760B | t(a_3,i_2)
+  Eval | Product | 58333ns | left=461112B | right=640B | result=432B | alloc=432B | hw=521304B | g(i_3,i_4,i_1,a_3) * t(a_3,i_2) -> I(i_3,i_4,i_1,i_2)
+  Cache | Store | key=15940048826142671177 | life=1/2 | alive=12 | entry=432B | total=59552B | g(i_3,i_4,i_1,a_3) * t(a_3,i_2) -> I(i_3,i_4,i_1,i_2)
+  Eval | Tensor | 208ns | result=18864B | alloc=18864B | hw=78416B | t(a_1,a_2,i_3,i_4)
+  Eval | Product | 236916ns | left=432B | right=18864B | result=18864B | alloc=18864B | hw=97280B | I(i_3,i_4,i_1,i_2) * t(a_1,a_2,i_3,i_4) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=59560B | 2
+  Eval | Product | 200917ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=97288B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 163084ns | result=18864B | alloc=18864B | hw=97280B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;i_1,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
+  Eval | SumInplace | 6409791ns | result=8679736B | alloc=0B | hw=8758152B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_3}:N-C-S
+  Eval | Tensor | 11493125ns | result=8679736B | alloc=8679736B | hw=8739288B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 917ns | result=640B | alloc=640B | hw=60192B | t(a_4,i_4)
+  Eval | Product | 266958ns | left=8679736B | right=640B | result=640B | alloc=640B | hw=8740568B | g(i_3,i_4,a_3,a_4) * t(a_4,i_4) -> I(i_3,a_3)
+  Cache | Store | key=12860816093799665187 | life=3/4 | alive=15 | entry=640B | total=60192B | g(i_3,i_4,a_3,a_4) * t(a_4,i_4) -> I(i_3,a_3)
+  Eval | Tensor | 375ns | result=1258096B | alloc=1258096B | hw=1318288B | t(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Product | 10255125ns | left=640B | right=1258096B | result=18864B | alloc=18864B | hw=1337152B | I(i_3,a_3) * t(a_1,a_2,a_3,i_1,i_2,i_3) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=60200B | 4
+  Eval | Product | 176916ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=97928B | I(a_2,a_1,i_2,i_1) * 4 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 186667ns | result=18864B | alloc=18864B | hw=97920B | I(a_2,a_1,i_2,i_1)
+  Term | End | 4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_3}:N-C-S
+  Eval | SumInplace | 6411291ns | result=8679736B | alloc=0B | hw=8758792B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | 4 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_1,i_3}:N-C-S
+  Cache | Release | key=8576080722563157927 | life=0/2 | alive=14 | entry=0B | total=41328B | g(i_3,a_2,a_3,a_4) * t(a_4,i_2) -> I(i_3,a_2,i_2,a_3)
+  Eval | Tensor | 750ns | result=18864B | alloc=18864B | hw=60192B | t(a_1,a_3,i_1,i_3)
+  Eval | Product | 434166ns | left=18864B | right=18864B | result=18864B | alloc=18864B | hw=97920B | I(i_3,a_2,i_2,a_3) * t(a_1,a_3,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 375ns | result=8B | alloc=8B | hw=41336B | 4
+  Eval | Product | 202125ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=79064B | I(a_1,a_2,i_1,i_2) * 4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 157625ns | result=18864B | alloc=18864B | hw=79056B | I(a_1,a_2,i_1,i_2)
+  Term | End | 4 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_1,i_3}:N-C-S
+  Eval | SumInplace | 6418375ns | result=8679736B | alloc=0B | hw=8739928B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Cache | Access | key=13613060045528791584 | life=2/4 | alive=13 | entry=640B | total=41328B | g(i_3,i_4,a_3,a_4) * t(a_4,i_3) -> I(i_4,a_3)
+  Eval | Tensor | 500ns | result=640B | alloc=640B | hw=41968B | t(a_3,i_2)
+  Eval | Product | 31042ns | left=640B | right=640B | result=384B | alloc=384B | hw=42352B | I(i_4,a_3) * t(a_3,i_2) -> I(i_4,i_2)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=60192B | t(a_1,a_2,i_1,i_4)
+  Eval | Product | 218333ns | left=384B | right=18864B | result=18864B | alloc=18864B | hw=79440B | I(i_4,i_2) * t(a_1,a_2,i_1,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 208ns | result=8B | alloc=8B | hw=41336B | 2
+  Eval | Product | 186333ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=79064B | I(a_2,a_1,i_2,i_1) * 2 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 185417ns | result=18864B | alloc=18864B | hw=79056B | I(a_2,a_1,i_2,i_1)
+  Term | End | 2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | SumInplace | 6087125ns | result=8679736B | alloc=0B | hw=8739928B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_3,i_4}:N-C-S) * t{a_2,a_4;i_2,i_1}:N-C-S
+  Eval | Tensor | 10458ns | result=8679736B | alloc=8679736B | hw=8721064B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 709ns | result=18864B | alloc=18864B | hw=60192B | t(a_1,a_3,i_3,i_4)
+  Eval | Product | 500709ns | left=8679736B | right=18864B | result=4992B | alloc=4992B | hw=8744920B | g(i_3,i_4,a_3,a_4) * t(a_1,a_3,i_3,i_4) -> I(a_1,a_4)
+  Eval | Tensor | 166ns | result=18864B | alloc=18864B | hw=60192B | t(a_2,a_4,i_2,i_1)
+  Eval | Product | 304250ns | left=4992B | right=18864B | result=18864B | alloc=18864B | hw=84048B | I(a_1,a_4) * t(a_2,a_4,i_2,i_1) -> I(a_2,a_1,i_1,i_2)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=41336B | 2
+  Eval | Product | 162792ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=79064B | I(a_2,a_1,i_1,i_2) * 2 -> I(a_2,a_1,i_1,i_2)
+  Eval | Permute | 169875ns | result=18864B | alloc=18864B | hw=79056B | I(a_2,a_1,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_3,i_4}:N-C-S) * t{a_2,a_4;i_2,i_1}:N-C-S
+  Eval | SumInplace | 6738791ns | result=8679736B | alloc=0B | hw=8739928B | I(a_2,a_1,i_1,i_2)
+  Term | Begin | -2 g{i_3,a_1;a_3,a_4}:N-C-S * t{a_2,a_3,a_4;i_3,i_2,i_1}:N-C-S
+  Eval | Tensor | 10209ns | result=163879224B | alloc=163879224B | hw=163920552B | g(i_3,a_1,a_3,a_4)
+  Eval | Tensor | 1333ns | result=1258096B | alloc=1258096B | hw=1299424B | t(a_2,a_3,a_4,i_3,i_2,i_1)
+  Eval | Product | 16335000ns | left=163879224B | right=1258096B | result=18864B | alloc=18864B | hw=165197512B | g(i_3,a_1,a_3,a_4) * t(a_2,a_3,a_4,i_3,i_2,i_1) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 833ns | result=8B | alloc=8B | hw=41336B | -2
+  Eval | Product | 198209ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=79064B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 168125ns | result=18864B | alloc=18864B | hw=79056B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 g{i_3,a_1;a_3,a_4}:N-C-S * t{a_2,a_3,a_4;i_3,i_2,i_1}:N-C-S
+  Eval | SumInplace | 6163375ns | result=8679736B | alloc=0B | hw=8739928B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 (f{i_3;a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
+  Eval | Tensor | 10792ns | result=30504B | alloc=30504B | hw=71832B | f(i_3,a_3)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=41968B | t(a_3,i_2)
+  Eval | Product | 48083ns | left=30504B | right=640B | result=384B | alloc=384B | hw=72856B | f(i_3,a_3) * t(a_3,i_2) -> I(i_3,i_2)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=60192B | t(a_1,a_2,i_1,i_3)
+  Eval | Product | 219333ns | left=384B | right=18864B | result=18864B | alloc=18864B | hw=79440B | I(i_3,i_2) * t(a_1,a_2,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=41336B | -2
+  Eval | Product | 161917ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=79064B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 146417ns | result=18864B | alloc=18864B | hw=79056B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 (f{i_3;a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
+  Eval | SumInplace | 6004459ns | result=8679736B | alloc=0B | hw=8739928B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 g{i_3,a_2;a_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_1,i_2,i_3}:N-C-S
+  Eval | Tensor | 4667ns | result=163879224B | alloc=163879224B | hw=163920552B | g(i_3,a_2,a_3,a_4)
+  Eval | Tensor | 1083ns | result=1258096B | alloc=1258096B | hw=1299424B | t(a_1,a_3,a_4,i_1,i_2,i_3)
+  Eval | Product | 16522583ns | left=163879224B | right=1258096B | result=18864B | alloc=18864B | hw=165197512B | g(i_3,a_2,a_3,a_4) * t(a_1,a_3,a_4,i_1,i_2,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 958ns | result=8B | alloc=8B | hw=41336B | -2
+  Eval | Product | 182000ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=79064B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 159292ns | result=18864B | alloc=18864B | hw=79056B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 g{i_3,a_2;a_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_1,i_2,i_3}:N-C-S
+  Eval | SumInplace | 7465375ns | result=8679736B | alloc=0B | hw=8739928B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_4,i_3}:N-C-S
+  Eval | Tensor | 12291ns | result=461112B | alloc=461112B | hw=502440B | g(i_3,i_4,i_2,a_3)
+  Eval | Tensor | 417ns | result=1258096B | alloc=1258096B | hw=1299424B | t(a_1,a_2,a_3,i_1,i_4,i_3)
+  Eval | Product | 11614084ns | left=461112B | right=1258096B | result=18864B | alloc=18864B | hw=1779400B | g(i_3,i_4,i_2,a_3) * t(a_1,a_2,a_3,i_1,i_4,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 584ns | result=8B | alloc=8B | hw=41336B | 2
+  Eval | Product | 171041ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=79064B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 160583ns | result=18864B | alloc=18864B | hw=79056B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_4,i_3}:N-C-S
+  Eval | SumInplace | 6372667ns | result=8679736B | alloc=0B | hw=8739928B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 ((g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1;i_4}:N-C-S) * t{a_2;i_3}:N-C-S
+  Cache | Release | key=15940048826142671177 | life=0/2 | alive=12 | entry=0B | total=40896B | g(i_3,i_4,i_2,a_3) * t(a_3,i_1) -> I(i_3,i_4,i_2,i_1)
+  Eval | Tensor | 709ns | result=640B | alloc=640B | hw=41536B | t(a_1,i_4)
+  Eval | Product | 50500ns | left=432B | right=640B | result=1456B | alloc=1456B | hw=43424B | I(i_3,i_4,i_2,i_1) * t(a_1,i_4) -> I(i_3,a_1,i_1,i_2)
+  Eval | Tensor | 84ns | result=640B | alloc=640B | hw=41536B | t(a_2,i_3)
+  Eval | Product | 124208ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=61856B | I(i_3,a_1,i_1,i_2) * t(a_2,i_3) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 334ns | result=8B | alloc=8B | hw=40904B | 2
+  Eval | Product | 165583ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=78632B | I(a_2,a_1,i_2,i_1) * 2 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 180959ns | result=18864B | alloc=18864B | hw=78624B | I(a_2,a_1,i_2,i_1)
+  Term | End | 2 ((g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1;i_4}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | SumInplace | 6235541ns | result=8679736B | alloc=0B | hw=8739496B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | (g{i_3,i_4;i_1,i_2}:N-C-S * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | Tensor | 588209ns | result=24888B | alloc=24888B | hw=65784B | g(i_3,i_4,i_1,i_2)
+  Eval | Tensor | 375ns | result=640B | alloc=640B | hw=41536B | t(a_1,i_3)
+  Eval | Product | 39708ns | left=24888B | right=640B | result=1456B | alloc=1456B | hw=67880B | g(i_3,i_4,i_1,i_2) * t(a_1,i_3) -> I(i_4,a_1,i_2,i_1)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=41536B | t(a_2,i_4)
+  Eval | Product | 134584ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=61856B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 166500ns | result=18864B | alloc=18864B | hw=78624B | I(a_2,a_1,i_2,i_1)
+  Term | End | (g{i_3,i_4;i_1,i_2}:N-C-S * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | SumInplace | 6440667ns | result=8679736B | alloc=0B | hw=8739496B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | 2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_4}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_2;i_3}:N-C-S
+  Cache | Access | key=13613060045528791584 | life=1/4 | alive=11 | entry=640B | total=40896B | g(i_3,i_4,a_3,a_4) * t(a_3,i_4) -> I(i_3,a_4)
+  Eval | Tensor | 667ns | result=18864B | alloc=18864B | hw=59760B | t(a_1,a_4,i_1,i_2)
+  Eval | Product | 163667ns | left=640B | right=18864B | result=1456B | alloc=1456B | hw=61216B | I(i_3,a_4) * t(a_1,a_4,i_1,i_2) -> I(i_3,a_1,i_2,i_1)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=41536B | t(a_2,i_3)
+  Eval | Product | 136666ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=61856B | I(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=40904B | 2
+  Eval | Product | 170333ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=78632B | I(a_2,a_1,i_2,i_1) * 2 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 180542ns | result=18864B | alloc=18864B | hw=78624B | I(a_2,a_1,i_2,i_1)
+  Term | End | 2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_4}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | SumInplace | 6271500ns | result=8679736B | alloc=0B | hw=8739496B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | 2 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | Tensor | 9625ns | result=461112B | alloc=461112B | hw=502008B | g(i_3,i_4,i_2,a_3)
+  Eval | Tensor | 250ns | result=640B | alloc=640B | hw=41536B | t(a_3,i_3)
+  Eval | Product | 68291ns | left=461112B | right=640B | result=384B | alloc=384B | hw=503032B | g(i_3,i_4,i_2,a_3) * t(a_3,i_3) -> I(i_4,i_2)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=59760B | t(a_1,a_2,i_1,i_4)
+  Eval | Product | 225750ns | left=384B | right=18864B | result=18864B | alloc=18864B | hw=79008B | I(i_4,i_2) * t(a_1,a_2,i_1,i_4) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=40904B | 2
+  Eval | Product | 175333ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=78632B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 156250ns | result=18864B | alloc=18864B | hw=78624B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | SumInplace | 6152083ns | result=8679736B | alloc=0B | hw=8739496B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_1,i_3,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | Tensor | 5917ns | result=8679736B | alloc=8679736B | hw=8720632B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 84ns | result=1258096B | alloc=1258096B | hw=1298992B | t(a_1,a_3,a_4,i_1,i_3,i_2)
+  Eval | Product | 17104834ns | left=8679736B | right=1258096B | result=1456B | alloc=1456B | hw=9980184B | g(i_3,i_4,a_3,a_4) * t(a_1,a_3,a_4,i_1,i_3,i_2) -> I(i_4,a_1,i_2,i_1)
+  Eval | Tensor | 333ns | result=640B | alloc=640B | hw=41536B | t(a_2,i_4)
+  Eval | Product | 155667ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=61856B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=40904B | -4
+  Eval | Product | 187333ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=78632B | I(a_1,a_2,i_1,i_2) * -4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 145584ns | result=18864B | alloc=18864B | hw=78624B | I(a_1,a_2,i_1,i_2)
+  Term | End | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_1,i_3,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | SumInplace | 6770208ns | result=8679736B | alloc=0B | hw=8739496B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | Tensor | 12667ns | result=461112B | alloc=461112B | hw=502008B | g(i_3,i_4,i_2,a_3)
+  Eval | Tensor | 208ns | result=18864B | alloc=18864B | hw=59760B | t(a_1,a_3,i_1,i_3)
+  Eval | Product | 238334ns | left=461112B | right=18864B | result=1456B | alloc=1456B | hw=522328B | g(i_3,i_4,i_2,a_3) * t(a_1,a_3,i_1,i_3) -> I(i_4,a_1,i_1,i_2)
+  Eval | Tensor | 208ns | result=640B | alloc=640B | hw=41536B | t(a_2,i_4)
+  Eval | Product | 131417ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=61856B | I(i_4,a_1,i_1,i_2) * t(a_2,i_4) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=40904B | 2
+  Eval | Product | 182333ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=78632B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 159542ns | result=18864B | alloc=18864B | hw=78624B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | SumInplace | 6126208ns | result=8679736B | alloc=0B | hw=8739496B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_3}:N-C-S) * t{a_2,a_3;i_2,i_4}:N-C-S
+  Eval | Tensor | 9375ns | result=8679736B | alloc=8679736B | hw=8720632B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 459ns | result=18864B | alloc=18864B | hw=59760B | t(a_1,a_4,i_1,i_3)
+  Eval | Product | 512833ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8758360B | g(i_3,i_4,a_3,a_4) * t(a_1,a_4,i_1,i_3) -> I(i_4,a_1,i_1,a_3)
+  Eval | Tensor | 458ns | result=18864B | alloc=18864B | hw=59760B | t(a_2,a_3,i_2,i_4)
+  Eval | Product | 400083ns | left=18864B | right=18864B | result=18864B | alloc=18864B | hw=97488B | I(i_4,a_1,i_1,a_3) * t(a_2,a_3,i_2,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=40904B | -2
+  Eval | Product | 171250ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=78632B | I(a_2,a_1,i_2,i_1) * -2 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 202666ns | result=18864B | alloc=18864B | hw=78624B | I(a_2,a_1,i_2,i_1)
+  Term | End | -2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_3}:N-C-S) * t{a_2,a_3;i_2,i_4}:N-C-S
+  Eval | SumInplace | 6290500ns | result=8679736B | alloc=0B | hw=8739496B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | 4 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S
+  Eval | Tensor | 9667ns | result=163879224B | alloc=163879224B | hw=163920120B | g(i_3,a_2,a_3,a_4)
+  Eval | Tensor | 1625ns | result=640B | alloc=640B | hw=41536B | t(a_3,i_3)
+  Eval | Product | 3191375ns | left=163879224B | right=640B | result=4992B | alloc=4992B | hw=163925752B | g(i_3,a_2,a_3,a_4) * t(a_3,i_3) -> I(a_2,a_4)
+  Eval | Tensor | 1208ns | result=18864B | alloc=18864B | hw=59760B | t(a_1,a_4,i_1,i_2)
+  Eval | Product | 302667ns | left=4992B | right=18864B | result=18864B | alloc=18864B | hw=83616B | I(a_2,a_4) * t(a_1,a_4,i_1,i_2) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 458ns | result=8B | alloc=8B | hw=40904B | 4
+  Eval | Product | 172625ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=78632B | I(a_1,a_2,i_1,i_2) * 4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 163208ns | result=18864B | alloc=18864B | hw=78624B | I(a_1,a_2,i_1,i_2)
+  Term | End | 4 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S
+  Eval | SumInplace | 6411417ns | result=8679736B | alloc=0B | hw=8739496B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | g{i_3,i_4;i_1,i_2}:N-C-S * t{a_1,a_2;i_3,i_4}:N-C-S
+  Eval | Tensor | 12542ns | result=24888B | alloc=24888B | hw=65784B | g(i_3,i_4,i_1,i_2)
+  Eval | Tensor | 292ns | result=18864B | alloc=18864B | hw=59760B | t(a_1,a_2,i_3,i_4)
+  Eval | Product | 262417ns | left=24888B | right=18864B | result=18864B | alloc=18864B | hw=103512B | g(i_3,i_4,i_1,i_2) * t(a_1,a_2,i_3,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 186042ns | result=18864B | alloc=18864B | hw=78624B | I(a_2,a_1,i_2,i_1)
+  Term | End | g{i_3,i_4;i_1,i_2}:N-C-S * t{a_1,a_2;i_3,i_4}:N-C-S
+  Eval | SumInplace | 5963000ns | result=8679736B | alloc=0B | hw=8739496B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | -2 (f{i_3;a_3}:N-C-S * t{a_1,a_3;i_1,i_2}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | Tensor | 5167ns | result=30504B | alloc=30504B | hw=71400B | f(i_3,a_3)
+  Eval | Tensor | 208ns | result=18864B | alloc=18864B | hw=59760B | t(a_1,a_3,i_1,i_2)
+  Eval | Product | 200833ns | left=30504B | right=18864B | result=1456B | alloc=1456B | hw=91720B | f(i_3,a_3) * t(a_1,a_3,i_1,i_2) -> I(i_3,a_1,i_2,i_1)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=41536B | t(a_2,i_3)
+  Eval | Product | 121375ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=61856B | I(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 167ns | result=8B | alloc=8B | hw=40904B | -2
+  Eval | Product | 171250ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=78632B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 164458ns | result=18864B | alloc=18864B | hw=78624B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 (f{i_3;a_3}:N-C-S * t{a_1,a_3;i_1,i_2}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | SumInplace | 5834959ns | result=8679736B | alloc=0B | hw=8739496B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 g{i_3,a_1;i_2,i_1}:N-C-S * t{a_2;i_3}:N-C-S
+  Eval | Tensor | 560208ns | result=461112B | alloc=461112B | hw=502008B | g(i_3,a_1,i_2,i_1)
+  Eval | Tensor | 375ns | result=640B | alloc=640B | hw=41536B | t(a_2,i_3)
+  Eval | Product | 137000ns | left=461112B | right=640B | result=18864B | alloc=18864B | hw=521512B | g(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=40904B | -2
+  Eval | Product | 169042ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=78632B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 162917ns | result=18864B | alloc=18864B | hw=78624B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 g{i_3,a_1;i_2,i_1}:N-C-S * t{a_2;i_3}:N-C-S
+  Eval | SumInplace | 5908541ns | result=8679736B | alloc=0B | hw=8739496B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=3/8 | alive=10 | entry=1456B | total=40896B | g(i_3,i_4,a_3,a_4) * t(a_3,i_1) -> I(i_3,i_4,i_1,a_4)
+  Eval | Tensor | 375ns | result=640B | alloc=640B | hw=41536B | t(a_4,i_2)
+  Eval | Product | 42291ns | left=1456B | right=640B | result=432B | alloc=432B | hw=41968B | I(i_3,i_4,i_1,a_4) * t(a_4,i_2) -> I(i_4,i_3,i_2,i_1)
+  Cache | Store | key=1288916799981805547 | life=1/2 | alive=11 | entry=432B | total=41328B | I(i_3,i_4,i_1,a_4) * t(a_4,i_2) -> I(i_4,i_3,i_2,i_1)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=60192B | t(a_1,a_2,i_3,i_4)
+  Eval | Product | 224667ns | left=432B | right=18864B | result=18864B | alloc=18864B | hw=79056B | I(i_4,i_3,i_2,i_1) * t(a_1,a_2,i_3,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 184875ns | result=18864B | alloc=18864B | hw=79056B | I(a_2,a_1,i_2,i_1)
+  Term | End | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
+  Eval | SumInplace | 5656417ns | result=8679736B | alloc=0B | hw=8739928B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | 2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_2,a_4;i_4,i_2}:N-C-S) * t{a_1;i_3}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=2/8 | alive=10 | entry=1456B | total=41328B | g(i_3,i_4,a_3,a_4) * t(a_3,i_1) -> I(i_3,i_4,i_1,a_4)
+  Eval | Tensor | 292ns | result=18864B | alloc=18864B | hw=60192B | t(a_2,a_4,i_4,i_2)
+  Eval | Product | 178250ns | left=1456B | right=18864B | result=1456B | alloc=1456B | hw=61648B | I(i_3,i_4,i_1,a_4) * t(a_2,a_4,i_4,i_2) -> I(i_3,a_2,i_2,i_1)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=41968B | t(a_1,i_3)
+  Eval | Product | 127917ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=62288B | I(i_3,a_2,i_2,i_1) * t(a_1,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=41336B | 2
+  Eval | Product | 178250ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=79064B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 158792ns | result=18864B | alloc=18864B | hw=79056B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_2,a_4;i_4,i_2}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | SumInplace | 5763166ns | result=8679736B | alloc=0B | hw=8739928B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_3,i_1}:N-C-S) * t{a_1,a_2;i_4,i_2}:N-C-S
+  Eval | Tensor | 5042ns | result=8679736B | alloc=8679736B | hw=8721064B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 292ns | result=18864B | alloc=18864B | hw=60192B | t(a_3,a_4,i_3,i_1)
+  Eval | Product | 1035833ns | left=8679736B | right=18864B | result=384B | alloc=384B | hw=8740312B | g(i_3,i_4,a_3,a_4) * t(a_3,a_4,i_3,i_1) -> I(i_4,i_1)
+  Eval | Tensor | 42ns | result=18864B | alloc=18864B | hw=60192B | t(a_1,a_2,i_4,i_2)
+  Eval | Product | 220916ns | left=384B | right=18864B | result=18864B | alloc=18864B | hw=79440B | I(i_4,i_1) * t(a_1,a_2,i_4,i_2) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 83ns | result=8B | alloc=8B | hw=41336B | -4
+  Eval | Product | 164250ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=79064B | I(a_2,a_1,i_2,i_1) * -4 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 173834ns | result=18864B | alloc=18864B | hw=79056B | I(a_2,a_1,i_2,i_1)
+  Term | End | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_3,i_1}:N-C-S) * t{a_1,a_2;i_4,i_2}:N-C-S
+  Eval | SumInplace | 6053625ns | result=8679736B | alloc=0B | hw=8739928B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | -4 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_4}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
+  Eval | Tensor | 584583ns | result=461112B | alloc=461112B | hw=502440B | g(i_3,i_4,i_2,a_3)
+  Eval | Tensor | 208ns | result=640B | alloc=640B | hw=41968B | t(a_3,i_4)
+  Eval | Product | 59375ns | left=461112B | right=640B | result=384B | alloc=384B | hw=503464B | g(i_3,i_4,i_2,a_3) * t(a_3,i_4) -> I(i_3,i_2)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=60192B | t(a_1,a_2,i_1,i_3)
+  Eval | Product | 234000ns | left=384B | right=18864B | result=18864B | alloc=18864B | hw=79440B | I(i_3,i_2) * t(a_1,a_2,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 83ns | result=8B | alloc=8B | hw=41336B | -4
+  Eval | Product | 173708ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=79064B | I(a_1,a_2,i_1,i_2) * -4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 164583ns | result=18864B | alloc=18864B | hw=79056B | I(a_1,a_2,i_1,i_2)
+  Term | End | -4 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_4}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
+  Eval | SumInplace | 6019333ns | result=8679736B | alloc=0B | hw=8739928B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_4}:N-C-S
+  Cache | Release | key=13613060045528791584 | life=0/4 | alive=9 | entry=0B | total=40688B | g(i_3,i_4,a_3,a_4) * t(a_4,i_3) -> I(i_4,a_3)
+  Eval | Tensor | 416ns | result=1258096B | alloc=1258096B | hw=1298784B | t(a_1,a_2,a_3,i_1,i_2,i_4)
+  Eval | Product | 10314875ns | left=640B | right=1258096B | result=18864B | alloc=18864B | hw=1318288B | I(i_4,a_3) * t(a_1,a_2,a_3,i_1,i_2,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 334ns | result=8B | alloc=8B | hw=40696B | -2
+  Eval | Product | 162458ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=78424B | I(a_2,a_1,i_2,i_1) * -2 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 184125ns | result=18864B | alloc=18864B | hw=78416B | I(a_2,a_1,i_2,i_1)
+  Term | End | -2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 7273042ns | result=8679736B | alloc=0B | hw=8739288B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_3,i_1}:N-C-S) * t{a_2,a_4;i_2,i_4}:N-C-S
+  Eval | Tensor | 10125ns | result=8679736B | alloc=8679736B | hw=8720424B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 458ns | result=18864B | alloc=18864B | hw=59552B | t(a_1,a_3,i_3,i_1)
+  Eval | Product | 528084ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8758152B | g(i_3,i_4,a_3,a_4) * t(a_1,a_3,i_3,i_1) -> I(i_4,a_1,i_1,a_4)
+  Cache | Store | key=853172630937087824 | life=1/2 | alive=10 | entry=18864B | total=59552B | g(i_3,i_4,a_3,a_4) * t(a_1,a_3,i_3,i_1) -> I(i_4,a_1,i_1,a_4)
+  Eval | Tensor | 166ns | result=18864B | alloc=18864B | hw=78416B | t(a_2,a_4,i_2,i_4)
+  Eval | Product | 359875ns | left=18864B | right=18864B | result=18864B | alloc=18864B | hw=97280B | I(i_4,a_1,i_1,a_4) * t(a_2,a_4,i_2,i_4) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 417ns | result=8B | alloc=8B | hw=59560B | -4
+  Eval | Product | 189166ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=97288B | I(a_1,a_2,i_1,i_2) * -4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 166292ns | result=18864B | alloc=18864B | hw=97280B | I(a_1,a_2,i_1,i_2)
+  Term | End | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_3,i_1}:N-C-S) * t{a_2,a_4;i_2,i_4}:N-C-S
+  Eval | SumInplace | 6272875ns | result=8679736B | alloc=0B | hw=8758152B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_2,a_3;i_2,i_4}:N-C-S) * t{a_1;i_3}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=1/8 | alive=9 | entry=1456B | total=59552B | g(i_3,i_4,a_3,a_4) * t(a_4,i_1) -> I(i_4,i_3,i_1,a_3)
+  Eval | Tensor | 375ns | result=18864B | alloc=18864B | hw=78416B | t(a_2,a_3,i_2,i_4)
+  Eval | Product | 168542ns | left=1456B | right=18864B | result=1456B | alloc=1456B | hw=79872B | I(i_4,i_3,i_1,a_3) * t(a_2,a_3,i_2,i_4) -> I(i_3,a_2,i_2,i_1)
+  Eval | Tensor | 292ns | result=640B | alloc=640B | hw=60192B | t(a_1,i_3)
+  Eval | Product | 122375ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=80512B | I(i_3,a_2,i_2,i_1) * t(a_1,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 334ns | result=8B | alloc=8B | hw=59560B | 2
+  Eval | Product | 170042ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=97288B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 156791ns | result=18864B | alloc=18864B | hw=97280B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_2,a_3;i_2,i_4}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | SumInplace | 6123291ns | result=8679736B | alloc=0B | hw=8758152B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_4,i_3,i_1}:N-C-S
+  Eval | Tensor | 8250ns | result=461112B | alloc=461112B | hw=520664B | g(i_3,i_4,i_2,a_3)
+  Eval | Tensor | 292ns | result=1258096B | alloc=1258096B | hw=1317648B | t(a_1,a_2,a_3,i_4,i_3,i_1)
+  Eval | Product | 13987875ns | left=461112B | right=1258096B | result=18864B | alloc=18864B | hw=1797624B | g(i_3,i_4,i_2,a_3) * t(a_1,a_2,a_3,i_4,i_3,i_1) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 209ns | result=8B | alloc=8B | hw=59560B | 2
+  Eval | Product | 187291ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=97288B | I(a_2,a_1,i_2,i_1) * 2 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 174125ns | result=18864B | alloc=18864B | hw=97280B | I(a_2,a_1,i_2,i_1)
+  Term | End | 2 g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_2,a_3;i_4,i_3,i_1}:N-C-S
+  Eval | SumInplace | 5776667ns | result=8679736B | alloc=0B | hw=8758152B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_3,i_1}:N-C-S) * t{a_2,a_4;i_4,i_2}:N-C-S
+  Cache | Release | key=853172630937087824 | life=0/2 | alive=8 | entry=0B | total=40688B | g(i_3,i_4,a_3,a_4) * t(a_1,a_3,i_3,i_1) -> I(i_4,a_1,i_1,a_4)
+  Eval | Tensor | 292ns | result=18864B | alloc=18864B | hw=59552B | t(a_2,a_4,i_4,i_2)
+  Eval | Product | 392875ns | left=18864B | right=18864B | result=18864B | alloc=18864B | hw=97280B | I(i_4,a_1,i_1,a_4) * t(a_2,a_4,i_4,i_2) -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 175500ns | result=18864B | alloc=18864B | hw=78416B | I(a_2,a_1,i_2,i_1)
+  Term | End | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_3,i_1}:N-C-S) * t{a_2,a_4;i_4,i_2}:N-C-S
+  Eval | SumInplace | 6017333ns | result=8679736B | alloc=0B | hw=8739288B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | -2 (g{i_3,a_1;i_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | Tensor | 8250ns | result=8679736B | alloc=8679736B | hw=8720424B | g(i_3,a_1,i_2,a_3)
+  Eval | Tensor | 292ns | result=640B | alloc=640B | hw=41328B | t(a_3,i_1)
+  Eval | Product | 242875ns | left=8679736B | right=640B | result=1456B | alloc=1456B | hw=8722520B | g(i_3,a_1,i_2,a_3) * t(a_3,i_1) -> I(i_3,a_1,i_2,i_1)
+  Eval | Tensor | 42ns | result=640B | alloc=640B | hw=41328B | t(a_2,i_3)
+  Eval | Product | 144959ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=61648B | I(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 208ns | result=8B | alloc=8B | hw=40696B | -2
+  Eval | Product | 170375ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=78424B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 150375ns | result=18864B | alloc=18864B | hw=78416B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 (g{i_3,a_1;i_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | SumInplace | 6043584ns | result=8679736B | alloc=0B | hw=8739288B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_3,i_1}:N-C-S) * t{a_2,a_3;i_2,i_4}:N-C-S
+  Cache | Release | key=13982275274528923534 | life=0/2 | alive=7 | entry=0B | total=21824B | g(i_3,i_4,a_3,a_4) * t(a_1,a_4,i_3,i_1) -> I(i_4,a_1,i_1,a_3)
+  Eval | Tensor | 417ns | result=18864B | alloc=18864B | hw=40688B | t(a_2,a_3,i_2,i_4)
+  Eval | Product | 382541ns | left=18864B | right=18864B | result=18864B | alloc=18864B | hw=78416B | I(i_4,a_1,i_1,a_3) * t(a_2,a_3,i_2,i_4) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=21832B | 2
+  Eval | Product | 164833ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59560B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 153125ns | result=18864B | alloc=18864B | hw=59552B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_3,i_1}:N-C-S) * t{a_2,a_3;i_2,i_4}:N-C-S
+  Eval | SumInplace | 6321458ns | result=8679736B | alloc=0B | hw=8720424B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 (g{i_3,a_1;a_3,a_4}:N-C-S * t{a_3,a_4;i_2,i_1}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | Tensor | 8125ns | result=163879224B | alloc=163879224B | hw=163901048B | g(i_3,a_1,a_3,a_4)
+  Eval | Tensor | 1167ns | result=18864B | alloc=18864B | hw=40688B | t(a_3,a_4,i_2,i_1)
+  Eval | Product | 3686083ns | left=163879224B | right=18864B | result=1456B | alloc=1456B | hw=163921368B | g(i_3,a_1,a_3,a_4) * t(a_3,a_4,i_2,i_1) -> I(i_3,a_1,i_2,i_1)
+  Eval | Tensor | 834ns | result=640B | alloc=640B | hw=22464B | t(a_2,i_3)
+  Eval | Product | 153208ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=42784B | I(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 375ns | result=8B | alloc=8B | hw=21832B | -2
+  Eval | Product | 163333ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59560B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 154041ns | result=18864B | alloc=18864B | hw=59552B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 (g{i_3,a_1;a_3,a_4}:N-C-S * t{a_3,a_4;i_2,i_1}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | SumInplace | 6348292ns | result=8679736B | alloc=0B | hw=8720424B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_4,i_3}:N-C-S) * t{a_2,a_4;i_2,i_1}:N-C-S
+  Eval | Tensor | 8041ns | result=8679736B | alloc=8679736B | hw=8701560B | g(i_3,i_4,a_3,a_4)
+  Eval | Tensor | 500ns | result=18864B | alloc=18864B | hw=40688B | t(a_1,a_3,i_4,i_3)
+  Eval | Product | 452250ns | left=8679736B | right=18864B | result=4992B | alloc=4992B | hw=8725416B | g(i_3,i_4,a_3,a_4) * t(a_1,a_3,i_4,i_3) -> I(a_1,a_4)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=40688B | t(a_2,a_4,i_2,i_1)
+  Eval | Product | 257375ns | left=4992B | right=18864B | result=18864B | alloc=18864B | hw=64544B | I(a_1,a_4) * t(a_2,a_4,i_2,i_1) -> I(a_2,a_1,i_1,i_2)
+  Eval | Constant | 209ns | result=8B | alloc=8B | hw=21832B | -4
+  Eval | Product | 174041ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59560B | I(a_2,a_1,i_1,i_2) * -4 -> I(a_2,a_1,i_1,i_2)
+  Eval | Permute | 163125ns | result=18864B | alloc=18864B | hw=59552B | I(a_2,a_1,i_1,i_2)
+  Term | End | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_4,i_3}:N-C-S) * t{a_2,a_4;i_2,i_1}:N-C-S
+  Eval | SumInplace | 5952459ns | result=8679736B | alloc=0B | hw=8720424B | I(a_2,a_1,i_1,i_2)
+  Term | Begin | -4 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Cache | Access | key=12860816093799665187 | life=2/4 | alive=6 | entry=640B | total=21824B | g(i_3,i_4,a_3,a_4) * t(a_3,i_3) -> I(i_4,a_4)
+  Eval | Tensor | 416ns | result=640B | alloc=640B | hw=22464B | t(a_4,i_2)
+  Eval | Product | 27458ns | left=640B | right=640B | result=384B | alloc=384B | hw=22848B | I(i_4,a_4) * t(a_4,i_2) -> I(i_4,i_2)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=40688B | t(a_1,a_2,i_1,i_4)
+  Eval | Product | 251458ns | left=384B | right=18864B | result=18864B | alloc=18864B | hw=59936B | I(i_4,i_2) * t(a_1,a_2,i_1,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 167ns | result=8B | alloc=8B | hw=21832B | -4
+  Eval | Product | 171375ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59560B | I(a_2,a_1,i_2,i_1) * -4 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 177625ns | result=18864B | alloc=18864B | hw=59552B | I(a_2,a_1,i_2,i_1)
+  Term | End | -4 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | SumInplace | 6319333ns | result=8679736B | alloc=0B | hw=8720424B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | -4 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
+  Cache | Access | key=12860816093799665187 | life=1/4 | alive=5 | entry=640B | total=21824B | g(i_3,i_4,a_3,a_4) * t(a_3,i_3) -> I(i_4,a_4)
+  Eval | Tensor | 333ns | result=18864B | alloc=18864B | hw=40688B | t(a_1,a_4,i_1,i_2)
+  Eval | Product | 160875ns | left=640B | right=18864B | result=1456B | alloc=1456B | hw=42144B | I(i_4,a_4) * t(a_1,a_4,i_1,i_2) -> I(i_4,a_1,i_2,i_1)
+  Eval | Tensor | 83ns | result=640B | alloc=640B | hw=22464B | t(a_2,i_4)
+  Eval | Product | 121125ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=42784B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Constant | 167ns | result=8B | alloc=8B | hw=21832B | -4
+  Eval | Product | 173958ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59560B | I(a_2,a_1,i_2,i_1) * -4 -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 172417ns | result=18864B | alloc=18864B | hw=59552B | I(a_2,a_1,i_2,i_1)
+  Term | End | -4 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | SumInplace | 6089417ns | result=8679736B | alloc=0B | hw=8720424B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | -2 f{i_3;a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_3,i_2}:N-C-S
+  Eval | Tensor | 6375ns | result=30504B | alloc=30504B | hw=52328B | f(i_3,a_3)
+  Eval | Tensor | 292ns | result=1258096B | alloc=1258096B | hw=1279920B | t(a_1,a_2,a_3,i_1,i_3,i_2)
+  Eval | Product | 14708625ns | left=30504B | right=1258096B | result=18864B | alloc=18864B | hw=1329288B | f(i_3,a_3) * t(a_1,a_2,a_3,i_1,i_3,i_2) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=21832B | -2
+  Eval | Product | 177667ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59560B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 156458ns | result=18864B | alloc=18864B | hw=59552B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 f{i_3;a_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_3,i_2}:N-C-S
+  Eval | SumInplace | 6121125ns | result=8679736B | alloc=0B | hw=8720424B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 4 g{i_3,a_2;a_3,i_2}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S
+  Eval | Tensor | 10562458ns | result=8679736B | alloc=8679736B | hw=8701560B | g(i_3,a_2,a_3,i_2)
+  Eval | Tensor | 584ns | result=18864B | alloc=18864B | hw=40688B | t(a_1,a_3,i_1,i_3)
+  Eval | Product | 534084ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8739288B | g(i_3,a_2,a_3,i_2) * t(a_1,a_3,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 208ns | result=8B | alloc=8B | hw=21832B | 4
+  Eval | Product | 173917ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59560B | I(a_1,a_2,i_1,i_2) * 4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 152750ns | result=18864B | alloc=18864B | hw=59552B | I(a_1,a_2,i_1,i_2)
+  Term | End | 4 g{i_3,a_2;a_3,i_2}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S
+  Eval | SumInplace | 6107583ns | result=8679736B | alloc=0B | hw=8720424B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | 2 f{a_2;a_3}:N-C-S * t{a_1,a_3;i_1,i_2}:N-C-S
+  Eval | Tensor | 7625ns | result=529960B | alloc=529960B | hw=551784B | f(a_2,a_3)
+  Eval | Tensor | 292ns | result=18864B | alloc=18864B | hw=40688B | t(a_1,a_3,i_1,i_2)
+  Eval | Product | 329000ns | left=529960B | right=18864B | result=18864B | alloc=18864B | hw=589512B | f(a_2,a_3) * t(a_1,a_3,i_1,i_2) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 209ns | result=8B | alloc=8B | hw=21832B | 2
+  Eval | Product | 163375ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59560B | I(a_1,a_2,i_1,i_2) * 2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 175208ns | result=18864B | alloc=18864B | hw=59552B | I(a_1,a_2,i_1,i_2)
+  Term | End | 2 f{a_2;a_3}:N-C-S * t{a_1,a_3;i_1,i_2}:N-C-S
+  Eval | SumInplace | 6286625ns | result=8679736B | alloc=0B | hw=8720424B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 g{i_3,a_2;i_2,a_3}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S
+  Eval | Tensor | 9167ns | result=8679736B | alloc=8679736B | hw=8701560B | g(i_3,a_2,i_2,a_3)
+  Eval | Tensor | 333ns | result=18864B | alloc=18864B | hw=40688B | t(a_1,a_3,i_1,i_3)
+  Eval | Product | 497750ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8739288B | g(i_3,a_2,i_2,a_3) * t(a_1,a_3,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 167ns | result=8B | alloc=8B | hw=21832B | -2
+  Eval | Product | 184167ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59560B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 160250ns | result=18864B | alloc=18864B | hw=59552B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 g{i_3,a_2;i_2,a_3}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S
+  Eval | SumInplace | 5867458ns | result=8679736B | alloc=0B | hw=8720424B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 f{i_3;i_2}:N-C-S * t{a_1,a_2;i_1,i_3}:N-C-S
+  Eval | Tensor | 6209ns | result=2088B | alloc=2088B | hw=23912B | f(i_3,i_2)
+  Eval | Tensor | 250ns | result=18864B | alloc=18864B | hw=40688B | t(a_1,a_2,i_1,i_3)
+  Eval | Product | 257542ns | left=2088B | right=18864B | result=18864B | alloc=18864B | hw=61640B | f(i_3,i_2) * t(a_1,a_2,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=21832B | -2
+  Eval | Product | 172667ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=59560B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 169458ns | result=18864B | alloc=18864B | hw=59552B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 f{i_3;i_2}:N-C-S * t{a_1,a_2;i_1,i_3}:N-C-S
+  Eval | SumInplace | 6169042ns | result=8679736B | alloc=0B | hw=8720424B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -4 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_2,a_4;i_2,i_4}:N-C-S) * t{a_1;i_3}:N-C-S
+  Cache | Release | key=6322769425051513756 | life=0/8 | alive=4 | entry=0B | total=20368B | g(i_3,i_4,a_3,a_4) * t(a_3,i_1) -> I(i_3,i_4,i_1,a_4)
+  Eval | Tensor | 417ns | result=18864B | alloc=18864B | hw=39232B | t(a_2,a_4,i_2,i_4)
+  Eval | Product | 183834ns | left=1456B | right=18864B | result=1456B | alloc=1456B | hw=42144B | I(i_3,i_4,i_1,a_4) * t(a_2,a_4,i_2,i_4) -> I(i_3,a_2,i_2,i_1)
+  Eval | Tensor | 167ns | result=640B | alloc=640B | hw=21008B | t(a_1,i_3)
+  Eval | Product | 128500ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=41328B | I(i_3,a_2,i_2,i_1) * t(a_1,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=20376B | -4
+  Eval | Product | 172000ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=58104B | I(a_1,a_2,i_1,i_2) * -4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 173417ns | result=18864B | alloc=18864B | hw=58096B | I(a_1,a_2,i_1,i_2)
+  Term | End | -4 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_2,a_4;i_2,i_4}:N-C-S) * t{a_1;i_3}:N-C-S
+  Eval | SumInplace | 6334333ns | result=8679736B | alloc=0B | hw=8718968B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 g{i_3,a_1;i_2,a_3}:N-C-S * t{a_2,a_3;i_3,i_1}:N-C-S
+  Eval | Tensor | 6708ns | result=8679736B | alloc=8679736B | hw=8700104B | g(i_3,a_1,i_2,a_3)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=39232B | t(a_2,a_3,i_3,i_1)
+  Eval | Product | 499542ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8737832B | g(i_3,a_1,i_2,a_3) * t(a_2,a_3,i_3,i_1) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 375ns | result=8B | alloc=8B | hw=20376B | -2
+  Eval | Product | 189750ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=58104B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 176250ns | result=18864B | alloc=18864B | hw=58096B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 g{i_3,a_1;i_2,a_3}:N-C-S * t{a_2,a_3;i_3,i_1}:N-C-S
+  Eval | SumInplace | 6507875ns | result=8679736B | alloc=0B | hw=8718968B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | (((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
+  Cache | Release | key=1288916799981805547 | life=0/2 | alive=3 | entry=0B | total=19936B | I(i_3,i_4,i_1,a_4) * t(a_4,i_2) -> I(i_4,i_3,i_2,i_1)
+  Eval | Tensor | 500ns | result=640B | alloc=640B | hw=20576B | t(a_1,i_3)
+  Eval | Product | 38166ns | left=432B | right=640B | result=1456B | alloc=1456B | hw=22464B | I(i_4,i_3,i_2,i_1) * t(a_1,i_3) -> I(i_4,a_1,i_2,i_1)
+  Eval | Tensor | 83ns | result=640B | alloc=640B | hw=20576B | t(a_2,i_4)
+  Eval | Product | 130208ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=40896B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 170875ns | result=18864B | alloc=18864B | hw=57664B | I(a_2,a_1,i_2,i_1)
+  Term | End | (((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | SumInplace | 6112041ns | result=8679736B | alloc=0B | hw=8718536B | I(a_2,a_1,i_2,i_1)
+  Term | Begin | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_2,a_3;i_1,i_3,i_2}:N-C-S
+  Cache | Release | key=12860816093799665187 | life=0/4 | alive=2 | entry=0B | total=19296B | g(i_3,i_4,a_3,a_4) * t(a_4,i_4) -> I(i_3,a_3)
+  Eval | Tensor | 500ns | result=1258096B | alloc=1258096B | hw=1277392B | t(a_1,a_2,a_3,i_1,i_3,i_2)
+  Eval | Product | 13488208ns | left=640B | right=1258096B | result=18864B | alloc=18864B | hw=1296896B | I(i_3,a_3) * t(a_1,a_2,a_3,i_1,i_3,i_2) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=19304B | -4
+  Eval | Product | 157958ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=57032B | I(a_1,a_2,i_1,i_2) * -4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 160292ns | result=18864B | alloc=18864B | hw=57024B | I(a_1,a_2,i_1,i_2)
+  Term | End | -4 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_2,a_3;i_1,i_3,i_2}:N-C-S
+  Eval | SumInplace | 6452958ns | result=8679736B | alloc=0B | hw=8717896B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -2 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_4;i_1,i_3}:N-C-S
+  Cache | Release | key=2837560362229546273 | life=0/3 | alive=1 | entry=0B | total=432B | g(i_3,a_2,a_3,a_4) * t(a_3,i_2) -> I(i_3,a_2,i_2,a_4)
+  Eval | Tensor | 333ns | result=18864B | alloc=18864B | hw=19296B | t(a_1,a_4,i_1,i_3)
+  Eval | Product | 401541ns | left=18864B | right=18864B | result=18864B | alloc=18864B | hw=57024B | I(i_3,a_2,i_2,a_4) * t(a_1,a_4,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 209ns | result=8B | alloc=8B | hw=440B | -2
+  Eval | Product | 168542ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=38168B | I(a_1,a_2,i_1,i_2) * -2 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 168416ns | result=18864B | alloc=18864B | hw=38160B | I(a_1,a_2,i_1,i_2)
+  Term | End | -2 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_4;i_1,i_3}:N-C-S
+  Eval | SumInplace | 6177041ns | result=8679736B | alloc=0B | hw=8699032B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -4 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_1,i_4}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | Tensor | 9208ns | result=461112B | alloc=461112B | hw=461544B | g(i_3,i_4,i_2,a_3)
+  Eval | Tensor | 250ns | result=18864B | alloc=18864B | hw=19296B | t(a_1,a_3,i_1,i_4)
+  Eval | Product | 258333ns | left=461112B | right=18864B | result=1456B | alloc=1456B | hw=481864B | g(i_3,i_4,i_2,a_3) * t(a_1,a_3,i_1,i_4) -> I(i_3,a_1,i_1,i_2)
+  Eval | Tensor | 208ns | result=640B | alloc=640B | hw=1072B | t(a_2,i_3)
+  Eval | Product | 122042ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=21392B | I(i_3,a_1,i_1,i_2) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
+  Eval | Constant | 166ns | result=8B | alloc=8B | hw=440B | -4
+  Eval | Product | 181500ns | left=18864B | right=8B | result=18864B | alloc=18864B | hw=38168B | I(a_1,a_2,i_1,i_2) * -4 -> I(a_1,a_2,i_1,i_2)
+  Eval | Permute | 166209ns | result=18864B | alloc=18864B | hw=38160B | I(a_1,a_2,i_1,i_2)
+  Term | End | -4 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_1,i_4}:N-C-S) * t{a_2;i_3}:N-C-S
+  Eval | SumInplace | 6068167ns | result=8679736B | alloc=0B | hw=8699032B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S) * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
+  Cache | Release | key=8037026140499556789 | life=0/2 | alive=0 | entry=0B | total=0B | g(i_3,i_4,a_3,a_4) * t(a_3,a_4,i_1,i_2) -> I(i_4,i_3,i_2,i_1)
+  Eval | Tensor | 291ns | result=640B | alloc=640B | hw=640B | t(a_1,i_3)
+  Eval | Product | 41750ns | left=432B | right=640B | result=1456B | alloc=1456B | hw=2528B | I(i_4,i_3,i_2,i_1) * t(a_1,i_3) -> I(i_4,a_1,i_2,i_1)
+  Eval | Tensor | 83ns | result=640B | alloc=640B | hw=640B | t(a_2,i_4)
+  Eval | Product | 125333ns | left=1456B | right=640B | result=18864B | alloc=18864B | hw=20960B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_2,a_1,i_2,i_1)
+  Eval | Permute | 169833ns | result=18864B | alloc=18864B | hw=37728B | I(a_2,a_1,i_2,i_1)
+  Term | End | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S) * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | SumInplace | 5884875ns | result=8679736B | alloc=0B | hw=8698600B | I(a_2,a_1,i_2,i_1)
+  Eval | Symmetrize | 21348500ns | result=8679736B | alloc=8679736B | hw=17359472B | I(a_1,a_2,i_1,i_2)
+  Term | Begin | -6 g{i_4,a_3;a_4,i_3}:N-C-S * t{a_1,a_2,a_4;i_1,i_4,i_2}:N-C-S
+  Eval | Tensor | 12000ns | result=8679736B | alloc=8679736B | hw=8679736B | g(i_4,a_3,a_4,i_3)
+  Eval | Tensor | 417ns | result=1258096B | alloc=1258096B | hw=1258096B | t(a_1,a_2,a_4,i_1,i_4,i_2)
+  Eval | Product | 27578333ns | left=8679736B | right=1258096B | result=1258096B | alloc=1258096B | hw=11195928B | g(i_4,a_3,a_4,i_3) * t(a_1,a_2,a_4,i_1,i_4,i_2) -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Constant | 708ns | result=8B | alloc=8B | hw=8B | -6
+  Eval | Product | 13987875ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2516200B | I(a_1,a_3,a_2,i_1,i_3,i_2) * -6 -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Permute | 14893375ns | result=1258096B | alloc=1258096B | hw=2516192B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | End | -6 g{i_4,a_3;a_4,i_3}:N-C-S * t{a_1,a_2,a_4;i_1,i_4,i_2}:N-C-S
+  Term | Begin | 12 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_3,i_5}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S
+  Eval | Tensor | 11119166ns | result=8679736B | alloc=8679736B | hw=8679736B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 667ns | result=18864B | alloc=18864B | hw=18864B | t(a_3,a_5,i_3,i_5)
+  Eval | Product | 452709ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8717464B | g(i_4,i_5,a_4,a_5) * t(a_3,a_5,i_3,i_5) -> I(i_4,a_3,i_3,a_4)
+  Cache | Store | key=14937657755075493246 | life=2/3 | alive=2 | entry=18864B | total=18864B | g(i_4,i_5,a_4,a_5) * t(a_3,a_5,i_3,i_5) -> I(i_4,a_3,i_3,a_4)
+  Eval | Tensor | 42ns | result=1258096B | alloc=1258096B | hw=1276960B | t(a_1,a_2,a_4,i_1,i_2,i_4)
+  Eval | Product | 19107416ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2535056B | I(i_4,a_3,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 625ns | result=8B | alloc=8B | hw=18872B | 12
+  Eval | Product | 14524208ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535064B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 12 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 15821542ns | result=1258096B | alloc=1258096B | hw=2535056B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 12 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_3,i_5}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 31005583ns | result=1258096B | alloc=0B | hw=2535056B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | -3 (f{i_4;a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_3}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | Tensor | 11958ns | result=30504B | alloc=30504B | hw=49368B | f(i_4,a_4)
+  Eval | Tensor | 542ns | result=1258096B | alloc=1258096B | hw=1276960B | t(a_1,a_2,a_4,i_1,i_2,i_3)
+  Eval | Product | 12879667ns | left=30504B | right=1258096B | result=74352B | alloc=74352B | hw=1381816B | f(i_4,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_3) -> I(i_4,a_2,a_1,i_2,i_1,i_3)
+  Eval | Tensor | 292ns | result=640B | alloc=640B | hw=19504B | t(a_3,i_4)
+  Eval | Product | 7348375ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1351952B | I(i_4,a_2,a_1,i_2,i_1,i_3) * t(a_3,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=18872B | -3
+  Eval | Product | 13490709ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535064B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17991708ns | result=1258096B | alloc=1258096B | hw=2535056B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -3 (f{i_4;a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_3}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 31720250ns | result=1258096B | alloc=0B | hw=2535056B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 12 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_1,a_4;i_1,i_4}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S
+  Eval | Tensor | 12208ns | result=163879224B | alloc=163879224B | hw=163898088B | g(i_4,a_3,a_4,a_5)
+  Eval | Tensor | 1250ns | result=18864B | alloc=18864B | hw=37728B | t(a_1,a_4,i_1,i_4)
+  Eval | Product | 5306708ns | left=163879224B | right=18864B | result=314800B | alloc=314800B | hw=164231752B | g(i_4,a_3,a_4,a_5) * t(a_1,a_4,i_1,i_4) -> I(a_3,a_1,i_1,a_5)
+  Eval | Tensor | 750ns | result=18864B | alloc=18864B | hw=37728B | t(a_2,a_5,i_2,i_3)
+  Eval | Product | 9257292ns | left=314800B | right=18864B | result=1258096B | alloc=1258096B | hw=1610624B | I(a_3,a_1,i_1,a_5) * t(a_2,a_5,i_2,i_3) -> I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Eval | Constant | 417ns | result=8B | alloc=8B | hw=18872B | 12
+  Eval | Product | 13768959ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535064B | I(a_2,a_3,a_1,i_2,i_3,i_1) * 12 -> I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Eval | Permute | 14161084ns | result=1258096B | alloc=1258096B | hw=2535056B | I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Term | End | 12 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_1,a_4;i_1,i_4}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S
+  Eval | SumInplace | 31114458ns | result=1258096B | alloc=0B | hw=2535056B | I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Term | Begin | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_3,a_5;i_1,i_5,i_4}:N-C-S) * t{a_2,a_4;i_2,i_3}:N-C-S
+  Eval | Tensor | 12958ns | result=8679736B | alloc=8679736B | hw=8698600B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 666ns | result=1258096B | alloc=1258096B | hw=1276960B | t(a_1,a_3,a_5,i_1,i_5,i_4)
+  Eval | Product | 13252209ns | left=8679736B | right=1258096B | result=314800B | alloc=314800B | hw=10271496B | g(i_4,i_5,a_4,a_5) * t(a_1,a_3,a_5,i_1,i_5,i_4) -> I(a_3,a_1,i_1,a_4)
+  Eval | Tensor | 458ns | result=18864B | alloc=18864B | hw=37728B | t(a_2,a_4,i_2,i_3)
+  Eval | Product | 9581000ns | left=314800B | right=18864B | result=1258096B | alloc=1258096B | hw=1610624B | I(a_3,a_1,i_1,a_4) * t(a_2,a_4,i_2,i_3) -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Constant | 417ns | result=8B | alloc=8B | hw=18872B | 6
+  Eval | Product | 13598167ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535064B | I(a_1,a_3,a_2,i_1,i_3,i_2) * 6 -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Permute | 14415541ns | result=1258096B | alloc=1258096B | hw=2535056B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | End | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_3,a_5;i_1,i_5,i_4}:N-C-S) * t{a_2,a_4;i_2,i_3}:N-C-S
+  Eval | SumInplace | 30472583ns | result=1258096B | alloc=0B | hw=2535056B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | Begin | 3 f{a_3;a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_3}:N-C-S
+  Eval | Tensor | 12583ns | result=529960B | alloc=529960B | hw=548824B | f(a_3,a_4)
+  Eval | Tensor | 416ns | result=1258096B | alloc=1258096B | hw=1276960B | t(a_1,a_2,a_4,i_1,i_2,i_3)
+  Eval | Product | 20935125ns | left=529960B | right=1258096B | result=1258096B | alloc=1258096B | hw=3065016B | f(a_3,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_3) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 1084ns | result=8B | alloc=8B | hw=18872B | 3
+  Eval | Product | 13538125ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535064B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17619167ns | result=1258096B | alloc=1258096B | hw=2535056B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 3 f{a_3;a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_3}:N-C-S
+  Eval | SumInplace | 30891667ns | result=1258096B | alloc=0B | hw=2535056B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_3,a_4;i_4,i_5,i_1}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S
+  Eval | Tensor | 12792ns | result=8679736B | alloc=8679736B | hw=8698600B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 583ns | result=1258096B | alloc=1258096B | hw=1276960B | t(a_1,a_3,a_4,i_4,i_5,i_1)
+  Eval | Product | 15304458ns | left=8679736B | right=1258096B | result=314800B | alloc=314800B | hw=10271496B | g(i_4,i_5,a_4,a_5) * t(a_1,a_3,a_4,i_4,i_5,i_1) -> I(a_3,a_1,i_1,a_5)
+  Eval | Tensor | 1208ns | result=18864B | alloc=18864B | hw=37728B | t(a_2,a_5,i_2,i_3)
+  Eval | Product | 9524333ns | left=314800B | right=18864B | result=1258096B | alloc=1258096B | hw=1610624B | I(a_3,a_1,i_1,a_5) * t(a_2,a_5,i_2,i_3) -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Constant | 542ns | result=8B | alloc=8B | hw=18872B | 6
+  Eval | Product | 13912417ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535064B | I(a_1,a_3,a_2,i_1,i_3,i_2) * 6 -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Permute | 14361250ns | result=1258096B | alloc=1258096B | hw=2535056B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | End | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_3,a_4;i_4,i_5,i_1}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S
+  Eval | SumInplace | 29891459ns | result=1258096B | alloc=0B | hw=2535056B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | Begin | 6 (g{i_4,i_5;i_1,a_4}:N-C-S * t{a_1,a_4;i_4,i_3}:N-C-S) * t{a_2,a_3;i_2,i_5}:N-C-S
+  Eval | Tensor | 13667ns | result=461112B | alloc=461112B | hw=479976B | g(i_4,i_5,i_1,a_4)
+  Eval | Tensor | 542ns | result=18864B | alloc=18864B | hw=37728B | t(a_1,a_4,i_4,i_3)
+  Eval | Product | 911000ns | left=461112B | right=18864B | result=1456B | alloc=1456B | hw=500296B | g(i_4,i_5,i_1,a_4) * t(a_1,a_4,i_4,i_3) -> I(i_5,a_1,i_3,i_1)
+  Eval | Tensor | 41ns | result=18864B | alloc=18864B | hw=37728B | t(a_2,a_3,i_2,i_5)
+  Eval | Product | 7949958ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1297280B | I(i_5,a_1,i_3,i_1) * t(a_2,a_3,i_2,i_5) -> I(a_2,a_3,a_1,i_2,i_1,i_3)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=18872B | 6
+  Eval | Product | 13523333ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535064B | I(a_2,a_3,a_1,i_2,i_1,i_3) * 6 -> I(a_2,a_3,a_1,i_2,i_1,i_3)
+  Eval | Permute | 16004792ns | result=1258096B | alloc=1258096B | hw=2535056B | I(a_2,a_3,a_1,i_2,i_1,i_3)
+  Term | End | 6 (g{i_4,i_5;i_1,a_4}:N-C-S * t{a_1,a_4;i_4,i_3}:N-C-S) * t{a_2,a_3;i_2,i_5}:N-C-S
+  Eval | SumInplace | 30931541ns | result=1258096B | alloc=0B | hw=2535056B | I(a_2,a_3,a_1,i_2,i_1,i_3)
+  Term | Begin | -6 (g{i_4,i_5;i_3,a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_5}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | Tensor | 13958ns | result=461112B | alloc=461112B | hw=479976B | g(i_4,i_5,i_3,a_4)
+  Eval | Tensor | 459ns | result=1258096B | alloc=1258096B | hw=1276960B | t(a_1,a_2,a_4,i_1,i_2,i_5)
+  Eval | Product | 13125708ns | left=461112B | right=1258096B | result=74352B | alloc=74352B | hw=1812424B | g(i_4,i_5,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_5) -> I(i_4,a_2,a_1,i_2,i_1,i_3)
+  Eval | Tensor | 458ns | result=640B | alloc=640B | hw=19504B | t(a_3,i_4)
+  Eval | Product | 7457792ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1351952B | I(i_4,a_2,a_1,i_2,i_1,i_3) * t(a_3,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 291ns | result=8B | alloc=8B | hw=18872B | -6
+  Eval | Product | 15068375ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535064B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 15686167ns | result=1258096B | alloc=1258096B | hw=2535056B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -6 (g{i_4,i_5;i_3,a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_5}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 31163000ns | result=1258096B | alloc=0B | hw=2535056B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 3 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_5}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | Tensor | 12625ns | result=8679736B | alloc=8679736B | hw=8698600B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 375ns | result=640B | alloc=640B | hw=19504B | t(a_5,i_3)
+  Eval | Product | 263833ns | left=8679736B | right=640B | result=1456B | alloc=1456B | hw=8700696B | g(i_4,i_5,a_4,a_5) * t(a_5,i_3) -> I(i_5,i_4,i_3,a_4)
+  Cache | Store | key=6322769425051513756 | life=9/10 | alive=11 | entry=1456B | total=20320B | g(i_4,i_5,a_4,a_5) * t(a_5,i_3) -> I(i_5,i_4,i_3,a_4)
+  Eval | Tensor | 250ns | result=1258096B | alloc=1258096B | hw=1278416B | t(a_1,a_2,a_4,i_1,i_2,i_5)
+  Eval | Product | 10836875ns | left=1456B | right=1258096B | result=74352B | alloc=74352B | hw=1352768B | I(i_5,i_4,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_5) -> I(i_4,a_2,a_1,i_2,i_1,i_3)
+  Eval | Tensor | 41ns | result=640B | alloc=640B | hw=20960B | t(a_3,i_4)
+  Eval | Product | 7359833ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1353408B | I(i_4,a_2,a_1,i_2,i_1,i_3) * t(a_3,i_4) -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=20328B | 3
+  Eval | Product | 14055625ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2536520B | I(a_3,a_2,a_1,i_2,i_1,i_3) * 3 -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Permute | 18490458ns | result=1258096B | alloc=1258096B | hw=2536512B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | End | 3 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_5}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 30933083ns | result=1258096B | alloc=0B | hw=2536512B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | Begin | 6 g{i_4,a_3;a_4,i_3}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S
+  Eval | Tensor | 11750792ns | result=8679736B | alloc=8679736B | hw=8700056B | g(i_4,a_3,a_4,i_3)
+  Eval | Tensor | 791ns | result=1258096B | alloc=1258096B | hw=1278416B | t(a_1,a_2,a_4,i_1,i_2,i_4)
+  Eval | Product | 20131042ns | left=8679736B | right=1258096B | result=1258096B | alloc=1258096B | hw=11216248B | g(i_4,a_3,a_4,i_3) * t(a_1,a_2,a_4,i_1,i_2,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 667ns | result=8B | alloc=8B | hw=20328B | 6
+  Eval | Product | 13471916ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2536520B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17716875ns | result=1258096B | alloc=1258096B | hw=2536512B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 6 g{i_4,a_3;a_4,i_3}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 30214834ns | result=1258096B | alloc=0B | hw=2536512B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | -6 g{i_4,a_2;i_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_1,i_4,i_2}:N-C-S
+  Eval | Tensor | 15708ns | result=8679736B | alloc=8679736B | hw=8700056B | g(i_4,a_2,i_3,a_4)
+  Eval | Tensor | 625ns | result=1258096B | alloc=1258096B | hw=1278416B | t(a_1,a_3,a_4,i_1,i_4,i_2)
+  Eval | Product | 21766167ns | left=8679736B | right=1258096B | result=1258096B | alloc=1258096B | hw=11216248B | g(i_4,a_2,i_3,a_4) * t(a_1,a_3,a_4,i_1,i_4,i_2) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 792ns | result=8B | alloc=8B | hw=20328B | -6
+  Eval | Product | 14036667ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2536520B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13212042ns | result=1258096B | alloc=1258096B | hw=2536512B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -6 g{i_4,a_2;i_3,a_4}:N-C-S * t{a_1,a_3,a_4;i_1,i_4,i_2}:N-C-S
+  Eval | SumInplace | 30875167ns | result=1258096B | alloc=0B | hw=2536512B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 3 (g{i_4,i_5;i_3,a_4}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_5}:N-C-S
+  Eval | Tensor | 14166ns | result=461112B | alloc=461112B | hw=481432B | g(i_4,i_5,i_3,a_4)
+  Eval | Tensor | 625ns | result=640B | alloc=640B | hw=20960B | t(a_4,i_4)
+  Eval | Product | 809542ns | left=461112B | right=640B | result=384B | alloc=384B | hw=482456B | g(i_4,i_5,i_3,a_4) * t(a_4,i_4) -> I(i_5,i_3)
+  Eval | Tensor | 417ns | result=1258096B | alloc=1258096B | hw=1278416B | t(a_1,a_2,a_3,i_1,i_2,i_5)
+  Eval | Product | 18132125ns | left=384B | right=1258096B | result=1258096B | alloc=1258096B | hw=2536896B | I(i_5,i_3) * t(a_1,a_2,a_3,i_1,i_2,i_5) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 500ns | result=8B | alloc=8B | hw=20328B | 3
+  Eval | Product | 13711292ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2536520B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 16138750ns | result=1258096B | alloc=1258096B | hw=2536512B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 3 (g{i_4,i_5;i_3,a_4}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_5}:N-C-S
+  Eval | SumInplace | 31630625ns | result=1258096B | alloc=0B | hw=2536512B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_2}:N-C-S) * t{a_1,a_4;i_4,i_1}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=8/10 | alive=10 | entry=1456B | total=20320B | g(i_4,i_5,a_4,a_5) * t(a_5,i_2) -> I(i_5,i_4,i_2,a_4)
+  Eval | Tensor | 750ns | result=18864B | alloc=18864B | hw=39184B | t(a_1,a_4,i_4,i_1)
+  Eval | Product | 919333ns | left=1456B | right=18864B | result=1456B | alloc=1456B | hw=40640B | I(i_5,i_4,i_2,a_4) * t(a_1,a_4,i_4,i_1) -> I(i_5,a_1,i_1,i_2)
+  Eval | Tensor | 167ns | result=18864B | alloc=18864B | hw=39184B | t(a_2,a_3,i_5,i_3)
+  Eval | Product | 8987958ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1298736B | I(i_5,a_1,i_1,i_2) * t(a_2,a_3,i_5,i_3) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 125ns | result=8B | alloc=8B | hw=20328B | 6
+  Eval | Product | 14519417ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2536520B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13221667ns | result=1258096B | alloc=1258096B | hw=2536512B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_2}:N-C-S) * t{a_1,a_4;i_4,i_1}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Eval | SumInplace | 32137625ns | result=1258096B | alloc=0B | hw=2536512B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_5;i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S
+  Eval | Tensor | 13667ns | result=163879224B | alloc=163879224B | hw=163899544B | g(i_4,a_3,a_4,a_5)
+  Eval | Tensor | 1292ns | result=640B | alloc=640B | hw=20960B | t(a_5,i_3)
+  Eval | Product | 3063708ns | left=163879224B | right=640B | result=18864B | alloc=18864B | hw=163919048B | g(i_4,a_3,a_4,a_5) * t(a_5,i_3) -> I(i_4,a_3,i_3,a_4)
+  Cache | Store | key=8576080722563157927 | life=2/3 | alive=12 | entry=18864B | total=39184B | g(i_4,a_3,a_4,a_5) * t(a_5,i_3) -> I(i_4,a_3,i_3,a_4)
+  Eval | Tensor | 916ns | result=1258096B | alloc=1258096B | hw=1297280B | t(a_1,a_2,a_4,i_1,i_2,i_4)
+  Eval | Product | 19203292ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2555376B | I(i_4,a_3,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 500ns | result=8B | alloc=8B | hw=39192B | 6
+  Eval | Product | 14079291ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2555384B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 16604250ns | result=1258096B | alloc=1258096B | hw=2555376B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_5;i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 30026208ns | result=1258096B | alloc=0B | hw=2555376B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 6 (g{i_4,i_5;i_2,i_3}:N-C-S * t{a_3;i_5}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | Tensor | 12333ns | result=24888B | alloc=24888B | hw=64072B | g(i_4,i_5,i_2,i_3)
+  Eval | Tensor | 291ns | result=640B | alloc=640B | hw=39824B | t(a_3,i_5)
+  Eval | Product | 758833ns | left=24888B | right=640B | result=1456B | alloc=1456B | hw=66168B | g(i_4,i_5,i_2,i_3) * t(a_3,i_5) -> I(i_4,a_3,i_2,i_3)
+  Eval | Tensor | 208ns | result=18864B | alloc=18864B | hw=58048B | t(a_1,a_2,i_1,i_4)
+  Eval | Product | 7454625ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1317600B | I(i_4,a_3,i_2,i_3) * t(a_1,a_2,i_1,i_4) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 291ns | result=8B | alloc=8B | hw=39192B | 6
+  Eval | Product | 13794708ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2555384B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 12535625ns | result=1258096B | alloc=1258096B | hw=2555376B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 (g{i_4,i_5;i_2,i_3}:N-C-S * t{a_3;i_5}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | SumInplace | 30238917ns | result=1258096B | alloc=0B | hw=2555376B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 3 g{a_1,a_2;a_4,a_5}:N-C-S * t{a_3,a_4,a_5;i_3,i_1,i_2}:N-C-S
+  Eval | Tensor | 13416ns | result=3100868920B | alloc=3100868920B | hw=3100908104B | g(a_1,a_2,a_4,a_5)
+  Eval | Tensor | 1417ns | result=1258096B | alloc=1258096B | hw=1297280B | t(a_3,a_4,a_5,i_3,i_1,i_2)
+  Eval | Product | 72411125ns | left=3100868920B | right=1258096B | result=1258096B | alloc=1258096B | hw=3103424296B | g(a_1,a_2,a_4,a_5) * t(a_3,a_4,a_5,i_3,i_1,i_2) -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Constant | 917ns | result=8B | alloc=8B | hw=39192B | 3
+  Eval | Product | 13201833ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2555384B | I(a_3,a_2,a_1,i_2,i_1,i_3) * 3 -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Permute | 17748708ns | result=1258096B | alloc=1258096B | hw=2555376B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | End | 3 g{a_1,a_2;a_4,a_5}:N-C-S * t{a_3,a_4,a_5;i_3,i_1,i_2}:N-C-S
+  Eval | SumInplace | 31143209ns | result=1258096B | alloc=0B | hw=2555376B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | Begin | -6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_4;i_3,i_5}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_4}:N-C-S
+  Eval | Tensor | 11471625ns | result=8679736B | alloc=8679736B | hw=8718920B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 1000ns | result=18864B | alloc=18864B | hw=58048B | t(a_3,a_4,i_3,i_5)
+  Eval | Product | 557417ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8756648B | g(i_4,i_5,a_4,a_5) * t(a_3,a_4,i_3,i_5) -> I(i_4,a_3,i_3,a_5)
+  Cache | Store | key=18006422551833664970 | life=2/3 | alive=14 | entry=18864B | total=58048B | g(i_4,i_5,a_4,a_5) * t(a_3,a_4,i_3,i_5) -> I(i_4,a_3,i_3,a_5)
+  Eval | Tensor | 250ns | result=1258096B | alloc=1258096B | hw=1316144B | t(a_1,a_2,a_5,i_1,i_2,i_4)
+  Eval | Product | 18504708ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2574240B | I(i_4,a_3,i_3,a_5) * t(a_1,a_2,a_5,i_1,i_2,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 625ns | result=8B | alloc=8B | hw=58056B | -6
+  Eval | Product | 13966667ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2574248B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 18050459ns | result=1258096B | alloc=1258096B | hw=2574240B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_4;i_3,i_5}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 31789167ns | result=1258096B | alloc=0B | hw=2574240B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | -12 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_3,a_4;i_1,i_5,i_4}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S
+  Eval | Tensor | 10000ns | result=8679736B | alloc=8679736B | hw=8737784B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 625ns | result=1258096B | alloc=1258096B | hw=1316144B | t(a_1,a_3,a_4,i_1,i_5,i_4)
+  Eval | Product | 12972292ns | left=8679736B | right=1258096B | result=314800B | alloc=314800B | hw=10310680B | g(i_4,i_5,a_4,a_5) * t(a_1,a_3,a_4,i_1,i_5,i_4) -> I(a_3,a_1,i_1,a_5)
+  Eval | Tensor | 250ns | result=18864B | alloc=18864B | hw=76912B | t(a_2,a_5,i_2,i_3)
+  Eval | Product | 9271417ns | left=314800B | right=18864B | result=1258096B | alloc=1258096B | hw=1649808B | I(a_3,a_1,i_1,a_5) * t(a_2,a_5,i_2,i_3) -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Constant | 291ns | result=8B | alloc=8B | hw=58056B | -12
+  Eval | Product | 13780125ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2574248B | I(a_1,a_3,a_2,i_1,i_3,i_2) * -12 -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Permute | 14464500ns | result=1258096B | alloc=1258096B | hw=2574240B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | End | -12 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_3,a_4;i_1,i_5,i_4}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S
+  Eval | SumInplace | 32027250ns | result=1258096B | alloc=0B | hw=2574240B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | Begin | 3 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_4,a_5;i_3,i_1,i_2}:N-C-S) * t{a_1;i_4}:N-C-S) * t{a_2;i_5}:N-C-S
+  Eval | Tensor | 12292ns | result=8679736B | alloc=8679736B | hw=8737784B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 250ns | result=1258096B | alloc=1258096B | hw=1316144B | t(a_3,a_4,a_5,i_3,i_1,i_2)
+  Eval | Product | 13179541ns | left=8679736B | right=1258096B | result=4720B | alloc=4720B | hw=10000600B | g(i_4,i_5,a_4,a_5) * t(a_3,a_4,a_5,i_3,i_1,i_2) -> I(i_5,i_4,a_3,i_2,i_1,i_3)
+  Cache | Store | key=6074554422931925897 | life=1/2 | alive=15 | entry=4720B | total=62768B | g(i_4,i_5,a_4,a_5) * t(a_3,a_4,a_5,i_3,i_1,i_2) -> I(i_5,i_4,a_3,i_2,i_1,i_3)
+  Eval | Tensor | 375ns | result=640B | alloc=640B | hw=63408B | t(a_1,i_4)
+  Eval | Product | 522541ns | left=4720B | right=640B | result=74352B | alloc=74352B | hw=137760B | I(i_5,i_4,a_3,i_2,i_1,i_3) * t(a_1,i_4) -> I(i_5,a_3,a_1,i_3,i_2,i_1)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=63408B | t(a_2,i_5)
+  Eval | Product | 7477125ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1395856B | I(i_5,a_3,a_1,i_3,i_2,i_1) * t(a_2,i_5) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=62776B | 3
+  Eval | Product | 14646208ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2578968B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17151334ns | result=1258096B | alloc=1258096B | hw=2578960B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 3 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_4,a_5;i_3,i_1,i_2}:N-C-S) * t{a_1;i_4}:N-C-S) * t{a_2;i_5}:N-C-S
+  Eval | SumInplace | 30959084ns | result=1258096B | alloc=0B | hw=2578960B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_5,i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_4,i_2}:N-C-S
+  Eval | Tensor | 13375ns | result=8679736B | alloc=8679736B | hw=8742504B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 708ns | result=18864B | alloc=18864B | hw=81632B | t(a_3,a_5,i_5,i_3)
+  Eval | Product | 485083ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8780232B | g(i_4,i_5,a_4,a_5) * t(a_3,a_5,i_5,i_3) -> I(i_4,a_3,i_3,a_4)
+  Cache | Store | key=853172630937087824 | life=2/3 | alive=17 | entry=18864B | total=81632B | g(i_4,i_5,a_4,a_5) * t(a_3,a_5,i_5,i_3) -> I(i_4,a_3,i_3,a_4)
+  Eval | Tensor | 125ns | result=1258096B | alloc=1258096B | hw=1339728B | t(a_1,a_2,a_4,i_1,i_4,i_2)
+  Eval | Product | 20942542ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2597824B | I(i_4,a_3,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_4,i_2) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 334ns | result=8B | alloc=8B | hw=81640B | 6
+  Eval | Product | 13532542ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2597832B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13438375ns | result=1258096B | alloc=1258096B | hw=2597824B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_5,i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_4,i_2}:N-C-S
+  Eval | SumInplace | 30819291ns | result=1258096B | alloc=0B | hw=2597824B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 ((g{i_4,i_5;i_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_2;i_5}:N-C-S) * t{a_1,a_3;i_1,i_4}:N-C-S
+  Eval | Tensor | 10417ns | result=461112B | alloc=461112B | hw=542744B | g(i_4,i_5,i_3,a_4)
+  Eval | Tensor | 500ns | result=640B | alloc=640B | hw=82272B | t(a_4,i_2)
+  Eval | Product | 541750ns | left=461112B | right=640B | result=432B | alloc=432B | hw=543816B | g(i_4,i_5,i_3,a_4) * t(a_4,i_2) -> I(i_4,i_5,i_3,i_2)
+  Cache | Store | key=15940048826142671177 | life=2/3 | alive=19 | entry=432B | total=82064B | g(i_4,i_5,i_3,a_4) * t(a_4,i_2) -> I(i_4,i_5,i_3,i_2)
+  Eval | Tensor | 42ns | result=640B | alloc=640B | hw=82704B | t(a_2,i_5)
+  Eval | Product | 31542ns | left=432B | right=640B | result=1456B | alloc=1456B | hw=84160B | I(i_4,i_5,i_3,i_2) * t(a_2,i_5) -> I(i_4,a_2,i_2,i_3)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=100928B | t(a_1,a_3,i_1,i_4)
+  Eval | Product | 6651917ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1360480B | I(i_4,a_2,i_2,i_3) * t(a_1,a_3,i_1,i_4) -> I(a_2,a_1,a_3,i_1,i_3,i_2)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=82072B | 6
+  Eval | Product | 13906375ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598264B | I(a_2,a_1,a_3,i_1,i_3,i_2) * 6 -> I(a_2,a_1,a_3,i_1,i_3,i_2)
+  Eval | Permute | 14119750ns | result=1258096B | alloc=1258096B | hw=2598256B | I(a_2,a_1,a_3,i_1,i_3,i_2)
+  Term | End | 6 ((g{i_4,i_5;i_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_2;i_5}:N-C-S) * t{a_1,a_3;i_1,i_4}:N-C-S
+  Eval | SumInplace | 32201708ns | result=1258096B | alloc=0B | hw=2598256B | I(a_2,a_1,a_3,i_1,i_3,i_2)
+  Term | Begin | 6 ((g{i_4,i_5;i_3,a_4}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_3;i_4}:N-C-S) * t{a_1,a_2;i_5,i_2}:N-C-S
+  Cache | Access | key=15940048826142671177 | life=1/3 | alive=18 | entry=432B | total=82064B | g(i_4,i_5,i_3,a_4) * t(a_4,i_1) -> I(i_4,i_5,i_3,i_1)
+  Eval | Tensor | 500ns | result=640B | alloc=640B | hw=82704B | t(a_3,i_4)
+  Eval | Product | 640375ns | left=432B | right=640B | result=1456B | alloc=1456B | hw=84160B | I(i_4,i_5,i_3,i_1) * t(a_3,i_4) -> I(i_5,a_3,i_1,i_3)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=100928B | t(a_1,a_2,i_5,i_2)
+  Eval | Product | 7520708ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1360480B | I(i_5,a_3,i_1,i_3) * t(a_1,a_2,i_5,i_2) -> I(a_3,a_2,a_1,i_2,i_3,i_1)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=82072B | 6
+  Eval | Product | 13848209ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598264B | I(a_3,a_2,a_1,i_2,i_3,i_1) * 6 -> I(a_3,a_2,a_1,i_2,i_3,i_1)
+  Eval | Permute | 14073166ns | result=1258096B | alloc=1258096B | hw=2598256B | I(a_3,a_2,a_1,i_2,i_3,i_1)
+  Term | End | 6 ((g{i_4,i_5;i_3,a_4}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_3;i_4}:N-C-S) * t{a_1,a_2;i_5,i_2}:N-C-S
+  Eval | SumInplace | 29967000ns | result=1258096B | alloc=0B | hw=2598256B | I(a_3,a_2,a_1,i_2,i_3,i_1)
+  Term | Begin | -12 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_2}:N-C-S) * t{a_1,a_4;i_1,i_4}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=7/10 | alive=17 | entry=1456B | total=82064B | g(i_4,i_5,a_4,a_5) * t(a_5,i_2) -> I(i_5,i_4,i_2,a_4)
+  Eval | Tensor | 375ns | result=18864B | alloc=18864B | hw=100928B | t(a_1,a_4,i_1,i_4)
+  Eval | Product | 630834ns | left=1456B | right=18864B | result=1456B | alloc=1456B | hw=102384B | I(i_5,i_4,i_2,a_4) * t(a_1,a_4,i_1,i_4) -> I(i_5,a_1,i_1,i_2)
+  Eval | Tensor | 167ns | result=18864B | alloc=18864B | hw=100928B | t(a_2,a_3,i_5,i_3)
+  Eval | Product | 9938125ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1360480B | I(i_5,a_1,i_1,i_2) * t(a_2,a_3,i_5,i_3) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=82072B | -12
+  Eval | Product | 13105792ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598264B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -12 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13164417ns | result=1258096B | alloc=1258096B | hw=2598256B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -12 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_2}:N-C-S) * t{a_1,a_4;i_1,i_4}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Eval | SumInplace | 30611541ns | result=1258096B | alloc=0B | hw=2598256B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4,a_5;i_3,i_2}:N-C-S) * t{a_3;i_4}:N-C-S) * t{a_1,a_2;i_1,i_5}:N-C-S
+  Eval | Tensor | 8792ns | result=8679736B | alloc=8679736B | hw=8761800B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 500ns | result=18864B | alloc=18864B | hw=100928B | t(a_4,a_5,i_3,i_2)
+  Eval | Product | 735750ns | left=8679736B | right=18864B | result=432B | alloc=432B | hw=8781096B | g(i_4,i_5,a_4,a_5) * t(a_4,a_5,i_3,i_2) -> I(i_5,i_4,i_2,i_3)
+  Cache | Store | key=8037026140499556789 | life=1/2 | alive=18 | entry=432B | total=82496B | g(i_4,i_5,a_4,a_5) * t(a_4,a_5,i_3,i_2) -> I(i_5,i_4,i_2,i_3)
+  Eval | Tensor | 208ns | result=640B | alloc=640B | hw=83136B | t(a_3,i_4)
+  Eval | Product | 32125ns | left=432B | right=640B | result=1456B | alloc=1456B | hw=84592B | I(i_5,i_4,i_2,i_3) * t(a_3,i_4) -> I(i_5,a_3,i_2,i_3)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=101360B | t(a_1,a_2,i_1,i_5)
+  Eval | Product | 7644542ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1360912B | I(i_5,a_3,i_2,i_3) * t(a_1,a_2,i_1,i_5) -> I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Eval | Constant | 334ns | result=8B | alloc=8B | hw=82504B | 6
+  Eval | Product | 14554833ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598696B | I(a_1,a_2,a_3,i_1,i_3,i_2) * 6 -> I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Eval | Permute | 15237500ns | result=1258096B | alloc=1258096B | hw=2598688B | I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Term | End | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4,a_5;i_3,i_2}:N-C-S) * t{a_3;i_4}:N-C-S) * t{a_1,a_2;i_1,i_5}:N-C-S
+  Eval | SumInplace | 30520958ns | result=1258096B | alloc=0B | hw=2598688B | I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Term | Begin | -6 (g{i_4,a_2;a_4,i_2}:N-C-S * t{a_1,a_4;i_1,i_3}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | Tensor | 10916750ns | result=8679736B | alloc=8679736B | hw=8762232B | g(i_4,a_2,a_4,i_2)
+  Eval | Tensor | 542ns | result=18864B | alloc=18864B | hw=101360B | t(a_1,a_4,i_1,i_3)
+  Eval | Product | 1023416ns | left=8679736B | right=18864B | result=74352B | alloc=74352B | hw=8855448B | g(i_4,a_2,a_4,i_2) * t(a_1,a_4,i_1,i_3) -> I(i_4,a_1,a_2,i_1,i_2,i_3)
+  Eval | Tensor | 292ns | result=640B | alloc=640B | hw=83136B | t(a_3,i_4)
+  Eval | Product | 7344500ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1415584B | I(i_4,a_1,a_2,i_1,i_2,i_3) * t(a_3,i_4) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 167ns | result=8B | alloc=8B | hw=82504B | -6
+  Eval | Product | 13659833ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598696B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13140250ns | result=1258096B | alloc=1258096B | hw=2598688B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -6 (g{i_4,a_2;a_4,i_2}:N-C-S * t{a_1,a_4;i_1,i_3}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 30891000ns | result=1258096B | alloc=0B | hw=2598688B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | -3 (f{i_4;a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_4}:N-C-S
+  Eval | Tensor | 14125ns | result=30504B | alloc=30504B | hw=113000B | f(i_4,a_4)
+  Eval | Tensor | 334ns | result=640B | alloc=640B | hw=83136B | t(a_4,i_3)
+  Eval | Product | 613416ns | left=30504B | right=640B | result=384B | alloc=384B | hw=114024B | f(i_4,a_4) * t(a_4,i_3) -> I(i_4,i_3)
+  Eval | Tensor | 250ns | result=1258096B | alloc=1258096B | hw=1340592B | t(a_1,a_2,a_3,i_1,i_2,i_4)
+  Eval | Product | 17831833ns | left=384B | right=1258096B | result=1258096B | alloc=1258096B | hw=2599072B | I(i_4,i_3) * t(a_1,a_2,a_3,i_1,i_2,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=82504B | -3
+  Eval | Product | 14002000ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598696B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17850000ns | result=1258096B | alloc=1258096B | hw=2598688B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -3 (f{i_4;a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 30777166ns | result=1258096B | alloc=0B | hw=2598688B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_1}:N-C-S) * t{a_1,a_4;i_5,i_3}:N-C-S) * t{a_2,a_3;i_2,i_4}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=6/10 | alive=17 | entry=1456B | total=82496B | g(i_4,i_5,a_4,a_5) * t(a_5,i_1) -> I(i_5,i_4,i_1,a_4)
+  Eval | Tensor | 333ns | result=18864B | alloc=18864B | hw=101360B | t(a_1,a_4,i_5,i_3)
+  Eval | Product | 651167ns | left=1456B | right=18864B | result=1456B | alloc=1456B | hw=102816B | I(i_5,i_4,i_1,a_4) * t(a_1,a_4,i_5,i_3) -> I(i_4,a_1,i_3,i_1)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=101360B | t(a_2,a_3,i_2,i_4)
+  Eval | Product | 7718000ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1360912B | I(i_4,a_1,i_3,i_1) * t(a_2,a_3,i_2,i_4) -> I(a_2,a_3,a_1,i_2,i_1,i_3)
+  Eval | Constant | 125ns | result=8B | alloc=8B | hw=82504B | 6
+  Eval | Product | 13377208ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598696B | I(a_2,a_3,a_1,i_2,i_1,i_3) * 6 -> I(a_2,a_3,a_1,i_2,i_1,i_3)
+  Eval | Permute | 17516750ns | result=1258096B | alloc=1258096B | hw=2598688B | I(a_2,a_3,a_1,i_2,i_1,i_3)
+  Term | End | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_1}:N-C-S) * t{a_1,a_4;i_5,i_3}:N-C-S) * t{a_2,a_3;i_2,i_4}:N-C-S
+  Eval | SumInplace | 30202458ns | result=1258096B | alloc=0B | hw=2598688B | I(a_2,a_3,a_1,i_2,i_1,i_3)
+  Term | Begin | -6 ((g{i_4,a_3;a_4,a_5}:N-C-S * t{a_5;i_3}:N-C-S) * t{a_2,a_4;i_2,i_1}:N-C-S) * t{a_1;i_4}:N-C-S
+  Cache | Access | key=8576080722563157927 | life=1/3 | alive=16 | entry=18864B | total=82496B | g(i_4,a_3,a_4,a_5) * t(a_5,i_3) -> I(i_4,a_3,i_3,a_4)
+  Eval | Tensor | 416ns | result=18864B | alloc=18864B | hw=101360B | t(a_2,a_4,i_2,i_1)
+  Eval | Product | 1099333ns | left=18864B | right=18864B | result=74352B | alloc=74352B | hw=175712B | I(i_4,a_3,i_3,a_4) * t(a_2,a_4,i_2,i_1) -> I(i_4,a_2,a_3,i_2,i_1,i_3)
+  Eval | Tensor | 250ns | result=640B | alloc=640B | hw=83136B | t(a_1,i_4)
+  Eval | Product | 7421208ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1415584B | I(i_4,a_2,a_3,i_2,i_1,i_3) * t(a_1,i_4) -> I(a_2,a_3,a_1,i_3,i_2,i_1)
+  Eval | Constant | 291ns | result=8B | alloc=8B | hw=82504B | -6
+  Eval | Product | 14139583ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598696B | I(a_2,a_3,a_1,i_3,i_2,i_1) * -6 -> I(a_2,a_3,a_1,i_3,i_2,i_1)
+  Eval | Permute | 13834708ns | result=1258096B | alloc=1258096B | hw=2598688B | I(a_2,a_3,a_1,i_3,i_2,i_1)
+  Term | End | -6 ((g{i_4,a_3;a_4,a_5}:N-C-S * t{a_5;i_3}:N-C-S) * t{a_2,a_4;i_2,i_1}:N-C-S) * t{a_1;i_4}:N-C-S
+  Eval | SumInplace | 29960834ns | result=1258096B | alloc=0B | hw=2598688B | I(a_2,a_3,a_1,i_3,i_2,i_1)
+  Term | Begin | -6 (g{i_4,a_3;i_2,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | Tensor | 14083ns | result=8679736B | alloc=8679736B | hw=8762232B | g(i_4,a_3,i_2,a_4)
+  Eval | Tensor | 167ns | result=640B | alloc=640B | hw=83136B | t(a_4,i_3)
+  Eval | Product | 230125ns | left=8679736B | right=640B | result=1456B | alloc=1456B | hw=8764328B | g(i_4,a_3,i_2,a_4) * t(a_4,i_3) -> I(i_4,a_3,i_2,i_3)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=101360B | t(a_1,a_2,i_1,i_4)
+  Eval | Product | 6716875ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1360912B | I(i_4,a_3,i_2,i_3) * t(a_1,a_2,i_1,i_4) -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Constant | 167ns | result=8B | alloc=8B | hw=82504B | -6
+  Eval | Product | 13234667ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598696B | I(a_1,a_3,a_2,i_1,i_3,i_2) * -6 -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Permute | 14585625ns | result=1258096B | alloc=1258096B | hw=2598688B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | End | -6 (g{i_4,a_3;i_2,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | SumInplace | 31403333ns | result=1258096B | alloc=0B | hw=2598688B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | Begin | -6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_5,i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S
+  Cache | Access | key=853172630937087824 | life=1/3 | alive=15 | entry=18864B | total=82496B | g(i_4,i_5,a_4,a_5) * t(a_3,a_5,i_5,i_3) -> I(i_4,a_3,i_3,a_4)
+  Eval | Tensor | 333ns | result=1258096B | alloc=1258096B | hw=1340592B | t(a_1,a_2,a_4,i_1,i_2,i_4)
+  Eval | Product | 19077292ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2598688B | I(i_4,a_3,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 208ns | result=8B | alloc=8B | hw=82504B | -6
+  Eval | Product | 13505250ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598696B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17640458ns | result=1258096B | alloc=1258096B | hw=2598688B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_5,i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 30535833ns | result=1258096B | alloc=0B | hw=2598688B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 3 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_4,a_5;i_3,i_1,i_2}:N-C-S) * t{a_1,a_2;i_4,i_5}:N-C-S
+  Cache | Release | key=6074554422931925897 | life=0/2 | alive=14 | entry=0B | total=77776B | g(i_4,i_5,a_4,a_5) * t(a_3,a_4,a_5,i_3,i_1,i_2) -> I(i_5,i_4,a_3,i_2,i_1,i_3)
+  Eval | Tensor | 791ns | result=18864B | alloc=18864B | hw=96640B | t(a_1,a_2,i_4,i_5)
+  Eval | Product | 7151750ns | left=4720B | right=18864B | result=1258096B | alloc=1258096B | hw=1359456B | I(i_5,i_4,a_3,i_2,i_1,i_3) * t(a_1,a_2,i_4,i_5) -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=77784B | 3
+  Eval | Product | 13695125ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2593976B | I(a_3,a_2,a_1,i_2,i_1,i_3) * 3 -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Permute | 18649750ns | result=1258096B | alloc=1258096B | hw=2593968B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | End | 3 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_4,a_5;i_3,i_1,i_2}:N-C-S) * t{a_1,a_2;i_4,i_5}:N-C-S
+  Eval | SumInplace | 30625375ns | result=1258096B | alloc=0B | hw=2593968B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | Begin | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4,a_5;i_4,i_1,i_2}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Eval | Tensor | 10558375ns | result=8679736B | alloc=8679736B | hw=8757512B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 750ns | result=1258096B | alloc=1258096B | hw=1335872B | t(a_1,a_4,a_5,i_4,i_1,i_2)
+  Eval | Product | 13280667ns | left=8679736B | right=1258096B | result=1456B | alloc=1456B | hw=10017064B | g(i_4,i_5,a_4,a_5) * t(a_1,a_4,a_5,i_4,i_1,i_2) -> I(i_5,a_1,i_2,i_1)
+  Eval | Tensor | 666ns | result=18864B | alloc=18864B | hw=96640B | t(a_2,a_3,i_5,i_3)
+  Eval | Product | 9233042ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1356192B | I(i_5,a_1,i_2,i_1) * t(a_2,a_3,i_5,i_3) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=77784B | 6
+  Eval | Product | 13680500ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2593976B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13644125ns | result=1258096B | alloc=1258096B | hw=2593968B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4,a_5;i_4,i_1,i_2}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Eval | SumInplace | 30304125ns | result=1258096B | alloc=0B | hw=2593968B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 (g{i_4,i_5;i_2,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_4,i_5}:N-C-S
+  Cache | Release | key=15940048826142671177 | life=0/3 | alive=13 | entry=0B | total=77344B | g(i_4,i_5,i_2,a_4) * t(a_4,i_3) -> I(i_4,i_5,i_2,i_3)
+  Eval | Tensor | 292ns | result=1258096B | alloc=1258096B | hw=1335440B | t(a_1,a_2,a_3,i_1,i_4,i_5)
+  Eval | Product | 16551792ns | left=432B | right=1258096B | result=1258096B | alloc=1258096B | hw=2593968B | I(i_4,i_5,i_2,i_3) * t(a_1,a_2,a_3,i_1,i_4,i_5) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=77352B | 6
+  Eval | Product | 13518000ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2593544B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 12941666ns | result=1258096B | alloc=1258096B | hw=2593536B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 (g{i_4,i_5;i_2,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_4,i_5}:N-C-S
+  Eval | SumInplace | 30873125ns | result=1258096B | alloc=0B | hw=2593536B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | -6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_2,a_5;i_4,i_3}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S
+  Eval | Tensor | 8750ns | result=163879224B | alloc=163879224B | hw=163956568B | g(i_4,a_3,a_4,a_5)
+  Eval | Tensor | 1250ns | result=18864B | alloc=18864B | hw=96208B | t(a_2,a_5,i_4,i_3)
+  Eval | Product | 4805167ns | left=163879224B | right=18864B | result=314800B | alloc=314800B | hw=164290232B | g(i_4,a_3,a_4,a_5) * t(a_2,a_5,i_4,i_3) -> I(a_2,a_3,i_3,a_4)
+  Eval | Tensor | 500ns | result=18864B | alloc=18864B | hw=96208B | t(a_1,a_4,i_1,i_2)
+  Eval | Product | 9288667ns | left=314800B | right=18864B | result=1258096B | alloc=1258096B | hw=1669104B | I(a_2,a_3,i_3,a_4) * t(a_1,a_4,i_1,i_2) -> I(a_1,a_3,a_2,i_1,i_2,i_3)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=77352B | -6
+  Eval | Product | 13917208ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2593544B | I(a_1,a_3,a_2,i_1,i_2,i_3) * -6 -> I(a_1,a_3,a_2,i_1,i_2,i_3)
+  Eval | Permute | 13541750ns | result=1258096B | alloc=1258096B | hw=2593536B | I(a_1,a_3,a_2,i_1,i_2,i_3)
+  Term | End | -6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_2,a_5;i_4,i_3}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S
+  Eval | SumInplace | 30374583ns | result=1258096B | alloc=0B | hw=2593536B | I(a_1,a_3,a_2,i_1,i_2,i_3)
+  Term | Begin | -3 f{i_4;i_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_2,i_4}:N-C-S
+  Eval | Tensor | 11709ns | result=2088B | alloc=2088B | hw=79432B | f(i_4,i_3)
+  Eval | Tensor | 375ns | result=1258096B | alloc=1258096B | hw=1335440B | t(a_1,a_2,a_3,i_1,i_2,i_4)
+  Eval | Product | 18935083ns | left=2088B | right=1258096B | result=1258096B | alloc=1258096B | hw=2595624B | f(i_4,i_3) * t(a_1,a_2,a_3,i_1,i_2,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 459ns | result=8B | alloc=8B | hw=77352B | -3
+  Eval | Product | 13390083ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2593544B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17566709ns | result=1258096B | alloc=1258096B | hw=2593536B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -3 f{i_4;i_3}:N-C-S * t{a_1,a_2,a_3;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 30278916ns | result=1258096B | alloc=0B | hw=2593536B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 3 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_5;i_2}:N-C-S) * t{a_1,a_2,a_3;i_4,i_5,i_3}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=5/10 | alive=12 | entry=1456B | total=77344B | g(i_4,i_5,a_4,a_5) * t(a_4,i_1) -> I(i_4,i_5,i_1,a_5)
+  Eval | Tensor | 834ns | result=640B | alloc=640B | hw=77984B | t(a_5,i_2)
+  Eval | Product | 652333ns | left=1456B | right=640B | result=432B | alloc=432B | hw=78416B | I(i_4,i_5,i_1,a_5) * t(a_5,i_2) -> I(i_5,i_4,i_2,i_1)
+  Cache | Store | key=1288916799981805547 | life=1/2 | alive=13 | entry=432B | total=77776B | I(i_4,i_5,i_1,a_5) * t(a_5,i_2) -> I(i_5,i_4,i_2,i_1)
+  Eval | Tensor | 208ns | result=1258096B | alloc=1258096B | hw=1335872B | t(a_1,a_2,a_3,i_4,i_5,i_3)
+  Eval | Product | 24287000ns | left=432B | right=1258096B | result=1258096B | alloc=1258096B | hw=2593968B | I(i_5,i_4,i_2,i_1) * t(a_1,a_2,a_3,i_4,i_5,i_3) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 416ns | result=8B | alloc=8B | hw=77784B | 3
+  Eval | Product | 13769250ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2593976B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 15573916ns | result=1258096B | alloc=1258096B | hw=2593968B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 3 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_5;i_2}:N-C-S) * t{a_1,a_2,a_3;i_4,i_5,i_3}:N-C-S
+  Eval | SumInplace | 30928708ns | result=1258096B | alloc=0B | hw=2593968B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 6 (g{i_4,i_5;i_1,a_4}:N-C-S * t{a_2,a_4;i_2,i_3}:N-C-S) * t{a_1,a_3;i_4,i_5}:N-C-S
+  Eval | Tensor | 12375ns | result=461112B | alloc=461112B | hw=538888B | g(i_4,i_5,i_1,a_4)
+  Eval | Tensor | 292ns | result=18864B | alloc=18864B | hw=96640B | t(a_2,a_4,i_2,i_3)
+  Eval | Product | 542042ns | left=461112B | right=18864B | result=4720B | alloc=4720B | hw=562472B | g(i_4,i_5,i_1,a_4) * t(a_2,a_4,i_2,i_3) -> I(i_4,i_5,a_2,i_3,i_1,i_2)
+  Cache | Store | key=5994811486625274629 | life=1/2 | alive=14 | entry=4720B | total=82496B | g(i_4,i_5,i_1,a_4) * t(a_2,a_4,i_2,i_3) -> I(i_4,i_5,a_2,i_3,i_1,i_2)
+  Eval | Tensor | 84ns | result=18864B | alloc=18864B | hw=101360B | t(a_1,a_3,i_4,i_5)
+  Eval | Product | 6772500ns | left=4720B | right=18864B | result=1258096B | alloc=1258096B | hw=1359456B | I(i_4,i_5,a_2,i_3,i_1,i_2) * t(a_1,a_3,i_4,i_5) -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Constant | 208ns | result=8B | alloc=8B | hw=82504B | 6
+  Eval | Product | 13547584ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598696B | I(a_1,a_3,a_2,i_1,i_3,i_2) * 6 -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Permute | 14363875ns | result=1258096B | alloc=1258096B | hw=2598688B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | End | 6 (g{i_4,i_5;i_1,a_4}:N-C-S * t{a_2,a_4;i_2,i_3}:N-C-S) * t{a_1,a_3;i_4,i_5}:N-C-S
+  Eval | SumInplace | 30549458ns | result=1258096B | alloc=0B | hw=2598688B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | Begin | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4;i_1,i_5}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S) * t{a_3;i_4}:N-C-S
+  Cache | Access | key=18006422551833664970 | life=1/3 | alive=13 | entry=18864B | total=82496B | g(i_4,i_5,a_4,a_5) * t(a_1,a_4,i_1,i_5) -> I(i_4,a_1,i_1,a_5)
+  Eval | Tensor | 875ns | result=18864B | alloc=18864B | hw=101360B | t(a_2,a_5,i_2,i_3)
+  Eval | Product | 1169167ns | left=18864B | right=18864B | result=74352B | alloc=74352B | hw=175712B | I(i_4,a_1,i_1,a_5) * t(a_2,a_5,i_2,i_3) -> I(i_4,a_2,a_1,i_2,i_3,i_1)
+  Eval | Tensor | 208ns | result=640B | alloc=640B | hw=83136B | t(a_3,i_4)
+  Eval | Product | 7593625ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1415584B | I(i_4,a_2,a_1,i_2,i_3,i_1) * t(a_3,i_4) -> I(a_2,a_1,a_3,i_2,i_3,i_1)
+  Eval | Constant | 375ns | result=8B | alloc=8B | hw=82504B | 6
+  Eval | Product | 13656000ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2598696B | I(a_2,a_1,a_3,i_2,i_3,i_1) * 6 -> I(a_2,a_1,a_3,i_2,i_3,i_1)
+  Eval | Permute | 14203167ns | result=1258096B | alloc=1258096B | hw=2598688B | I(a_2,a_1,a_3,i_2,i_3,i_1)
+  Term | End | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4;i_1,i_5}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 30944625ns | result=1258096B | alloc=0B | hw=2598688B | I(a_2,a_1,a_3,i_2,i_3,i_1)
+  Term | Begin | -6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_5;i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_4,i_2}:N-C-S
+  Cache | Release | key=8576080722563157927 | life=0/3 | alive=12 | entry=0B | total=63632B | g(i_4,a_3,a_4,a_5) * t(a_5,i_3) -> I(i_4,a_3,i_3,a_4)
+  Eval | Tensor | 459ns | result=1258096B | alloc=1258096B | hw=1321728B | t(a_1,a_2,a_4,i_1,i_4,i_2)
+  Eval | Product | 19389166ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2598688B | I(i_4,a_3,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_4,i_2) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=63640B | -6
+  Eval | Product | 13757750ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2579832B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 12847542ns | result=1258096B | alloc=1258096B | hw=2579824B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_5;i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_4,i_2}:N-C-S
+  Eval | SumInplace | 31492042ns | result=1258096B | alloc=0B | hw=2579824B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | -12 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4;i_1,i_4}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S) * t{a_3;i_5}:N-C-S
+  Cache | Access | key=14937657755075493246 | life=1/3 | alive=11 | entry=18864B | total=63632B | g(i_4,i_5,a_4,a_5) * t(a_1,a_4,i_1,i_4) -> I(i_5,a_1,i_1,a_5)
+  Eval | Tensor | 709ns | result=18864B | alloc=18864B | hw=82496B | t(a_2,a_5,i_2,i_3)
+  Eval | Product | 1219250ns | left=18864B | right=18864B | result=74352B | alloc=74352B | hw=156848B | I(i_5,a_1,i_1,a_5) * t(a_2,a_5,i_2,i_3) -> I(i_5,a_2,a_1,i_2,i_3,i_1)
+  Eval | Tensor | 333ns | result=640B | alloc=640B | hw=64272B | t(a_3,i_5)
+  Eval | Product | 7570083ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1396720B | I(i_5,a_2,a_1,i_2,i_3,i_1) * t(a_3,i_5) -> I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=63640B | -12
+  Eval | Product | 13716000ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2579832B | I(a_1,a_2,a_3,i_1,i_3,i_2) * -12 -> I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Eval | Permute | 14213875ns | result=1258096B | alloc=1258096B | hw=2579824B | I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Term | End | -12 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4;i_1,i_4}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S) * t{a_3;i_5}:N-C-S
+  Eval | SumInplace | 30807458ns | result=1258096B | alloc=0B | hw=2579824B | I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Term | Begin | 3 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_5}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_3}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | Tensor | 14167ns | result=8679736B | alloc=8679736B | hw=8743368B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 333ns | result=640B | alloc=640B | hw=64272B | t(a_4,i_5)
+  Eval | Product | 261666ns | left=8679736B | right=640B | result=640B | alloc=640B | hw=8744648B | g(i_4,i_5,a_4,a_5) * t(a_4,i_5) -> I(i_4,a_5)
+  Cache | Store | key=13613060045528791584 | life=2/3 | alive=13 | entry=640B | total=64272B | g(i_4,i_5,a_4,a_5) * t(a_4,i_5) -> I(i_4,a_5)
+  Eval | Tensor | 125ns | result=1258096B | alloc=1258096B | hw=1322368B | t(a_1,a_2,a_5,i_1,i_2,i_3)
+  Eval | Product | 11197500ns | left=640B | right=1258096B | result=74352B | alloc=74352B | hw=1396720B | I(i_4,a_5) * t(a_1,a_2,a_5,i_1,i_2,i_3) -> I(i_4,a_2,a_1,i_2,i_1,i_3)
+  Eval | Tensor | 125ns | result=640B | alloc=640B | hw=64912B | t(a_3,i_4)
+  Eval | Product | 7287667ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1397360B | I(i_4,a_2,a_1,i_2,i_1,i_3) * t(a_3,i_4) -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=64280B | 3
+  Eval | Product | 14206459ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2580472B | I(a_3,a_2,a_1,i_2,i_1,i_3) * 3 -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Permute | 17549667ns | result=1258096B | alloc=1258096B | hw=2580464B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | End | 3 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_5}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_3}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 31332208ns | result=1258096B | alloc=0B | hw=2580464B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | Begin | -12 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_3,i_5}:N-C-S) * t{a_1,a_2,a_4;i_1,i_4,i_2}:N-C-S
+  Cache | Release | key=14937657755075493246 | life=0/3 | alive=12 | entry=0B | total=45408B | g(i_4,i_5,a_4,a_5) * t(a_3,a_5,i_3,i_5) -> I(i_4,a_3,i_3,a_4)
+  Eval | Tensor | 458ns | result=1258096B | alloc=1258096B | hw=1303504B | t(a_1,a_2,a_4,i_1,i_4,i_2)
+  Eval | Product | 22284458ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2580464B | I(i_4,a_3,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_4,i_2) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 209ns | result=8B | alloc=8B | hw=45416B | -12
+  Eval | Product | 13709208ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2561608B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -12 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 12682833ns | result=1258096B | alloc=1258096B | hw=2561600B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -12 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_3,i_5}:N-C-S) * t{a_1,a_2,a_4;i_1,i_4,i_2}:N-C-S
+  Eval | SumInplace | 30610834ns | result=1258096B | alloc=0B | hw=2561600B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 g{a_3,a_2;i_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_2}:N-C-S
+  Eval | Tensor | 225673167ns | result=163879224B | alloc=163879224B | hw=163924632B | g(a_3,a_2,i_3,a_4)
+  Eval | Tensor | 1333ns | result=18864B | alloc=18864B | hw=64272B | t(a_1,a_4,i_1,i_2)
+  Eval | Product | 12482167ns | left=163879224B | right=18864B | result=1258096B | alloc=1258096B | hw=165201592B | g(a_3,a_2,i_3,a_4) * t(a_1,a_4,i_1,i_2) -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Constant | 1083ns | result=8B | alloc=8B | hw=45416B | 6
+  Eval | Product | 13744959ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2561608B | I(a_1,a_3,a_2,i_1,i_3,i_2) * 6 -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Permute | 13777625ns | result=1258096B | alloc=1258096B | hw=2561600B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | End | 6 g{a_3,a_2;i_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_2}:N-C-S
+  Eval | SumInplace | 30414625ns | result=1258096B | alloc=0B | hw=2561600B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | Begin | 6 (g{a_2,a_3;a_4,a_5}:N-C-S * t{a_5;i_3}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S
+  Eval | Tensor | 13875ns | result=3100868920B | alloc=3100868920B | hw=3100914328B | g(a_2,a_3,a_4,a_5)
+  Eval | Tensor | 1792ns | result=640B | alloc=640B | hw=46048B | t(a_5,i_3)
+  Eval | Product | 50984709ns | left=3100868920B | right=640B | result=314800B | alloc=314800B | hw=3101229768B | g(a_2,a_3,a_4,a_5) * t(a_5,i_3) -> I(a_2,a_3,i_3,a_4)
+  Eval | Tensor | 916ns | result=18864B | alloc=18864B | hw=64272B | t(a_1,a_4,i_1,i_2)
+  Eval | Product | 9362375ns | left=314800B | right=18864B | result=1258096B | alloc=1258096B | hw=1637168B | I(a_2,a_3,i_3,a_4) * t(a_1,a_4,i_1,i_2) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 584ns | result=8B | alloc=8B | hw=45416B | 6
+  Eval | Product | 13416459ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2561608B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13341125ns | result=1258096B | alloc=1258096B | hw=2561600B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 (g{a_2,a_3;a_4,a_5}:N-C-S * t{a_5;i_3}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S
+  Eval | SumInplace | 29622625ns | result=1258096B | alloc=0B | hw=2561600B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | -6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_4,a_5;i_2,i_3}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | Tensor | 221216833ns | result=163879224B | alloc=163879224B | hw=163924632B | g(i_4,a_3,a_4,a_5)
+  Eval | Tensor | 2000ns | result=18864B | alloc=18864B | hw=64272B | t(a_4,a_5,i_2,i_3)
+  Eval | Product | 3632125ns | left=163879224B | right=18864B | result=1456B | alloc=1456B | hw=163944952B | g(i_4,a_3,a_4,a_5) * t(a_4,a_5,i_2,i_3) -> I(i_4,a_3,i_2,i_3)
+  Eval | Tensor | 958ns | result=18864B | alloc=18864B | hw=64272B | t(a_1,a_2,i_1,i_4)
+  Eval | Product | 11232958ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1323824B | I(i_4,a_3,i_2,i_3) * t(a_1,a_2,i_1,i_4) -> I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Eval | Constant | 542ns | result=8B | alloc=8B | hw=45416B | -6
+  Eval | Product | 13958500ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2561608B | I(a_3,a_2,a_1,i_3,i_2,i_1) * -6 -> I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Eval | Permute | 14481958ns | result=1258096B | alloc=1258096B | hw=2561600B | I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Term | End | -6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_4,a_5;i_2,i_3}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | SumInplace | 30278667ns | result=1258096B | alloc=0B | hw=2561600B | I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Term | Begin | -12 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4,a_5;i_1,i_4,i_2}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Eval | Tensor | 14833ns | result=8679736B | alloc=8679736B | hw=8725144B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 500ns | result=1258096B | alloc=1258096B | hw=1303504B | t(a_1,a_4,a_5,i_1,i_4,i_2)
+  Eval | Product | 15628542ns | left=8679736B | right=1258096B | result=1456B | alloc=1456B | hw=9984696B | g(i_4,i_5,a_4,a_5) * t(a_1,a_4,a_5,i_1,i_4,i_2) -> I(i_5,a_1,i_2,i_1)
+  Eval | Tensor | 250ns | result=18864B | alloc=18864B | hw=64272B | t(a_2,a_3,i_5,i_3)
+  Eval | Product | 8873583ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1323824B | I(i_5,a_1,i_2,i_1) * t(a_2,a_3,i_5,i_3) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 83ns | result=8B | alloc=8B | hw=45416B | -12
+  Eval | Product | 14358833ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2561608B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -12 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13085916ns | result=1258096B | alloc=1258096B | hw=2561600B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -12 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4,a_5;i_1,i_4,i_2}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Eval | SumInplace | 31402500ns | result=1258096B | alloc=0B | hw=2561600B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | -6 (g{i_4,a_2;a_4,a_5}:N-C-S * t{a_1,a_4,a_5;i_1,i_3,i_2}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | Tensor | 9208ns | result=163879224B | alloc=163879224B | hw=163924632B | g(i_4,a_2,a_4,a_5)
+  Eval | Tensor | 1250ns | result=1258096B | alloc=1258096B | hw=1303504B | t(a_1,a_4,a_5,i_1,i_3,i_2)
+  Eval | Product | 16218167ns | left=163879224B | right=1258096B | result=74352B | alloc=74352B | hw=165257080B | g(i_4,a_2,a_4,a_5) * t(a_1,a_4,a_5,i_1,i_3,i_2) -> I(i_4,a_1,a_2,i_1,i_2,i_3)
+  Eval | Tensor | 1041ns | result=640B | alloc=640B | hw=46048B | t(a_3,i_4)
+  Eval | Product | 7320917ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1378496B | I(i_4,a_1,a_2,i_1,i_2,i_3) * t(a_3,i_4) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 84ns | result=8B | alloc=8B | hw=45416B | -6
+  Eval | Product | 13775042ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2561608B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 12941916ns | result=1258096B | alloc=1258096B | hw=2561600B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -6 (g{i_4,a_2;a_4,a_5}:N-C-S * t{a_1,a_4,a_5;i_1,i_3,i_2}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 29795583ns | result=1258096B | alloc=0B | hw=2561600B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | -6 ((g{i_4,a_3;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_5;i_3}:N-C-S) * t{a_1,a_2;i_4,i_2}:N-C-S
+  Eval | Tensor | 13209ns | result=163879224B | alloc=163879224B | hw=163924632B | g(i_4,a_3,a_4,a_5)
+  Eval | Tensor | 1417ns | result=640B | alloc=640B | hw=46048B | t(a_4,i_1)
+  Eval | Product | 3273583ns | left=163879224B | right=640B | result=18864B | alloc=18864B | hw=163944136B | g(i_4,a_3,a_4,a_5) * t(a_4,i_1) -> I(i_4,a_3,i_1,a_5)
+  Cache | Store | key=2837560362229546273 | life=3/4 | alive=15 | entry=18864B | total=64272B | g(i_4,a_3,a_4,a_5) * t(a_4,i_1) -> I(i_4,a_3,i_1,a_5)
+  Eval | Tensor | 958ns | result=640B | alloc=640B | hw=64912B | t(a_5,i_3)
+  Eval | Product | 193375ns | left=18864B | right=640B | result=1456B | alloc=1456B | hw=66368B | I(i_4,a_3,i_1,a_5) * t(a_5,i_3) -> I(i_4,a_3,i_1,i_3)
+  Eval | Tensor | 292ns | result=18864B | alloc=18864B | hw=83136B | t(a_1,a_2,i_4,i_2)
+  Eval | Product | 7593625ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1342688B | I(i_4,a_3,i_1,i_3) * t(a_1,a_2,i_4,i_2) -> I(a_2,a_3,a_1,i_3,i_2,i_1)
+  Eval | Constant | 458ns | result=8B | alloc=8B | hw=64280B | -6
+  Eval | Product | 13651958ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2580472B | I(a_2,a_3,a_1,i_3,i_2,i_1) * -6 -> I(a_2,a_3,a_1,i_3,i_2,i_1)
+  Eval | Permute | 13793583ns | result=1258096B | alloc=1258096B | hw=2580464B | I(a_2,a_3,a_1,i_3,i_2,i_1)
+  Term | End | -6 ((g{i_4,a_3;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_5;i_3}:N-C-S) * t{a_1,a_2;i_4,i_2}:N-C-S
+  Eval | SumInplace | 31113666ns | result=1258096B | alloc=0B | hw=2580464B | I(a_2,a_3,a_1,i_3,i_2,i_1)
+  Term | Begin | 6 (g{i_4,i_5;i_1,a_4}:N-C-S * t{a_3,a_4;i_3,i_4}:N-C-S) * t{a_1,a_2;i_5,i_2}:N-C-S
+  Eval | Tensor | 13208ns | result=461112B | alloc=461112B | hw=525384B | g(i_4,i_5,i_1,a_4)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=83136B | t(a_3,a_4,i_3,i_4)
+  Eval | Product | 621000ns | left=461112B | right=18864B | result=1456B | alloc=1456B | hw=545704B | g(i_4,i_5,i_1,a_4) * t(a_3,a_4,i_3,i_4) -> I(i_5,a_3,i_3,i_1)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=83136B | t(a_1,a_2,i_5,i_2)
+  Eval | Product | 7713375ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1342688B | I(i_5,a_3,i_3,i_1) * t(a_1,a_2,i_5,i_2) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=64280B | 6
+  Eval | Product | 13620500ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2580472B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 16890666ns | result=1258096B | alloc=1258096B | hw=2580464B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 6 (g{i_4,i_5;i_1,a_4}:N-C-S * t{a_3,a_4;i_3,i_4}:N-C-S) * t{a_1,a_2;i_5,i_2}:N-C-S
+  Eval | SumInplace | 31256292ns | result=1258096B | alloc=0B | hw=2580464B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 3 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_4,i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_5}:N-C-S
+  Eval | Tensor | 12667ns | result=8679736B | alloc=8679736B | hw=8744008B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 500ns | result=18864B | alloc=18864B | hw=83136B | t(a_3,a_5,i_4,i_3)
+  Eval | Product | 491084ns | left=8679736B | right=18864B | result=18864B | alloc=18864B | hw=8781736B | g(i_4,i_5,a_4,a_5) * t(a_3,a_5,i_4,i_3) -> I(i_5,a_3,i_3,a_4)
+  Cache | Store | key=13982275274528923534 | life=2/3 | alive=17 | entry=18864B | total=83136B | g(i_4,i_5,a_4,a_5) * t(a_3,a_5,i_4,i_3) -> I(i_5,a_3,i_3,a_4)
+  Eval | Tensor | 208ns | result=1258096B | alloc=1258096B | hw=1341232B | t(a_1,a_2,a_4,i_1,i_2,i_5)
+  Eval | Product | 18619500ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2599328B | I(i_5,a_3,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_5) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=83144B | 3
+  Eval | Product | 13461875ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17470584ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 3 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_4,i_3}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_5}:N-C-S
+  Eval | SumInplace | 30792125ns | result=1258096B | alloc=0B | hw=2599328B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3,a_5;i_1,i_5,i_3}:N-C-S) * t{a_2;i_4}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=4/10 | alive=16 | entry=1456B | total=83136B | g(i_4,i_5,a_4,a_5) * t(a_4,i_2) -> I(i_4,i_5,i_2,a_5)
+  Eval | Tensor | 334ns | result=1258096B | alloc=1258096B | hw=1341232B | t(a_1,a_3,a_5,i_1,i_5,i_3)
+  Eval | Product | 15315542ns | left=1456B | right=1258096B | result=74352B | alloc=74352B | hw=1415584B | I(i_4,i_5,i_2,a_5) * t(a_1,a_3,a_5,i_1,i_5,i_3) -> I(i_4,a_1,a_3,i_1,i_3,i_2)
+  Eval | Tensor | 292ns | result=640B | alloc=640B | hw=83776B | t(a_2,i_4)
+  Eval | Product | 7578000ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1416224B | I(i_4,a_1,a_3,i_1,i_3,i_2) * t(a_2,i_4) -> I(a_2,a_1,a_3,i_1,i_2,i_3)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=83144B | 6
+  Eval | Product | 14160875ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_2,a_1,a_3,i_1,i_2,i_3) * 6 -> I(a_2,a_1,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13227875ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_2,a_1,a_3,i_1,i_2,i_3)
+  Term | End | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3,a_5;i_1,i_5,i_3}:N-C-S) * t{a_2;i_4}:N-C-S
+  Eval | SumInplace | 31749541ns | result=1258096B | alloc=0B | hw=2599328B | I(a_2,a_1,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 (g{i_4,i_5;i_2,a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_4,i_3}:N-C-S) * t{a_3;i_5}:N-C-S
+  Eval | Tensor | 10666ns | result=461112B | alloc=461112B | hw=544248B | g(i_4,i_5,i_2,a_4)
+  Eval | Tensor | 334ns | result=1258096B | alloc=1258096B | hw=1341232B | t(a_1,a_2,a_4,i_1,i_4,i_3)
+  Eval | Product | 15731875ns | left=461112B | right=1258096B | result=74352B | alloc=74352B | hw=1876696B | g(i_4,i_5,i_2,a_4) * t(a_1,a_2,a_4,i_1,i_4,i_3) -> I(i_5,a_1,a_2,i_1,i_3,i_2)
+  Eval | Tensor | 250ns | result=640B | alloc=640B | hw=83776B | t(a_3,i_5)
+  Eval | Product | 7574958ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1416224B | I(i_5,a_1,a_2,i_1,i_3,i_2) * t(a_3,i_5) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 458ns | result=8B | alloc=8B | hw=83144B | 6
+  Eval | Product | 14004959ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13565750ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 (g{i_4,i_5;i_2,a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_4,i_3}:N-C-S) * t{a_3;i_5}:N-C-S
+  Eval | SumInplace | 29883125ns | result=1258096B | alloc=0B | hw=2599328B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4;i_5,i_3}:N-C-S) * t{a_2,a_5;i_2,i_1}:N-C-S) * t{a_3;i_4}:N-C-S
+  Cache | Access | key=13982275274528923534 | life=1/3 | alive=15 | entry=18864B | total=83136B | g(i_4,i_5,a_4,a_5) * t(a_1,a_4,i_5,i_3) -> I(i_4,a_1,i_3,a_5)
+  Eval | Tensor | 333ns | result=18864B | alloc=18864B | hw=102000B | t(a_2,a_5,i_2,i_1)
+  Eval | Product | 1107125ns | left=18864B | right=18864B | result=74352B | alloc=74352B | hw=176352B | I(i_4,a_1,i_3,a_5) * t(a_2,a_5,i_2,i_1) -> I(i_4,a_2,a_1,i_2,i_1,i_3)
+  Eval | Tensor | 166ns | result=640B | alloc=640B | hw=83776B | t(a_3,i_4)
+  Eval | Product | 7290625ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1416224B | I(i_4,a_2,a_1,i_2,i_1,i_3) * t(a_3,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 167ns | result=8B | alloc=8B | hw=83144B | 6
+  Eval | Product | 13958625ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17530834ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4;i_5,i_3}:N-C-S) * t{a_2,a_5;i_2,i_1}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 30696958ns | result=1258096B | alloc=0B | hw=2599328B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_4}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Cache | Access | key=13613060045528791584 | life=1/3 | alive=14 | entry=640B | total=83136B | g(i_4,i_5,a_4,a_5) * t(a_5,i_4) -> I(i_5,a_4)
+  Eval | Tensor | 834ns | result=18864B | alloc=18864B | hw=102000B | t(a_1,a_4,i_1,i_2)
+  Eval | Product | 645459ns | left=640B | right=18864B | result=1456B | alloc=1456B | hw=103456B | I(i_5,a_4) * t(a_1,a_4,i_1,i_2) -> I(i_5,a_1,i_2,i_1)
+  Eval | Tensor | 166ns | result=18864B | alloc=18864B | hw=102000B | t(a_2,a_3,i_5,i_3)
+  Eval | Product | 11146041ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1361552B | I(i_5,a_1,i_2,i_1) * t(a_2,a_3,i_5,i_3) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=83144B | 6
+  Eval | Product | 13568958ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13311667ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_4}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Eval | SumInplace | 29602083ns | result=1258096B | alloc=0B | hw=2599328B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | -3 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_4}:N-C-S
+  Cache | Access | key=2837560362229546273 | life=2/4 | alive=13 | entry=18864B | total=83136B | g(i_4,a_3,a_4,a_5) * t(a_4,i_3) -> I(i_4,a_3,i_3,a_5)
+  Eval | Tensor | 625ns | result=1258096B | alloc=1258096B | hw=1341232B | t(a_1,a_2,a_5,i_1,i_2,i_4)
+  Eval | Product | 18456000ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2599328B | I(i_4,a_3,i_3,a_5) * t(a_1,a_2,a_5,i_1,i_2,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 208ns | result=8B | alloc=8B | hw=83144B | -3
+  Eval | Product | 13660958ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17531875ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -3 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 30988000ns | result=1258096B | alloc=0B | hw=2599328B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_1,a_2,a_5;i_4,i_2,i_3}:N-C-S) * t{a_3;i_5}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=3/10 | alive=12 | entry=1456B | total=83136B | g(i_4,i_5,a_4,a_5) * t(a_4,i_1) -> I(i_4,i_5,i_1,a_5)
+  Eval | Tensor | 792ns | result=1258096B | alloc=1258096B | hw=1341232B | t(a_1,a_2,a_5,i_4,i_2,i_3)
+  Eval | Product | 11041500ns | left=1456B | right=1258096B | result=74352B | alloc=74352B | hw=1415584B | I(i_4,i_5,i_1,a_5) * t(a_1,a_2,a_5,i_4,i_2,i_3) -> I(i_5,a_2,a_1,i_2,i_3,i_1)
+  Eval | Tensor | 333ns | result=640B | alloc=640B | hw=83776B | t(a_3,i_5)
+  Eval | Product | 7341167ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1416224B | I(i_5,a_2,a_1,i_2,i_3,i_1) * t(a_3,i_5) -> I(a_3,a_1,a_2,i_1,i_2,i_3)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=83144B | 6
+  Eval | Product | 13991667ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_3,a_1,a_2,i_1,i_2,i_3) * 6 -> I(a_3,a_1,a_2,i_1,i_2,i_3)
+  Eval | Permute | 13758917ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_3,a_1,a_2,i_1,i_2,i_3)
+  Term | End | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_1,a_2,a_5;i_4,i_2,i_3}:N-C-S) * t{a_3;i_5}:N-C-S
+  Eval | SumInplace | 31331834ns | result=1258096B | alloc=0B | hw=2599328B | I(a_3,a_1,a_2,i_1,i_2,i_3)
+  Term | Begin | -6 g{i_4,a_3;i_2,i_3}:N-C-S * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | Tensor | 1092667ns | result=461112B | alloc=461112B | hw=544248B | g(i_4,a_3,i_2,i_3)
+  Eval | Tensor | 375ns | result=18864B | alloc=18864B | hw=102000B | t(a_1,a_2,i_1,i_4)
+  Eval | Product | 6927250ns | left=461112B | right=18864B | result=1258096B | alloc=1258096B | hw=1821208B | g(i_4,a_3,i_2,i_3) * t(a_1,a_2,i_1,i_4) -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Constant | 208ns | result=8B | alloc=8B | hw=83144B | -6
+  Eval | Product | 12595875ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_1,a_3,a_2,i_1,i_3,i_2) * -6 -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Permute | 14061042ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | End | -6 g{i_4,a_3;i_2,i_3}:N-C-S * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | SumInplace | 31475042ns | result=1258096B | alloc=0B | hw=2599328B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | Begin | 6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_3}:N-C-S
+  Eval | Tensor | 11375ns | result=163879224B | alloc=163879224B | hw=163962360B | g(i_4,a_3,a_4,a_5)
+  Eval | Tensor | 1000ns | result=640B | alloc=640B | hw=83776B | t(a_4,i_4)
+  Eval | Product | 3178125ns | left=163879224B | right=640B | result=4992B | alloc=4992B | hw=163967992B | g(i_4,a_3,a_4,a_5) * t(a_4,i_4) -> I(a_3,a_5)
+  Eval | Tensor | 709ns | result=1258096B | alloc=1258096B | hw=1341232B | t(a_1,a_2,a_5,i_1,i_2,i_3)
+  Eval | Product | 20780709ns | left=4992B | right=1258096B | result=1258096B | alloc=1258096B | hw=2604320B | I(a_3,a_5) * t(a_1,a_2,a_5,i_1,i_2,i_3) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 334ns | result=8B | alloc=8B | hw=83144B | 6
+  Eval | Product | 13468667ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 18186125ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_3}:N-C-S
+  Eval | SumInplace | 30624292ns | result=1258096B | alloc=0B | hw=2599328B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | -3 g{i_4,a_3;i_3,a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S
+  Eval | Tensor | 8917ns | result=8679736B | alloc=8679736B | hw=8762872B | g(i_4,a_3,i_3,a_4)
+  Eval | Tensor | 625ns | result=1258096B | alloc=1258096B | hw=1341232B | t(a_1,a_2,a_4,i_1,i_2,i_4)
+  Eval | Product | 20476417ns | left=8679736B | right=1258096B | result=1258096B | alloc=1258096B | hw=11279064B | g(i_4,a_3,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 458ns | result=8B | alloc=8B | hw=83144B | -3
+  Eval | Product | 13420958ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17715084ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -3 g{i_4,a_3;i_3,a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 30279292ns | result=1258096B | alloc=0B | hw=2599328B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_2}:N-C-S) * t{a_3,a_4;i_3,i_5}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=2/10 | alive=11 | entry=1456B | total=83136B | g(i_4,i_5,a_4,a_5) * t(a_5,i_2) -> I(i_5,i_4,i_2,a_4)
+  Eval | Tensor | 583ns | result=18864B | alloc=18864B | hw=102000B | t(a_3,a_4,i_3,i_5)
+  Eval | Product | 675792ns | left=1456B | right=18864B | result=1456B | alloc=1456B | hw=103456B | I(i_5,i_4,i_2,a_4) * t(a_3,a_4,i_3,i_5) -> I(i_4,a_3,i_3,i_2)
+  Eval | Tensor | 208ns | result=18864B | alloc=18864B | hw=102000B | t(a_1,a_2,i_1,i_4)
+  Eval | Product | 7895334ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1361552B | I(i_4,a_3,i_3,i_2) * t(a_1,a_2,i_1,i_4) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 167ns | result=8B | alloc=8B | hw=83144B | 6
+  Eval | Product | 13395167ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 12842958ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_2}:N-C-S) * t{a_3,a_4;i_3,i_5}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | SumInplace | 30588458ns | result=1258096B | alloc=0B | hw=2599328B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_2}:N-C-S) * t{a_1,a_4;i_1,i_3}:N-C-S) * t{a_2,a_3;i_5,i_4}:N-C-S
+  Cache | Access | key=6322769425051513756 | life=1/10 | alive=10 | entry=1456B | total=83136B | g(i_4,i_5,a_4,a_5) * t(a_5,i_2) -> I(i_5,i_4,i_2,a_4)
+  Eval | Tensor | 583ns | result=18864B | alloc=18864B | hw=102000B | t(a_1,a_4,i_1,i_3)
+  Eval | Product | 646292ns | left=1456B | right=18864B | result=4720B | alloc=4720B | hw=106720B | I(i_5,i_4,i_2,a_4) * t(a_1,a_4,i_1,i_3) -> I(i_4,i_5,a_1,i_3,i_2,i_1)
+  Cache | Store | key=47978033300314424 | life=1/2 | alive=11 | entry=4720B | total=87856B | I(i_5,i_4,i_2,a_4) * t(a_1,a_4,i_1,i_3) -> I(i_4,i_5,a_1,i_3,i_2,i_1)
+  Eval | Tensor | 208ns | result=18864B | alloc=18864B | hw=106720B | t(a_2,a_3,i_5,i_4)
+  Eval | Product | 6815042ns | left=4720B | right=18864B | result=1258096B | alloc=1258096B | hw=1364816B | I(i_4,i_5,a_1,i_3,i_2,i_1) * t(a_2,a_3,i_5,i_4) -> I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Eval | Constant | 125ns | result=8B | alloc=8B | hw=87864B | 6
+  Eval | Product | 13318042ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2604056B | I(a_1,a_2,a_3,i_1,i_3,i_2) * 6 -> I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Eval | Permute | 13960750ns | result=1258096B | alloc=1258096B | hw=2604048B | I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Term | End | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_2}:N-C-S) * t{a_1,a_4;i_1,i_3}:N-C-S) * t{a_2,a_3;i_5,i_4}:N-C-S
+  Eval | SumInplace | 29950500ns | result=1258096B | alloc=0B | hw=2604048B | I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Term | Begin | 6 ((g{i_4,i_5;i_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_2;i_5}:N-C-S) * t{a_3;i_4}:N-C-S
+  Cache | Release | key=5994811486625274629 | life=0/2 | alive=10 | entry=0B | total=83136B | g(i_4,i_5,i_3,a_4) * t(a_1,a_4,i_1,i_2) -> I(i_4,i_5,a_1,i_2,i_3,i_1)
+  Eval | Tensor | 625ns | result=640B | alloc=640B | hw=83776B | t(a_2,i_5)
+  Eval | Product | 1065625ns | left=4720B | right=640B | result=74352B | alloc=74352B | hw=162848B | I(i_4,i_5,a_1,i_2,i_3,i_1) * t(a_2,i_5) -> I(i_4,a_1,a_2,i_1,i_3,i_2)
+  Eval | Tensor | 166ns | result=640B | alloc=640B | hw=83776B | t(a_3,i_4)
+  Eval | Product | 7392500ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1416224B | I(i_4,a_1,a_2,i_1,i_3,i_2) * t(a_3,i_4) -> I(a_3,a_1,a_2,i_1,i_3,i_2)
+  Eval | Constant | 291ns | result=8B | alloc=8B | hw=83144B | 6
+  Eval | Product | 13324167ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_3,a_1,a_2,i_1,i_3,i_2) * 6 -> I(a_3,a_1,a_2,i_1,i_3,i_2)
+  Eval | Permute | 14250292ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_3,a_1,a_2,i_1,i_3,i_2)
+  Term | End | 6 ((g{i_4,i_5;i_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_2;i_5}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 29720917ns | result=1258096B | alloc=0B | hw=2599328B | I(a_3,a_1,a_2,i_1,i_3,i_2)
+  Term | Begin | -12 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_5}:N-C-S) * t{a_3,a_4;i_3,i_2}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | Tensor | 12291ns | result=8679736B | alloc=8679736B | hw=8762872B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 541ns | result=640B | alloc=640B | hw=83776B | t(a_5,i_5)
+  Eval | Product | 273791ns | left=8679736B | right=640B | result=640B | alloc=640B | hw=8764152B | g(i_4,i_5,a_4,a_5) * t(a_5,i_5) -> I(i_4,a_4)
+  Cache | Store | key=12860816093799665187 | life=2/3 | alive=12 | entry=640B | total=83776B | g(i_4,i_5,a_4,a_5) * t(a_5,i_5) -> I(i_4,a_4)
+  Eval | Tensor | 375ns | result=18864B | alloc=18864B | hw=102640B | t(a_3,a_4,i_3,i_2)
+  Eval | Product | 149875ns | left=640B | right=18864B | result=1456B | alloc=1456B | hw=104096B | I(i_4,a_4) * t(a_3,a_4,i_3,i_2) -> I(i_4,a_3,i_2,i_3)
+  Eval | Tensor | 83ns | result=18864B | alloc=18864B | hw=102640B | t(a_1,a_2,i_1,i_4)
+  Eval | Product | 7295250ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1362192B | I(i_4,a_3,i_2,i_3) * t(a_1,a_2,i_1,i_4) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 458ns | result=8B | alloc=8B | hw=83784B | -12
+  Eval | Product | 13762459ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599976B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -12 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 12771375ns | result=1258096B | alloc=1258096B | hw=2599968B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -12 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_5}:N-C-S) * t{a_3,a_4;i_3,i_2}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
+  Eval | SumInplace | 30608833ns | result=1258096B | alloc=0B | hw=2599968B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | -6 (g{i_4,a_2;a_4,i_2}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_3;i_1,i_4}:N-C-S
+  Eval | Tensor | 11762417ns | result=8679736B | alloc=8679736B | hw=8763512B | g(i_4,a_2,a_4,i_2)
+  Eval | Tensor | 875ns | result=640B | alloc=640B | hw=84416B | t(a_4,i_3)
+  Eval | Product | 258792ns | left=8679736B | right=640B | result=1456B | alloc=1456B | hw=8765608B | g(i_4,a_2,a_4,i_2) * t(a_4,i_3) -> I(i_4,a_2,i_3,i_2)
+  Eval | Tensor | 250ns | result=18864B | alloc=18864B | hw=102640B | t(a_1,a_3,i_1,i_4)
+  Eval | Product | 6834209ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1362192B | I(i_4,a_2,i_3,i_2) * t(a_1,a_3,i_1,i_4) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 458ns | result=8B | alloc=8B | hw=83784B | -6
+  Eval | Product | 14647792ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599976B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13531125ns | result=1258096B | alloc=1258096B | hw=2599968B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -6 (g{i_4,a_2;a_4,i_2}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_3;i_1,i_4}:N-C-S
+  Eval | SumInplace | 30516791ns | result=1258096B | alloc=0B | hw=2599968B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | -6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_5;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_5}:N-C-S
+  Cache | Access | key=12860816093799665187 | life=1/3 | alive=11 | entry=640B | total=83776B | g(i_4,i_5,a_4,a_5) * t(a_4,i_4) -> I(i_5,a_5)
+  Eval | Tensor | 500ns | result=640B | alloc=640B | hw=84416B | t(a_5,i_3)
+  Eval | Product | 604333ns | left=640B | right=640B | result=384B | alloc=384B | hw=84800B | I(i_5,a_5) * t(a_5,i_3) -> I(i_5,i_3)
+  Eval | Tensor | 209ns | result=1258096B | alloc=1258096B | hw=1341872B | t(a_1,a_2,a_3,i_1,i_2,i_5)
+  Eval | Product | 16617167ns | left=384B | right=1258096B | result=1258096B | alloc=1258096B | hw=2600352B | I(i_5,i_3) * t(a_1,a_2,a_3,i_1,i_2,i_5) -> I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=83784B | -6
+  Eval | Product | 13891375ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599976B | I(a_2,a_1,a_3,i_3,i_2,i_1) * -6 -> I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Eval | Permute | 13855500ns | result=1258096B | alloc=1258096B | hw=2599968B | I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Term | End | -6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_5;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_5}:N-C-S
+  Eval | SumInplace | 30385917ns | result=1258096B | alloc=0B | hw=2599968B | I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Term | Begin | -6 (g{i_4,i_5;i_3,a_4}:N-C-S * t{a_4;i_5}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_4}:N-C-S
+  Eval | Tensor | 923917ns | result=461112B | alloc=461112B | hw=544888B | g(i_4,i_5,i_3,a_4)
+  Eval | Tensor | 500ns | result=640B | alloc=640B | hw=84416B | t(a_4,i_5)
+  Eval | Product | 102416ns | left=461112B | right=640B | result=384B | alloc=384B | hw=545912B | g(i_4,i_5,i_3,a_4) * t(a_4,i_5) -> I(i_4,i_3)
+  Eval | Tensor | 250ns | result=1258096B | alloc=1258096B | hw=1341872B | t(a_1,a_2,a_3,i_1,i_2,i_4)
+  Eval | Product | 17419042ns | left=384B | right=1258096B | result=1258096B | alloc=1258096B | hw=2600352B | I(i_4,i_3) * t(a_1,a_2,a_3,i_1,i_2,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 416ns | result=8B | alloc=8B | hw=83784B | -6
+  Eval | Product | 14245209ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599976B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 18198417ns | result=1258096B | alloc=1258096B | hw=2599968B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -6 (g{i_4,i_5;i_3,a_4}:N-C-S * t{a_4;i_5}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 30887334ns | result=1258096B | alloc=0B | hw=2599968B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | -6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_4,i_5}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_3}:N-C-S
+  Eval | Tensor | 10570875ns | result=8679736B | alloc=8679736B | hw=8763512B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 833ns | result=18864B | alloc=18864B | hw=102640B | t(a_3,a_5,i_4,i_5)
+  Eval | Product | 457500ns | left=8679736B | right=18864B | result=4992B | alloc=4992B | hw=8787368B | g(i_4,i_5,a_4,a_5) * t(a_3,a_5,i_4,i_5) -> I(a_3,a_4)
+  Eval | Tensor | 250ns | result=1258096B | alloc=1258096B | hw=1341872B | t(a_1,a_2,a_4,i_1,i_2,i_3)
+  Eval | Product | 21415291ns | left=4992B | right=1258096B | result=1258096B | alloc=1258096B | hw=2604960B | I(a_3,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_3) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 625ns | result=8B | alloc=8B | hw=83784B | -6
+  Eval | Product | 13740417ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599976B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 18118292ns | result=1258096B | alloc=1258096B | hw=2599968B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_5;i_4,i_5}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_3}:N-C-S
+  Eval | SumInplace | 31354542ns | result=1258096B | alloc=0B | hw=2599968B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 3 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_4}:N-C-S) * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_5}:N-C-S
+  Cache | Release | key=13613060045528791584 | life=0/3 | alive=10 | entry=0B | total=83136B | g(i_4,i_5,a_4,a_5) * t(a_5,i_4) -> I(i_5,a_4)
+  Eval | Tensor | 833ns | result=640B | alloc=640B | hw=83776B | t(a_4,i_3)
+  Eval | Product | 657666ns | left=640B | right=640B | result=384B | alloc=384B | hw=84800B | I(i_5,a_4) * t(a_4,i_3) -> I(i_5,i_3)
+  Eval | Tensor | 250ns | result=1258096B | alloc=1258096B | hw=1341232B | t(a_1,a_2,a_3,i_1,i_2,i_5)
+  Eval | Product | 17814000ns | left=384B | right=1258096B | result=1258096B | alloc=1258096B | hw=2599712B | I(i_5,i_3) * t(a_1,a_2,a_3,i_1,i_2,i_5) -> I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Eval | Constant | 417ns | result=8B | alloc=8B | hw=83144B | 3
+  Eval | Product | 13258750ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2599336B | I(a_2,a_1,a_3,i_3,i_2,i_1) * 3 -> I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Eval | Permute | 14421875ns | result=1258096B | alloc=1258096B | hw=2599328B | I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Term | End | 3 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_5;i_4}:N-C-S) * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_5}:N-C-S
+  Eval | SumInplace | 31050792ns | result=1258096B | alloc=0B | hw=2599328B | I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Term | Begin | -6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_5}:N-C-S) * t{a_3;i_4}:N-C-S
+  Cache | Release | key=6322769425051513756 | life=0/10 | alive=9 | entry=0B | total=81680B | g(i_4,i_5,a_4,a_5) * t(a_4,i_3) -> I(i_4,i_5,i_3,a_5)
+  Eval | Tensor | 917ns | result=1258096B | alloc=1258096B | hw=1339776B | t(a_1,a_2,a_5,i_1,i_2,i_5)
+  Eval | Product | 11675708ns | left=1456B | right=1258096B | result=74352B | alloc=74352B | hw=1415584B | I(i_4,i_5,i_3,a_5) * t(a_1,a_2,a_5,i_1,i_2,i_5) -> I(i_4,a_2,a_1,i_2,i_1,i_3)
+  Eval | Tensor | 583ns | result=640B | alloc=640B | hw=82320B | t(a_3,i_4)
+  Eval | Product | 7442917ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1414768B | I(i_4,a_2,a_1,i_2,i_1,i_3) * t(a_3,i_4) -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Constant | 375ns | result=8B | alloc=8B | hw=81688B | -6
+  Eval | Product | 14326500ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2597880B | I(a_3,a_2,a_1,i_2,i_1,i_3) * -6 -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Permute | 17575709ns | result=1258096B | alloc=1258096B | hw=2597872B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | End | -6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_5}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 31976834ns | result=1258096B | alloc=0B | hw=2597872B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | Begin | -6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4,a_5;i_4,i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_5}:N-C-S
+  Eval | Tensor | 13667ns | result=8679736B | alloc=8679736B | hw=8761416B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 291ns | result=18864B | alloc=18864B | hw=100544B | t(a_4,a_5,i_4,i_3)
+  Eval | Product | 1037750ns | left=8679736B | right=18864B | result=384B | alloc=384B | hw=8780664B | g(i_4,i_5,a_4,a_5) * t(a_4,a_5,i_4,i_3) -> I(i_5,i_3)
+  Eval | Tensor | 166ns | result=1258096B | alloc=1258096B | hw=1339776B | t(a_1,a_2,a_3,i_1,i_2,i_5)
+  Eval | Product | 17399250ns | left=384B | right=1258096B | result=1258096B | alloc=1258096B | hw=2598256B | I(i_5,i_3) * t(a_1,a_2,a_3,i_1,i_2,i_5) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=81688B | -6
+  Eval | Product | 13523875ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2597880B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17672833ns | result=1258096B | alloc=1258096B | hw=2597872B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4,a_5;i_4,i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_5}:N-C-S
+  Eval | SumInplace | 30156375ns | result=1258096B | alloc=0B | hw=2597872B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | -6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_3}:N-C-S) * t{a_3;i_5}:N-C-S
+  Cache | Release | key=12860816093799665187 | life=0/3 | alive=8 | entry=0B | total=81040B | g(i_4,i_5,a_4,a_5) * t(a_4,i_4) -> I(i_5,a_5)
+  Eval | Tensor | 792ns | result=1258096B | alloc=1258096B | hw=1339136B | t(a_1,a_2,a_5,i_1,i_2,i_3)
+  Eval | Product | 10437583ns | left=640B | right=1258096B | result=74352B | alloc=74352B | hw=1414128B | I(i_5,a_5) * t(a_1,a_2,a_5,i_1,i_2,i_3) -> I(i_5,a_2,a_1,i_2,i_1,i_3)
+  Eval | Tensor | 292ns | result=640B | alloc=640B | hw=81680B | t(a_3,i_5)
+  Eval | Product | 7406791ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1414128B | I(i_5,a_2,a_1,i_2,i_1,i_3) * t(a_3,i_5) -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Constant | 459ns | result=8B | alloc=8B | hw=81048B | -6
+  Eval | Product | 14626542ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2597240B | I(a_3,a_2,a_1,i_2,i_1,i_3) * -6 -> I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Eval | Permute | 17330166ns | result=1258096B | alloc=1258096B | hw=2597232B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | End | -6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_3}:N-C-S) * t{a_3;i_5}:N-C-S
+  Eval | SumInplace | 29909208ns | result=1258096B | alloc=0B | hw=2597232B | I(a_3,a_2,a_1,i_2,i_1,i_3)
+  Term | Begin | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_4;i_3,i_5}:N-C-S) * t{a_1,a_2,a_5;i_1,i_4,i_2}:N-C-S
+  Cache | Release | key=18006422551833664970 | life=0/3 | alive=7 | entry=0B | total=62176B | g(i_4,i_5,a_4,a_5) * t(a_3,a_4,i_3,i_5) -> I(i_4,a_3,i_3,a_5)
+  Eval | Tensor | 375ns | result=1258096B | alloc=1258096B | hw=1320272B | t(a_1,a_2,a_5,i_1,i_4,i_2)
+  Eval | Product | 21323458ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2597232B | I(i_4,a_3,i_3,a_5) * t(a_1,a_2,a_5,i_1,i_4,i_2) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=62184B | 6
+  Eval | Product | 13200125ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2578376B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 12639333ns | result=1258096B | alloc=1258096B | hw=2578368B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_4;i_3,i_5}:N-C-S) * t{a_1,a_2,a_5;i_1,i_4,i_2}:N-C-S
+  Eval | SumInplace | 30851500ns | result=1258096B | alloc=0B | hw=2578368B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_2,a_4,a_5;i_2,i_1,i_4}:N-C-S) * t{a_1,a_3;i_5,i_3}:N-C-S
+  Eval | Tensor | 14542ns | result=8679736B | alloc=8679736B | hw=8741912B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 334ns | result=1258096B | alloc=1258096B | hw=1320272B | t(a_2,a_4,a_5,i_2,i_1,i_4)
+  Eval | Product | 12790167ns | left=8679736B | right=1258096B | result=1456B | alloc=1456B | hw=10001464B | g(i_4,i_5,a_4,a_5) * t(a_2,a_4,a_5,i_2,i_1,i_4) -> I(i_5,a_2,i_1,i_2)
+  Eval | Tensor | 333ns | result=18864B | alloc=18864B | hw=81040B | t(a_1,a_3,i_5,i_3)
+  Eval | Product | 11081875ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1340592B | I(i_5,a_2,i_1,i_2) * t(a_1,a_3,i_5,i_3) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 416ns | result=8B | alloc=8B | hw=62184B | 6
+  Eval | Product | 14444250ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2578376B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 6 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17746000ns | result=1258096B | alloc=1258096B | hw=2578368B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_2,a_4,a_5;i_2,i_1,i_4}:N-C-S) * t{a_1,a_3;i_5,i_3}:N-C-S
+  Eval | SumInplace | 30492500ns | result=1258096B | alloc=0B | hw=2578368B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | -3 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_5;i_4}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_3}:N-C-S
+  Eval | Tensor | 12834ns | result=163879224B | alloc=163879224B | hw=163941400B | g(i_4,a_3,a_4,a_5)
+  Eval | Tensor | 1083ns | result=640B | alloc=640B | hw=62816B | t(a_5,i_4)
+  Eval | Product | 3190666ns | left=163879224B | right=640B | result=4992B | alloc=4992B | hw=163947032B | g(i_4,a_3,a_4,a_5) * t(a_5,i_4) -> I(a_3,a_4)
+  Eval | Tensor | 1000ns | result=1258096B | alloc=1258096B | hw=1320272B | t(a_1,a_2,a_4,i_1,i_2,i_3)
+  Eval | Product | 22350541ns | left=4992B | right=1258096B | result=1258096B | alloc=1258096B | hw=2583360B | I(a_3,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_3) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 542ns | result=8B | alloc=8B | hw=62184B | -3
+  Eval | Product | 13625333ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2578376B | I(a_2,a_1,a_3,i_2,i_1,i_3) * -3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 18018792ns | result=1258096B | alloc=1258096B | hw=2578368B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | -3 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_5;i_4}:N-C-S) * t{a_1,a_2,a_4;i_1,i_2,i_3}:N-C-S
+  Eval | SumInplace | 29821791ns | result=1258096B | alloc=0B | hw=2578368B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4;i_4,i_1}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S) * t{a_3;i_5}:N-C-S
+  Cache | Release | key=853172630937087824 | life=0/3 | alive=6 | entry=0B | total=43312B | g(i_4,i_5,a_4,a_5) * t(a_1,a_4,i_4,i_1) -> I(i_5,a_1,i_1,a_5)
+  Eval | Tensor | 625ns | result=18864B | alloc=18864B | hw=62176B | t(a_2,a_5,i_2,i_3)
+  Eval | Product | 1464583ns | left=18864B | right=18864B | result=74352B | alloc=74352B | hw=155392B | I(i_5,a_1,i_1,a_5) * t(a_2,a_5,i_2,i_3) -> I(i_5,a_2,a_1,i_2,i_3,i_1)
+  Eval | Tensor | 167ns | result=640B | alloc=640B | hw=43952B | t(a_3,i_5)
+  Eval | Product | 7537000ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1376400B | I(i_5,a_2,a_1,i_2,i_3,i_1) * t(a_3,i_5) -> I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Eval | Constant | 208ns | result=8B | alloc=8B | hw=43320B | 6
+  Eval | Product | 14076250ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2559512B | I(a_1,a_2,a_3,i_1,i_3,i_2) * 6 -> I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Eval | Permute | 14107458ns | result=1258096B | alloc=1258096B | hw=2559504B | I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Term | End | 6 ((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_1,a_4;i_4,i_1}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S) * t{a_3;i_5}:N-C-S
+  Eval | SumInplace | 30909375ns | result=1258096B | alloc=0B | hw=2559504B | I(a_1,a_2,a_3,i_1,i_3,i_2)
+  Term | Begin | 3 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_4;i_4,i_5}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_3}:N-C-S
+  Eval | Tensor | 12083ns | result=8679736B | alloc=8679736B | hw=8723048B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 666ns | result=18864B | alloc=18864B | hw=62176B | t(a_3,a_4,i_4,i_5)
+  Eval | Product | 448542ns | left=8679736B | right=18864B | result=4992B | alloc=4992B | hw=8746904B | g(i_4,i_5,a_4,a_5) * t(a_3,a_4,i_4,i_5) -> I(a_3,a_5)
+  Eval | Tensor | 83ns | result=1258096B | alloc=1258096B | hw=1301408B | t(a_1,a_2,a_5,i_1,i_2,i_3)
+  Eval | Product | 21794000ns | left=4992B | right=1258096B | result=1258096B | alloc=1258096B | hw=2564496B | I(a_3,a_5) * t(a_1,a_2,a_5,i_1,i_2,i_3) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=43320B | 3
+  Eval | Product | 13470458ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2559512B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17803250ns | result=1258096B | alloc=1258096B | hw=2559504B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 3 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_3,a_4;i_4,i_5}:N-C-S) * t{a_1,a_2,a_5;i_1,i_2,i_3}:N-C-S
+  Eval | SumInplace | 30418709ns | result=1258096B | alloc=0B | hw=2559504B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | -6 (g{i_4,a_2;i_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | Tensor | 11792ns | result=8679736B | alloc=8679736B | hw=8723048B | g(i_4,a_2,i_3,a_4)
+  Eval | Tensor | 292ns | result=18864B | alloc=18864B | hw=62176B | t(a_1,a_4,i_1,i_2)
+  Eval | Product | 886042ns | left=8679736B | right=18864B | result=74352B | alloc=74352B | hw=8816264B | g(i_4,a_2,i_3,a_4) * t(a_1,a_4,i_1,i_2) -> I(i_4,a_1,a_2,i_1,i_3,i_2)
+  Eval | Tensor | 250ns | result=640B | alloc=640B | hw=43952B | t(a_3,i_4)
+  Eval | Product | 7620084ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1376400B | I(i_4,a_1,a_2,i_1,i_3,i_2) * t(a_3,i_4) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 375ns | result=8B | alloc=8B | hw=43320B | -6
+  Eval | Product | 14070042ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2559512B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13871583ns | result=1258096B | alloc=1258096B | hw=2559504B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -6 (g{i_4,a_2;i_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 29446417ns | result=1258096B | alloc=0B | hw=2559504B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 (((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_5;i_2}:N-C-S) * t{a_1;i_4}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Cache | Release | key=1288916799981805547 | life=0/2 | alive=5 | entry=0B | total=42880B | I(i_4,i_5,i_1,a_5) * t(a_5,i_2) -> I(i_5,i_4,i_2,i_1)
+  Eval | Tensor | 541ns | result=640B | alloc=640B | hw=43520B | t(a_1,i_4)
+  Eval | Product | 818875ns | left=432B | right=640B | result=1456B | alloc=1456B | hw=45408B | I(i_5,i_4,i_2,i_1) * t(a_1,i_4) -> I(i_5,a_1,i_2,i_1)
+  Eval | Tensor | 167ns | result=18864B | alloc=18864B | hw=61744B | t(a_2,a_3,i_5,i_3)
+  Eval | Product | 10813000ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1321296B | I(i_5,a_1,i_2,i_1) * t(a_2,a_3,i_5,i_3) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=42888B | 6
+  Eval | Product | 13817667ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2559080B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 12891708ns | result=1258096B | alloc=1258096B | hw=2559072B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 (((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_5;i_2}:N-C-S) * t{a_1;i_4}:N-C-S) * t{a_2,a_3;i_5,i_3}:N-C-S
+  Eval | SumInplace | 30544667ns | result=1258096B | alloc=0B | hw=2559072B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 (((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S) * t{a_1;i_4}:N-C-S) * t{a_3;i_5}:N-C-S
+  Cache | Release | key=47978033300314424 | life=0/2 | alive=4 | entry=0B | total=38160B | I(i_4,i_5,i_1,a_5) * t(a_2,a_5,i_2,i_3) -> I(i_5,i_4,a_2,i_3,i_1,i_2)
+  Eval | Tensor | 250ns | result=640B | alloc=640B | hw=38800B | t(a_1,i_4)
+  Eval | Product | 1251125ns | left=4720B | right=640B | result=74352B | alloc=74352B | hw=117872B | I(i_5,i_4,a_2,i_3,i_1,i_2) * t(a_1,i_4) -> I(i_5,a_2,a_1,i_1,i_2,i_3)
+  Eval | Tensor | 41ns | result=640B | alloc=640B | hw=38800B | t(a_3,i_5)
+  Eval | Product | 7717667ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1371248B | I(i_5,a_2,a_1,i_1,i_2,i_3) * t(a_3,i_5) -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=38168B | 6
+  Eval | Product | 14214750ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2554360B | I(a_1,a_3,a_2,i_1,i_3,i_2) * 6 -> I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Eval | Permute | 14141583ns | result=1258096B | alloc=1258096B | hw=2554352B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | End | 6 (((g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S) * t{a_1;i_4}:N-C-S) * t{a_3;i_5}:N-C-S
+  Eval | SumInplace | 30831625ns | result=1258096B | alloc=0B | hw=2554352B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  Term | Begin | -6 (g{i_4,a_2;a_4,a_5}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_3,a_5;i_1,i_4,i_2}:N-C-S
+  Cache | Access | key=2837560362229546273 | life=1/4 | alive=3 | entry=18864B | total=38160B | g(i_4,a_2,a_4,a_5) * t(a_4,i_3) -> I(i_4,a_2,i_3,a_5)
+  Eval | Tensor | 417ns | result=1258096B | alloc=1258096B | hw=1296256B | t(a_1,a_3,a_5,i_1,i_4,i_2)
+  Eval | Product | 20550292ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2554352B | I(i_4,a_2,i_3,a_5) * t(a_1,a_3,a_5,i_1,i_4,i_2) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 292ns | result=8B | alloc=8B | hw=38168B | -6
+  Eval | Product | 13407583ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2554360B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 12725625ns | result=1258096B | alloc=1258096B | hw=2554352B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -6 (g{i_4,a_2;a_4,a_5}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_3,a_5;i_1,i_4,i_2}:N-C-S
+  Eval | SumInplace | 30762208ns | result=1258096B | alloc=0B | hw=2554352B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | -6 (f{i_4;a_4}:N-C-S * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_2,a_3;i_4,i_3}:N-C-S
+  Eval | Tensor | 13791ns | result=30504B | alloc=30504B | hw=68664B | f(i_4,a_4)
+  Eval | Tensor | 334ns | result=18864B | alloc=18864B | hw=57024B | t(a_1,a_4,i_1,i_2)
+  Eval | Product | 851792ns | left=30504B | right=18864B | result=1456B | alloc=1456B | hw=88984B | f(i_4,a_4) * t(a_1,a_4,i_1,i_2) -> I(i_4,a_1,i_2,i_1)
+  Eval | Tensor | 125ns | result=18864B | alloc=18864B | hw=57024B | t(a_2,a_3,i_4,i_3)
+  Eval | Product | 10945042ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1316576B | I(i_4,a_1,i_2,i_1) * t(a_2,a_3,i_4,i_3) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=38168B | -6
+  Eval | Product | 14722375ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2554360B | I(a_1,a_2,a_3,i_1,i_2,i_3) * -6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13247333ns | result=1258096B | alloc=1258096B | hw=2554352B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | -6 (f{i_4;a_4}:N-C-S * t{a_1,a_4;i_1,i_2}:N-C-S) * t{a_2,a_3;i_4,i_3}:N-C-S
+  Eval | SumInplace | 30504667ns | result=1258096B | alloc=0B | hw=2554352B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_2,a_5;i_4,i_3}:N-C-S) * t{a_1,a_3,a_4;i_1,i_5,i_2}:N-C-S
+  Cache | Release | key=13982275274528923534 | life=0/3 | alive=2 | entry=0B | total=19296B | g(i_4,i_5,a_4,a_5) * t(a_2,a_5,i_4,i_3) -> I(i_5,a_2,i_3,a_4)
+  Eval | Tensor | 417ns | result=1258096B | alloc=1258096B | hw=1277392B | t(a_1,a_3,a_4,i_1,i_5,i_2)
+  Eval | Product | 20271667ns | left=18864B | right=1258096B | result=1258096B | alloc=1258096B | hw=2554352B | I(i_5,a_2,i_3,a_4) * t(a_1,a_3,a_4,i_1,i_5,i_2) -> I(a_1,a_3,a_2,i_1,i_2,i_3)
+  Eval | Constant | 125ns | result=8B | alloc=8B | hw=19304B | 6
+  Eval | Product | 13969375ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535496B | I(a_1,a_3,a_2,i_1,i_2,i_3) * 6 -> I(a_1,a_3,a_2,i_1,i_2,i_3)
+  Eval | Permute | 13434292ns | result=1258096B | alloc=1258096B | hw=2535488B | I(a_1,a_3,a_2,i_1,i_2,i_3)
+  Term | End | 6 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_2,a_5;i_4,i_3}:N-C-S) * t{a_1,a_3,a_4;i_1,i_5,i_2}:N-C-S
+  Eval | SumInplace | 30043959ns | result=1258096B | alloc=0B | hw=2535488B | I(a_1,a_3,a_2,i_1,i_2,i_3)
+  Term | Begin | 3 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4,a_5;i_5,i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_4}:N-C-S
+  Eval | Tensor | 11500ns | result=8679736B | alloc=8679736B | hw=8699032B | g(i_4,i_5,a_4,a_5)
+  Eval | Tensor | 584ns | result=18864B | alloc=18864B | hw=38160B | t(a_4,a_5,i_5,i_3)
+  Eval | Product | 994458ns | left=8679736B | right=18864B | result=384B | alloc=384B | hw=8718280B | g(i_4,i_5,a_4,a_5) * t(a_4,a_5,i_5,i_3) -> I(i_4,i_3)
+  Eval | Tensor | 83ns | result=1258096B | alloc=1258096B | hw=1277392B | t(a_1,a_2,a_3,i_1,i_2,i_4)
+  Eval | Product | 18230000ns | left=384B | right=1258096B | result=1258096B | alloc=1258096B | hw=2535872B | I(i_4,i_3) * t(a_1,a_2,a_3,i_1,i_2,i_4) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 375ns | result=8B | alloc=8B | hw=19304B | 3
+  Eval | Product | 13503375ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535496B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17648291ns | result=1258096B | alloc=1258096B | hw=2535488B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 3 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4,a_5;i_5,i_3}:N-C-S) * t{a_1,a_2,a_3;i_1,i_2,i_4}:N-C-S
+  Eval | SumInplace | 31331667ns | result=1258096B | alloc=0B | hw=2535488B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | Begin | -6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_1,a_5;i_1,i_4}:N-C-S) * t{a_2,a_4;i_2,i_3}:N-C-S
+  Eval | Tensor | 11583ns | result=163879224B | alloc=163879224B | hw=163898520B | g(i_4,a_3,a_4,a_5)
+  Eval | Tensor | 1125ns | result=18864B | alloc=18864B | hw=38160B | t(a_1,a_5,i_1,i_4)
+  Eval | Product | 4897125ns | left=163879224B | right=18864B | result=314800B | alloc=314800B | hw=164232184B | g(i_4,a_3,a_4,a_5) * t(a_1,a_5,i_1,i_4) -> I(a_3,a_1,i_1,a_4)
+  Eval | Tensor | 833ns | result=18864B | alloc=18864B | hw=38160B | t(a_2,a_4,i_2,i_3)
+  Eval | Product | 9181958ns | left=314800B | right=18864B | result=1258096B | alloc=1258096B | hw=1611056B | I(a_3,a_1,i_1,a_4) * t(a_2,a_4,i_2,i_3) -> I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Eval | Constant | 417ns | result=8B | alloc=8B | hw=19304B | -6
+  Eval | Product | 13331083ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535496B | I(a_2,a_3,a_1,i_2,i_3,i_1) * -6 -> I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Eval | Permute | 13895042ns | result=1258096B | alloc=1258096B | hw=2535488B | I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Term | End | -6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_1,a_5;i_1,i_4}:N-C-S) * t{a_2,a_4;i_2,i_3}:N-C-S
+  Eval | SumInplace | 31158792ns | result=1258096B | alloc=0B | hw=2535488B | I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Term | Begin | 3 g{i_4,i_5;i_1,i_2}:N-C-S * t{a_1,a_2,a_3;i_4,i_5,i_3}:N-C-S
+  Eval | Tensor | 10458ns | result=24888B | alloc=24888B | hw=44184B | g(i_4,i_5,i_1,i_2)
+  Eval | Tensor | 250ns | result=1258096B | alloc=1258096B | hw=1277392B | t(a_1,a_2,a_3,i_4,i_5,i_3)
+  Eval | Product | 20266916ns | left=24888B | right=1258096B | result=1258096B | alloc=1258096B | hw=2560376B | g(i_4,i_5,i_1,i_2) * t(a_1,a_2,a_3,i_4,i_5,i_3) -> I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Eval | Constant | 500ns | result=8B | alloc=8B | hw=19304B | 3
+  Eval | Product | 13699042ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535496B | I(a_2,a_1,a_3,i_3,i_2,i_1) * 3 -> I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Eval | Permute | 14317291ns | result=1258096B | alloc=1258096B | hw=2535488B | I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Term | End | 3 g{i_4,i_5;i_1,i_2}:N-C-S * t{a_1,a_2,a_3;i_4,i_5,i_3}:N-C-S
+  Eval | SumInplace | 31183750ns | result=1258096B | alloc=0B | hw=2535488B | I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Term | Begin | 6 (g{i_4,i_5;i_3,a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_5,i_2}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | Tensor | 15083ns | result=461112B | alloc=461112B | hw=480408B | g(i_4,i_5,i_3,a_4)
+  Eval | Tensor | 708ns | result=1258096B | alloc=1258096B | hw=1277392B | t(a_1,a_2,a_4,i_1,i_5,i_2)
+  Eval | Product | 16025500ns | left=461112B | right=1258096B | result=74352B | alloc=74352B | hw=1812856B | g(i_4,i_5,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_5,i_2) -> I(i_4,a_1,a_2,i_1,i_3,i_2)
+  Eval | Tensor | 667ns | result=640B | alloc=640B | hw=19936B | t(a_3,i_4)
+  Eval | Product | 7444791ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1352384B | I(i_4,a_1,a_2,i_1,i_3,i_2) * t(a_3,i_4) -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=19304B | 6
+  Eval | Product | 13430458ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535496B | I(a_1,a_2,a_3,i_1,i_2,i_3) * 6 -> I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Eval | Permute | 13325125ns | result=1258096B | alloc=1258096B | hw=2535488B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | End | 6 (g{i_4,i_5;i_3,a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_5,i_2}:N-C-S) * t{a_3;i_4}:N-C-S
+  Eval | SumInplace | 30473417ns | result=1258096B | alloc=0B | hw=2535488B | I(a_1,a_2,a_3,i_1,i_2,i_3)
+  Term | Begin | -12 (g{i_4,i_5;i_2,a_4}:N-C-S * t{a_1,a_4;i_1,i_5}:N-C-S) * t{a_2,a_3;i_4,i_3}:N-C-S
+  Eval | Tensor | 9125ns | result=461112B | alloc=461112B | hw=480408B | g(i_4,i_5,i_2,a_4)
+  Eval | Tensor | 417ns | result=18864B | alloc=18864B | hw=38160B | t(a_1,a_4,i_1,i_5)
+  Eval | Product | 864167ns | left=461112B | right=18864B | result=1456B | alloc=1456B | hw=500728B | g(i_4,i_5,i_2,a_4) * t(a_1,a_4,i_1,i_5) -> I(i_4,a_1,i_1,i_2)
+  Eval | Tensor | 84ns | result=18864B | alloc=18864B | hw=38160B | t(a_2,a_3,i_4,i_3)
+  Eval | Product | 7743041ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1297712B | I(i_4,a_1,i_1,i_2) * t(a_2,a_3,i_4,i_3) -> I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Eval | Constant | 333ns | result=8B | alloc=8B | hw=19304B | -12
+  Eval | Product | 14384250ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535496B | I(a_3,a_2,a_1,i_3,i_2,i_1) * -12 -> I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Eval | Permute | 14089417ns | result=1258096B | alloc=1258096B | hw=2535488B | I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Term | End | -12 (g{i_4,i_5;i_2,a_4}:N-C-S * t{a_1,a_4;i_1,i_5}:N-C-S) * t{a_2,a_3;i_4,i_3}:N-C-S
+  Eval | SumInplace | 30142959ns | result=1258096B | alloc=0B | hw=2535488B | I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Term | Begin | 6 (g{i_4,i_5;i_2,a_4}:N-C-S * t{a_1,a_4;i_5,i_1}:N-C-S) * t{a_2,a_3;i_4,i_3}:N-C-S
+  Eval | Tensor | 13584ns | result=461112B | alloc=461112B | hw=480408B | g(i_4,i_5,i_2,a_4)
+  Eval | Tensor | 291ns | result=18864B | alloc=18864B | hw=38160B | t(a_1,a_4,i_5,i_1)
+  Eval | Product | 828667ns | left=461112B | right=18864B | result=1456B | alloc=1456B | hw=500728B | g(i_4,i_5,i_2,a_4) * t(a_1,a_4,i_5,i_1) -> I(i_4,a_1,i_1,i_2)
+  Eval | Tensor | 166ns | result=18864B | alloc=18864B | hw=38160B | t(a_2,a_3,i_4,i_3)
+  Eval | Product | 7775167ns | left=1456B | right=18864B | result=1258096B | alloc=1258096B | hw=1297712B | I(i_4,a_1,i_1,i_2) * t(a_2,a_3,i_4,i_3) -> I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Eval | Constant | 291ns | result=8B | alloc=8B | hw=19304B | 6
+  Eval | Product | 13886083ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535496B | I(a_3,a_2,a_1,i_3,i_2,i_1) * 6 -> I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Eval | Permute | 14373250ns | result=1258096B | alloc=1258096B | hw=2535488B | I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Term | End | 6 (g{i_4,i_5;i_2,a_4}:N-C-S * t{a_1,a_4;i_5,i_1}:N-C-S) * t{a_2,a_3;i_4,i_3}:N-C-S
+  Eval | SumInplace | 30863125ns | result=1258096B | alloc=0B | hw=2535488B | I(a_3,a_2,a_1,i_3,i_2,i_1)
+  Term | Begin | -6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_1,a_4;i_4,i_1}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S
+  Eval | Tensor | 7584ns | result=163879224B | alloc=163879224B | hw=163898520B | g(i_4,a_3,a_4,a_5)
+  Eval | Tensor | 916ns | result=18864B | alloc=18864B | hw=38160B | t(a_1,a_4,i_4,i_1)
+  Eval | Product | 4964625ns | left=163879224B | right=18864B | result=314800B | alloc=314800B | hw=164232184B | g(i_4,a_3,a_4,a_5) * t(a_1,a_4,i_4,i_1) -> I(a_1,a_3,i_1,a_5)
+  Eval | Tensor | 750ns | result=18864B | alloc=18864B | hw=38160B | t(a_2,a_5,i_2,i_3)
+  Eval | Product | 9188500ns | left=314800B | right=18864B | result=1258096B | alloc=1258096B | hw=1611056B | I(a_1,a_3,i_1,a_5) * t(a_2,a_5,i_2,i_3) -> I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Eval | Constant | 416ns | result=8B | alloc=8B | hw=19304B | -6
+  Eval | Product | 14215334ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535496B | I(a_2,a_3,a_1,i_2,i_3,i_1) * -6 -> I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Eval | Permute | 14268333ns | result=1258096B | alloc=1258096B | hw=2535488B | I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Term | End | -6 (g{i_4,a_3;a_4,a_5}:N-C-S * t{a_1,a_4;i_4,i_1}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S
+  Eval | SumInplace | 30241708ns | result=1258096B | alloc=0B | hw=2535488B | I(a_2,a_3,a_1,i_2,i_3,i_1)
+  Term | Begin | 3 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4,a_5;i_1,i_2}:N-C-S) * t{a_1,a_2,a_3;i_4,i_5,i_3}:N-C-S
+  Cache | Release | key=8037026140499556789 | life=0/2 | alive=1 | entry=0B | total=18864B | g(i_4,i_5,a_4,a_5) * t(a_4,a_5,i_1,i_2) -> I(i_5,i_4,i_2,i_1)
+  Eval | Tensor | 625ns | result=1258096B | alloc=1258096B | hw=1276960B | t(a_1,a_2,a_3,i_4,i_5,i_3)
+  Eval | Product | 20038125ns | left=432B | right=1258096B | result=1258096B | alloc=1258096B | hw=2535488B | I(i_5,i_4,i_2,i_1) * t(a_1,a_2,a_3,i_4,i_5,i_3) -> I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=18872B | 3
+  Eval | Product | 14098917ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2535064B | I(a_2,a_1,a_3,i_3,i_2,i_1) * 3 -> I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Eval | Permute | 14289459ns | result=1258096B | alloc=1258096B | hw=2535056B | I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Term | End | 3 (g{i_4,i_5;a_4,a_5}:N-C-S * t{a_4,a_5;i_1,i_2}:N-C-S) * t{a_1,a_2,a_3;i_4,i_5,i_3}:N-C-S
+  Eval | SumInplace | 30738917ns | result=1258096B | alloc=0B | hw=2535056B | I(a_2,a_1,a_3,i_3,i_2,i_1)
+  Term | Begin | -6 ((g{i_4,a_3;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S) * t{a_1;i_4}:N-C-S
+  Cache | Release | key=2837560362229546273 | life=0/4 | alive=0 | entry=0B | total=0B | g(i_4,a_3,a_4,a_5) * t(a_4,i_1) -> I(i_4,a_3,i_1,a_5)
+  Eval | Tensor | 625ns | result=18864B | alloc=18864B | hw=18864B | t(a_2,a_5,i_2,i_3)
+  Eval | Product | 1652625ns | left=18864B | right=18864B | result=74352B | alloc=74352B | hw=112080B | I(i_4,a_3,i_1,a_5) * t(a_2,a_5,i_2,i_3) -> I(i_4,a_2,a_3,i_2,i_3,i_1)
+  Eval | Tensor | 334ns | result=640B | alloc=640B | hw=640B | t(a_1,i_4)
+  Eval | Product | 7684625ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1333088B | I(i_4,a_2,a_3,i_2,i_3,i_1) * t(a_1,i_4) -> I(a_2,a_3,a_1,i_1,i_2,i_3)
+  Eval | Constant | 208ns | result=8B | alloc=8B | hw=8B | -6
+  Eval | Product | 14007792ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2516200B | I(a_2,a_3,a_1,i_1,i_2,i_3) * -6 -> I(a_2,a_3,a_1,i_1,i_2,i_3)
+  Eval | Permute | 13236375ns | result=1258096B | alloc=1258096B | hw=2516192B | I(a_2,a_3,a_1,i_1,i_2,i_3)
+  Term | End | -6 ((g{i_4,a_3;a_4,a_5}:N-C-S * t{a_4;i_1}:N-C-S) * t{a_2,a_5;i_2,i_3}:N-C-S) * t{a_1;i_4}:N-C-S
+  Eval | SumInplace | 32102458ns | result=1258096B | alloc=0B | hw=2516192B | I(a_2,a_3,a_1,i_1,i_2,i_3)
+  Term | Begin | 3 (g{i_4,i_5;i_3,a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S) * t{a_3;i_5}:N-C-S
+  Eval | Tensor | 10417ns | result=461112B | alloc=461112B | hw=461112B | g(i_4,i_5,i_3,a_4)
+  Eval | Tensor | 292ns | result=1258096B | alloc=1258096B | hw=1258096B | t(a_1,a_2,a_4,i_1,i_2,i_4)
+  Eval | Product | 12813208ns | left=461112B | right=1258096B | result=74352B | alloc=74352B | hw=1793560B | g(i_4,i_5,i_3,a_4) * t(a_1,a_2,a_4,i_1,i_2,i_4) -> I(i_5,a_2,a_1,i_2,i_1,i_3)
+  Eval | Tensor | 250ns | result=640B | alloc=640B | hw=640B | t(a_3,i_5)
+  Eval | Product | 7530875ns | left=74352B | right=640B | result=1258096B | alloc=1258096B | hw=1333088B | I(i_5,a_2,a_1,i_2,i_1,i_3) * t(a_3,i_5) -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Constant | 250ns | result=8B | alloc=8B | hw=8B | 3
+  Eval | Product | 14231583ns | left=1258096B | right=8B | result=1258096B | alloc=1258096B | hw=2516200B | I(a_2,a_1,a_3,i_2,i_1,i_3) * 3 -> I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Permute | 17887333ns | result=1258096B | alloc=1258096B | hw=2516192B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Term | End | 3 (g{i_4,i_5;i_3,a_4}:N-C-S * t{a_1,a_2,a_4;i_1,i_2,i_4}:N-C-S) * t{a_3;i_5}:N-C-S
+  Eval | SumInplace | 29960750ns | result=1258096B | alloc=0B | hw=2516192B | I(a_2,a_1,a_3,i_2,i_1,i_3)
+  Eval | Symmetrize | 184660500ns | result=1258096B | alloc=1258096B | hw=2516192B | I(a_1,a_3,a_2,i_1,i_3,i_2)
+  iter         delta      residual             energy    total time/s
+    1    7.40199e-01    1.25712e-06   -0.740198699763          34.9
+
+   Warning!! Exceed Max Iteration!
+  CCk Energy  -0.7401986997628317
+  Time in CCk: 37.058809375000003 S
   Output KeyVal (format=JSON):
   {
       "units": "2010CODATA",
-      "molecule": {
-          "type": "Molecule",
-          "file_name": "he16.xyz",
-          "charge": "0"
+      "atoms": {
+          "file_name": "C2H6.xyz",
+          "sort_input": "true",
+          "charge": "0",
+          "n_cluster": "1",
+          "tile_size": "4"
       },
       "obs": {
-          "type": "Basis",
           "name": "cc-pVTZ",
-          "molecule": "$:molecule"
+          "atoms": "$:atoms"
       },
       "dfbs": {
-          "type": "Basis",
           "name": "cc-pVTZ-RI",
-          "molecule": "$:molecule"
+          "atoms": "$:atoms"
       },
       "wfn_world": {
-          "molecule": "$:molecule",
+          "atoms": "$:atoms",
           "basis": "$:obs",
           "df_basis": "$:dfbs"
       },
-      "localizer": {
-          "type": "FBLocalizer",
-          "max_iter": "1000",
-          "convergence": "1e-5",
-          "wfn_world": "$:wfn_world"
-      },
       "scf": {
           "type": "DirectDF-RHF",
-          "wfn_world": "$:wfn_world",
-          "localizer": "$:localizer"
-      },
-      "pno": {
-          "type": "PaoPnoRMP2",
-          "atoms": "$:atoms",
-          "wfn_world": "$:wfn_world",
-          "ref": "$:scf",
-          "unit_csv_tile_size": "true",
-          "use osvs": "true",
-          "tpno": "1e-7",
-          "tosv": "1e-9",
-          "tC": "1e-4",
-          "ldf integrals": "true",
-          "Fast E": "false",
-          "Fast Zir": "false",
-          "Fast Zia": "false",
-          "tSpao": "1e-8",
-          "tIA": "7e-4",
-          "tIX": "1e-4",
-          "tIJ": "1e-6",
-          "tRS": "1e-9",
-          "tFIJ": "1e-4"
+          "wfn_world": "$:wfn_world"
       },
       "wfn": {
           "type": "CCk",
-          "_csv": {
-              "provider": "$:pno",
-              "tIJ": "3e-5"
-          },
-          "method": "df",
           "wfn_world": "$:wfn_world",
-          "molecule": "$:molecule",
+          "atoms": "$:atoms",
+          "method": "df",
           "ref": "$:scf",
-          "localizer": "$:localizer",
+          "frozen_core": "true",
           "occ_tile_size": "4",
-          "uocc_tile_size": "50",
-          "tile_size": "200",
-          "export_orbitals": "false",
-          "max_iter": "50",
-          "seq_opt": "true",
-          "cache_imeds": "true",
-          "k": "2",
+          "uocc_tile_size": "4",
+          "k": "3",
+          "spinorbital": "false",
+          "max_iter": "1",
           "sequant": {
               "trace": {
-                  "eval": "true"
+                  "eval": "true",
+                  "eval_level": "1"
               }
           }
       },
       "property": {
           "type": "Energy",
-          "precision": "1e-7",
+          "precision": "1e-10",
           "wfn": "$:wfn",
           "value": {
-              "value": "-46.408060173738775"
+              "value": "-79.999617373439676"
           }
       }
   }
diff --git a/doc/user/guide/sequant.nu b/doc/user/guide/sequant.nu
deleted file mode 100644
index 43b937865b..0000000000
--- a/doc/user/guide/sequant.nu
+++ /dev/null
@@ -1,87 +0,0 @@
-use std/assert
-
-const pattern = {
-
-  #
-  # A line prefixed by:
-  #   - zero or more spaces
-  #   - followed by one of [Term, Eval, Cache]
-  #   - followed by one or more spaces, and
-  #   - followed by the separator character
-  # is _potentially_ a trace produced by sequant.
-  #
-  trace: '^\s*(Term|Eval|Cache)\s+\|' # The sep char '|' is escaped: '\|'.
-  separator: '|'
-}
-
-# Because of a bug -- that is fixed in future version of nushell
-# need to convert to the filesize value smartly.
-def "as filesize" [] {
-  $in | str trim --right --char 'B' | into float | into filesize
-}
-
-def "read log" [file: string] {
-    grep -n -E -e $pattern.trace $file
-      | parse --regex '(?<line>\d+):\s*(?<trace>.*)'
-      | each {
-        let line = $in.line
-        let fields = $in.trace
-                     | split row $pattern.separator
-                     | str trim
-        match $fields {
-          [$tag0 $tag1 ..$rest] => {
-                      {tag0 : $tag0
-                       tag1 : $tag1
-                       trace: $rest
-                       line : ($line | into int) } }
-          }
-        }
-}
-
-def "new-cols eval" [] {
-    {
-      time   : ($in.0 | into duration)
-      memory : ($in.1 | as filesize)
-      annot  : $in.2
-    }
-}
-
-def "new-cols cache" [] {
-  {
-    key    : $in.0
-    life   : $in.1
-    nalive : ($in.2 | into int)
-    memory : ($in.3 | as filesize)
-  }
-}
-
-def make-tag [tag: string, make_col: closure] {
-  let entry = $in | where tag0 == $tag
-  let new_cols = $entry.trace | each { do $make_col }
-  $entry | select tag0 tag1
-         | merge $new_cols
-         | merge ($entry | select line)
-}
-
-export def "trace cache" [file: string] {
-  read log $file | make-tag 'Cache' { new-cols cache }
-}
-
-export def "trace eval" [
-            file: string # The text file with sequant evaluation trace.
-            ] {
-  read log $file | make-tag 'Eval' { new-cols eval }
-}
-
-export def "trace term" [file: string] {
-  let lines = read log $file | where tag0 == 'Term'
-  let begs  = $lines | every 2
-  let ends  = $lines | skip 1 | every 2 | append [null]
-  $begs | zip $ends
-        | each { match $in { [$b, $e] => { assert (($e == null) or ($b.trace.0 == $e.trace.0))
-                                           { tag0  : $b.tag0
-                                             begin : $b.line
-                                             end   : (if ($e == null) { "❎" } else { $e.line })
-                                             expr  : $b.trace.0
-                                           } } } }
-}
diff --git a/doc/user/guide/sequant_trace.py b/doc/user/guide/sequant_trace.py
new file mode 100644
index 0000000000..a0b0215120
--- /dev/null
+++ b/doc/user/guide/sequant_trace.py
@@ -0,0 +1,312 @@
+"""Parsers for SeQuant evaluation traces.
+
+A trace is a stream of pipe-delimited lines emitted by the evaluator;
+each line is one of three kinds, identified by its first token:
+
+    Eval  | <mode> | <time> | [left=L | right=R |] result=X | alloc=A | hw=H | <label>
+    Cache | <mode> | key=K  | life=c/m | alive=N | entry=E | total=T | <label>
+    Term  | Begin  | <expr>
+    Term  | End    | <expr>
+
+The trace may be embedded in a larger log; lines that don't start with
+one of the three tags are skipped. The parsers concatenate every trace
+event in the file — if the log covers more than one iteration (or any
+other repeated context), the caller is responsible for slicing rows by
+line range or term before computing aggregates.
+
+Public API:
+    parse(path)        -> (eval_rows, cache_rows, term_rows)   one-pass
+    trace_eval(path)   -> generator of EvalRow
+    trace_cache(path)  -> generator of CacheRow
+    trace_term(path)   -> list of TermRow
+    format_table(rows, columns=..., max_rows=...) -> str
+    print_table(...)   -> prints format_table output
+
+Row types are NamedTuples. Unknown key=value fields land in row.extras
+so a future evaluator column survives without a parser change.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import NamedTuple
+
+
+_LINE_TAGS = frozenset({"Eval", "Cache", "Term"})
+_KV_RE = re.compile(r"^([A-Za-z_]+)=(.+)$")
+
+_EVAL_KNOWN_KEYS = frozenset({"result", "alloc", "hw", "left", "right"})
+_CACHE_KNOWN_KEYS = frozenset({"key", "life", "alive", "entry", "total"})
+
+
+# ---------- row schemas ----------
+
+class EvalRow(NamedTuple):
+    mode: str
+    time_ns: int
+    result: int
+    alloc: int
+    hw: int
+    left: "int | None"
+    right: "int | None"
+    label: str
+    line: int
+    extras: dict
+
+
+class CacheRow(NamedTuple):
+    mode: str
+    key: int
+    life_curr: int
+    life_max: int
+    alive: int
+    entry: int
+    total: int
+    label: str
+    line: int
+    extras: dict
+
+
+class TermRow(NamedTuple):
+    begin_line: int
+    end_line: int
+    expr: str
+
+
+# Columns displayed by default; excludes `extras` to keep tables readable.
+_EVAL_DEFAULT_COLUMNS = tuple(c for c in EvalRow._fields if c != "extras")
+_CACHE_DEFAULT_COLUMNS = tuple(c for c in CacheRow._fields if c != "extras")
+_TERM_DEFAULT_COLUMNS = TermRow._fields
+
+
+# ---------- low-level parsing helpers ----------
+
+def _strip_suffix(s, suffix):
+    """'13129B' with suffix='B' -> 13129. Returns int."""
+    assert s.endswith(suffix), s
+    return int(s[: -len(suffix)])
+
+
+def _parse_kv(field):
+    """Parse 'key=value' into (key, value); (None, None) if not k=v."""
+    m = _KV_RE.match(field)
+    if not m:
+        return None, None
+    return m.group(1), m.group(2)
+
+
+def _kv_and_label(fields):
+    """Split a list of trailing fields into (kv: dict, label: str | None).
+
+    Fields shaped 'k=v' go into the dict (values left as raw strings).
+    The first non-kv token, if any, becomes the label.
+    """
+    kv, label = {}, None
+    for f in fields:
+        k, v = _parse_kv(f)
+        if k is None:
+            label = f
+        else:
+            kv[k] = v
+    return kv, label
+
+
+# ---------- per-row parsers ----------
+
+def _parse_eval_row(lineno, fields):
+    """fields: [<mode>, <time>, <k=v>..., <label>]"""
+    mode = fields[0]
+    time_ns = _strip_suffix(fields[1], "ns")
+    kv, label = _kv_and_label(fields[2:])
+    extras = {k: v for k, v in kv.items() if k not in _EVAL_KNOWN_KEYS}
+    return EvalRow(
+        mode=mode,
+        time_ns=time_ns,
+        result=_strip_suffix(kv["result"], "B"),
+        alloc=_strip_suffix(kv["alloc"], "B"),
+        hw=_strip_suffix(kv["hw"], "B"),
+        left=_strip_suffix(kv["left"], "B") if "left" in kv else None,
+        right=_strip_suffix(kv["right"], "B") if "right" in kv else None,
+        label=label,
+        line=lineno,
+        extras=extras,
+    )
+
+
+def _parse_cache_row(lineno, fields):
+    """fields: [<mode>, <k=v>..., <label>]"""
+    mode = fields[0]
+    kv, label = _kv_and_label(fields[1:])
+    life_curr, life_max = (int(x) for x in kv["life"].split("/"))
+    extras = {k: v for k, v in kv.items() if k not in _CACHE_KNOWN_KEYS}
+    return CacheRow(
+        mode=mode,
+        key=int(kv["key"]),
+        life_curr=life_curr,
+        life_max=life_max,
+        alive=int(kv["alive"]),
+        entry=_strip_suffix(kv["entry"], "B"),
+        total=_strip_suffix(kv["total"], "B"),
+        label=label,
+        line=lineno,
+        extras=extras,
+    )
+
+
+class _TermPairer:
+    """Pair Term | Begin / Term | End lines under a LIFO invariant.
+
+    The evaluator never interleaves terms, so the matching End for
+    every Begin is the most recently opened one. Violations raise.
+    """
+
+    def __init__(self):
+        self._stack = []
+        self.pairs = []
+
+    def handle(self, lineno, fields):
+        # fields: [<kind>, <expr>] where kind is 'Begin' or 'End'.
+        kind, expr = fields[0], fields[1]
+        if kind == "Begin":
+            self._stack.append((lineno, expr))
+            return
+        assert kind == "End", kind
+        assert self._stack, f"Term | End at line {lineno} with no open Begin"
+        begin_line, begin_expr = self._stack.pop()
+        assert begin_expr == expr, (
+            f"Term mismatch at line {lineno}: "
+            f"End {expr!r} closing Begin {begin_expr!r}"
+        )
+        self.pairs.append(TermRow(begin_line, lineno, expr))
+
+
+# ---------- file-level iteration ----------
+
+def _iter_trace_lines(path):
+    """Yield (lineno, tag, rest_fields) for trace lines in `path`.
+
+    rest_fields excludes the tag token. Lines that don't start with a
+    known tag (after whitespace strip) are silently skipped.
+    """
+    with open(path, encoding="utf-8") as f:
+        for lineno, raw in enumerate(f, start=1):
+            line = raw.strip()
+            if not line:
+                continue
+            head = line.split(" | ", 1)[0]
+            if head not in _LINE_TAGS:
+                continue
+            fields = line.split(" | ")
+            yield lineno, fields[0], fields[1:]
+
+
+# ---------- public API ----------
+
+def parse(path):
+    """Parse all three line kinds in a single pass.
+
+    Returns (eval_rows, cache_rows, term_rows) — each a list,
+    materialized for downstream querying.
+    """
+    eval_rows, cache_rows = [], []
+    term_pairer = _TermPairer()
+    handlers = {
+        "Eval": lambda ln, fs: eval_rows.append(_parse_eval_row(ln, fs)),
+        "Cache": lambda ln, fs: cache_rows.append(_parse_cache_row(ln, fs)),
+        "Term": term_pairer.handle,
+    }
+    for lineno, tag, fields in _iter_trace_lines(path):
+        handlers[tag](lineno, fields)
+    return eval_rows, cache_rows, term_pairer.pairs
+
+
+def trace_eval(path):
+    """Yield an EvalRow for every Eval line in `path`."""
+    for lineno, tag, fields in _iter_trace_lines(path):
+        if tag == "Eval":
+            yield _parse_eval_row(lineno, fields)
+
+
+def trace_cache(path):
+    """Yield a CacheRow for every Cache line in `path`."""
+    for lineno, tag, fields in _iter_trace_lines(path):
+        if tag == "Cache":
+            yield _parse_cache_row(lineno, fields)
+
+
+def trace_term(path):
+    """Return paired TermRow list for `path`."""
+    pairer = _TermPairer()
+    for lineno, tag, fields in _iter_trace_lines(path):
+        if tag == "Term":
+            pairer.handle(lineno, fields)
+    return pairer.pairs
+
+
+# ---------- presentation ----------
+
+def _row_field(row, name):
+    return getattr(row, name) if hasattr(row, "_fields") else row.get(name)
+
+
+def _default_columns(row):
+    if isinstance(row, EvalRow):
+        return _EVAL_DEFAULT_COLUMNS
+    if isinstance(row, CacheRow):
+        return _CACHE_DEFAULT_COLUMNS
+    if isinstance(row, TermRow):
+        return _TERM_DEFAULT_COLUMNS
+    if hasattr(row, "_fields"):
+        return row._fields
+    return tuple(row.keys())
+
+
+def _is_int_column(cells, col_idx):
+    """A column is numeric if at least one non-None cell parses as int."""
+    saw_value = False
+    for row in cells:
+        v = row[col_idx]
+        if v == "None":
+            continue
+        saw_value = True
+        try:
+            int(v)
+        except ValueError:
+            return False
+    return saw_value
+
+
+def format_table(rows, columns=None, max_rows=None):
+    """Render `rows` as an aligned text table and return the string.
+
+    Numeric columns (those whose non-None cells all parse as int) are
+    right-aligned; all other columns are left-aligned.
+    """
+    rows = list(rows)
+    if not rows:
+        return "(empty)"
+    if columns is None:
+        columns = _default_columns(rows[0])
+    if max_rows is not None:
+        rows = rows[:max_rows]
+
+    cells = [[str(_row_field(r, c)) for c in columns] for r in rows]
+    widths = [max(len(c), *(len(row[i]) for row in cells))
+              for i, c in enumerate(columns)]
+    aligners = [
+        str.rjust if _is_int_column(cells, i) else str.ljust
+        for i in range(len(columns))
+    ]
+
+    out = []
+    out.append(" | ".join(c.ljust(widths[i]) for i, c in enumerate(columns)))
+    out.append("-+-".join("-" * w for w in widths))
+    for row in cells:
+        out.append(" | ".join(aligners[i](row[i], widths[i])
+                              for i in range(len(columns))))
+    return "\n".join(out)
+
+
+def print_table(rows, columns=None, max_rows=None):
+    """Print `rows` as an aligned text table."""
+    print(format_table(rows, columns, max_rows))
diff --git a/doc/user/guide/trace.txt b/doc/user/guide/trace.txt
deleted file mode 100644
index 108ca38d46..0000000000
--- a/doc/user/guide/trace.txt
+++ /dev/null
@@ -1,800 +0,0 @@
-Term | Begin | f{a_1;i_1}:N-C-S
-Eval | Tensor | 6003295ns | 36768B | f(a_1,i_1)
-Eval | Permute | 195598ns | 73536B | f(a_1,i_1)
-Term | End | f{a_1;i_1}:N-C-S
-Term | Begin | -1 f{i_2;i_1}:N-C-S * t{a_1;i_2}:N-C-S
-Eval | Tensor | 119317395ns | 10752B | f(i_2,i_1)
-Eval | Tensor | 1613ns | 36768B | t(a_1,i_2)
-Eval | Product | 6789630ns | 84288B | f(i_2,i_1) * t(a_1,i_2) -> I(a_1,i_1)
-Eval | Constant | 3296ns | 8B | {{{-1}}}
-Eval | Product | 199284ns | 73544B | I(a_1,i_1) * {{{-1}}} -> I(a_1,i_1)
-Eval | Permute | 755948ns | 73536B | I(a_1,i_1)
-Term | End | -1 f{i_2;i_1}:N-C-S * t{a_1;i_2}:N-C-S
-Eval | SumInplace | 3032326ns | 73536B | I(a_1,i_1)
-Term | Begin | 2 f{i_2;a_2}:N-C-S * t{a_1,a_2;i_1,i_2}:N-C-S
-Eval | Tensor | 6265660ns | 36768B | f(i_2,a_2)
-Eval | Tensor | 992ns | 88751616B | t(a_1,a_2,i_1,i_2)
-Eval | Product | 31665922ns | 88825152B | f(i_2,a_2) * t(a_1,a_2,i_1,i_2) -> I(a_1,i_1)
-Eval | Constant | 1122ns | 8B | {{{2}}}
-Eval | Product | 173254ns | 73544B | I(a_1,i_1) * {{{2}}} -> I(a_1,i_1)
-Eval | Permute | 1399418ns | 73536B | I(a_1,i_1)
-Term | End | 2 f{i_2;a_2}:N-C-S * t{a_1,a_2;i_1,i_2}:N-C-S
-Eval | SumInplace | 4580051ns | 73536B | I(a_1,i_1)
-Term | Begin | -1 g{i_2,a_1;i_1,a_2}:N-C-S * t{a_2;i_2}:N-C-S
-Eval | Tensor | 688998813ns | 88751616B | g(i_2,a_1,i_1,a_2)
-Eval | Tensor | 2424ns | 36768B | t(a_2,i_2)
-Eval | Product | 31669619ns | 88825152B | g(i_2,a_1,i_1,a_2) * t(a_2,i_2) -> I(a_1,i_1)
-Eval | Constant | 1553ns | 8B | {{{-1}}}
-Eval | Product | 181701ns | 73544B | I(a_1,i_1) * {{{-1}}} -> I(a_1,i_1)
-Eval | Permute | 1018213ns | 73536B | I(a_1,i_1)
-Term | End | -1 g{i_2,a_1;i_1,a_2}:N-C-S * t{a_2;i_2}:N-C-S
-Eval | SumInplace | 3777603ns | 73536B | I(a_1,i_1)
-Term | Begin | 2 g{i_2,a_1;a_2,i_1}:N-C-S * t{a_2;i_2}:N-C-S
-Eval | Tensor | 45684750ns | 84920312B | g(i_2,a_1,a_2,i_1)
-Eval | Tensor | 2004ns | 36768B | t(a_2,i_2)
-Eval | Product | 29504525ns | 84993848B | g(i_2,a_1,a_2,i_1) * t(a_2,i_2) -> I(a_1,i_1)
-Eval | Constant | 1362ns | 8B | {{{2}}}
-Eval | Product | 191860ns | 73544B | I(a_1,i_1) * {{{2}}} -> I(a_1,i_1)
-Eval | Permute | 1168743ns | 73536B | I(a_1,i_1)
-Term | End | 2 g{i_2,a_1;a_2,i_1}:N-C-S * t{a_2;i_2}:N-C-S
-Eval | SumInplace | 3525137ns | 73536B | I(a_1,i_1)
-Term | Begin | -2 g{i_2,i_3;i_1,a_2}:N-C-S * t{a_1,a_2;i_2,i_3}:N-C-S
-Eval | Tensor | 63722777ns | 6614112B | g(i_2,i_3,i_1,a_2)
-Eval | Tensor | 1794ns | 88751616B | t(a_1,a_2,i_2,i_3)
-Eval | Product | 88658825ns | 95402496B | g(i_2,i_3,i_1,a_2) * t(a_1,a_2,i_2,i_3) -> I(a_1,i_1)
-Eval | Constant | 1403ns | 8B | {{{-2}}}
-Eval | Product | 179877ns | 73544B | I(a_1,i_1) * {{{-2}}} -> I(a_1,i_1)
-Eval | Permute | 872021ns | 73536B | I(a_1,i_1)
-Term | End | -2 g{i_2,i_3;i_1,a_2}:N-C-S * t{a_1,a_2;i_2,i_3}:N-C-S
-Eval | SumInplace | 3363355ns | 73536B | I(a_1,i_1)
-Term | Begin | 2 g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2,a_3;i_2,i_1}:N-C-S
-Eval | Tensor | 280151443ns | 1152043680B | g(i_2,a_1,a_2,a_3)
-Eval | Tensor | 2104ns | 88751616B | t(a_2,a_3,i_2,i_1)
-Eval | Product | 193736424ns | 1240832064B | g(i_2,a_1,a_2,a_3) * t(a_2,a_3,i_2,i_1) -> I(a_1,i_1)
-Eval | Constant | 1893ns | 8B | {{{2}}}
-Eval | Product | 254230ns | 73544B | I(a_1,i_1) * {{{2}}} -> I(a_1,i_1)
-Eval | Permute | 832185ns | 73536B | I(a_1,i_1)
-Term | End | 2 g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2,a_3;i_2,i_1}:N-C-S
-Eval | SumInplace | 4023177ns | 73536B | I(a_1,i_1)
-Term | Begin | -1 f{i_2;a_2}:N-C-S * t{a_1,a_2;i_2,i_1}:N-C-S
-Eval | Tensor | 22794ns | 36768B | f(i_2,a_2)
-Eval | Tensor | 1432ns | 88751616B | t(a_1,a_2,i_2,i_1)
-Eval | Product | 33803253ns | 88825152B | f(i_2,a_2) * t(a_1,a_2,i_2,i_1) -> I(a_1,i_1)
-Eval | Constant | 932ns | 8B | {{{-1}}}
-Eval | Product | 168325ns | 73544B | I(a_1,i_1) * {{{-1}}} -> I(a_1,i_1)
-Eval | Permute | 1476617ns | 73536B | I(a_1,i_1)
-Term | End | -1 f{i_2;a_2}:N-C-S * t{a_1,a_2;i_2,i_1}:N-C-S
-Eval | SumInplace | 3493626ns | 73536B | I(a_1,i_1)
-Term | Begin | f{a_1;a_2}:N-C-S * t{a_2;i_1}:N-C-S
-Eval | Tensor | 116850349ns | 358056B | f(a_1,a_2)
-Eval | Tensor | 1293ns | 36768B | t(a_2,i_1)
-Eval | Product | 9412768ns | 431592B | f(a_1,a_2) * t(a_2,i_1) -> I(a_1,i_1)
-Eval | Permute | 197610ns | 73536B | I(a_1,i_1)
-Term | End | f{a_1;a_2}:N-C-S * t{a_2;i_1}:N-C-S
-Eval | SumInplace | 3309040ns | 73536B | I(a_1,i_1)
-Term | Begin | -1 g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2,a_3;i_1,i_2}:N-C-S
-Eval | Tensor | 16481ns | 1152043680B | g(i_2,a_1,a_2,a_3)
-Eval | Tensor | 1112ns | 88751616B | t(a_2,a_3,i_1,i_2)
-Eval | Product | 189706986ns | 1240832064B | g(i_2,a_1,a_2,a_3) * t(a_2,a_3,i_1,i_2) -> I(a_1,i_1)
-Eval | Constant | 1402ns | 8B | {{{-1}}}
-Eval | Product | 186990ns | 73544B | I(a_1,i_1) * {{{-1}}} -> I(a_1,i_1)
-Eval | Permute | 1161229ns | 73536B | I(a_1,i_1)
-Term | End | -1 g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2,a_3;i_1,i_2}:N-C-S
-Eval | SumInplace | 4171943ns | 73536B | I(a_1,i_1)
-Term | Begin | g{i_2,i_3;i_1,a_2}:N-C-S * t{a_1,a_2;i_3,i_2}:N-C-S
-Eval | Tensor | 25810ns | 6614112B | g(i_2,i_3,i_1,a_2)
-Eval | Tensor | 1203ns | 88751616B | t(a_1,a_2,i_3,i_2)
-Eval | Product | 89797791ns | 95402496B | g(i_2,i_3,i_1,a_2) * t(a_1,a_2,i_3,i_2) -> I(a_1,i_1)
-Eval | Permute | 204374ns | 73536B | I(a_1,i_1)
-Term | End | g{i_2,i_3;i_1,a_2}:N-C-S * t{a_1,a_2;i_3,i_2}:N-C-S
-Eval | SumInplace | 2892677ns | 73536B | I(a_1,i_1)
-Term | Begin | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_2,i_1}:N-C-S
-Eval | Tensor | 46174846ns | 84920312B | g(i_2,i_3,a_2,a_3)
-Eval | Tensor | 2344ns | 36768B | t(a_3,i_3)
-Eval | Product | 30138557ns | 84993848B | g(i_2,i_3,a_2,a_3) * t(a_3,i_3) -> I(i_2,a_2)
-Cache | Store | 6443766742777296727 | 2/3 | 2 | 36768B
-Eval | Tensor | 1994ns | 88751616B | t(a_1,a_2,i_2,i_1)
-Eval | Product | 35106726ns | 88825152B | I(i_2,a_2) * t(a_1,a_2,i_2,i_1) -> I(a_1,i_1)
-Eval | Constant | 1172ns | 8B | {{{-2}}}
-Eval | Product | 210235ns | 73544B | I(a_1,i_1) * {{{-2}}} -> I(a_1,i_1)
-Eval | Permute | 1409197ns | 73536B | I(a_1,i_1)
-Term | End | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_2,i_1}:N-C-S
-Eval | SumInplace | 3793183ns | 73536B | I(a_1,i_1)
-Term | Begin | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2,a_3;i_1,i_2}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | Tensor | 23886ns | 84920312B | g(i_2,i_3,a_2,a_3)
-Eval | Tensor | 1042ns | 88751616B | t(a_2,a_3,i_1,i_2)
-Eval | Product | 126274688ns | 173682680B | g(i_2,i_3,a_2,a_3) * t(a_2,a_3,i_1,i_2) -> I(i_3,i_1)
-Eval | Tensor | 2575ns | 36768B | t(a_1,i_3)
-Eval | Product | 6325506ns | 84288B | I(i_3,i_1) * t(a_1,i_3) -> I(a_1,i_1)
-Eval | Permute | 1173162ns | 73536B | I(a_1,i_1)
-Term | End | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2,a_3;i_1,i_2}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | SumInplace | 3073004ns | 73536B | I(a_1,i_1)
-Term | Begin | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2;i_1}:N-C-S) * t{a_1,a_3;i_3,i_2}:N-C-S
-Eval | Tensor | 22292ns | 84920312B | g(i_2,i_3,a_2,a_3)
-Eval | Tensor | 951ns | 36768B | t(a_2,i_1)
-Eval | Product | 32816931ns | 91890968B | g(i_2,i_3,a_2,a_3) * t(a_2,i_1) -> I(i_2,i_3,i_1,a_3)
-Cache | Store | 14406268377898944426 | 1/2 | 3 | 6970656B
-Eval | Tensor | 2285ns | 88751616B | t(a_1,a_3,i_3,i_2)
-Eval | Product | 93909528ns | 95722272B | I(i_2,i_3,i_1,a_3) * t(a_1,a_3,i_3,i_2) -> I(a_1,i_1)
-Eval | Permute | 185327ns | 73536B | I(a_1,i_1)
-Term | End | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2;i_1}:N-C-S) * t{a_1,a_3;i_3,i_2}:N-C-S
-Eval | SumInplace | 3035031ns | 73536B | I(a_1,i_1)
-Term | Begin | -1 (g{i_2,a_1;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2;i_1}:N-C-S
-Eval | Tensor | 28185ns | 1152043680B | g(i_2,a_1,a_2,a_3)
-Eval | Tensor | 1443ns | 36768B | t(a_3,i_2)
-Eval | Product | 70877782ns | 1152438504B | g(i_2,a_1,a_2,a_3) * t(a_3,i_2) -> I(a_1,a_2)
-Eval | Tensor | 2656ns | 36768B | t(a_2,i_1)
-Eval | Product | 13706677ns | 431592B | I(a_1,a_2) * t(a_2,i_1) -> I(a_1,i_1)
-Eval | Constant | 1753ns | 8B | {{{-1}}}
-Eval | Product | 818618ns | 73544B | I(a_1,i_1) * {{{-1}}} -> I(a_1,i_1)
-Eval | Permute | 1738923ns | 73536B | I(a_1,i_1)
-Term | End | -1 (g{i_2,a_1;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2;i_1}:N-C-S
-Eval | SumInplace | 3485229ns | 73536B | I(a_1,i_1)
-Term | Begin | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2;i_3}:N-C-S) * t{a_1,a_3;i_2,i_1}:N-C-S
-Eval | Tensor | 24367ns | 84920312B | g(i_2,i_3,a_2,a_3)
-Eval | Tensor | 971ns | 36768B | t(a_2,i_3)
-Eval | Product | 28556397ns | 84993848B | g(i_2,i_3,a_2,a_3) * t(a_2,i_3) -> I(i_2,a_3)
-Cache | Store | 4354995230928331310 | 2/3 | 5 | 7007424B
-Eval | Tensor | 1854ns | 88751616B | t(a_1,a_3,i_2,i_1)
-Eval | Product | 33053277ns | 88825152B | I(i_2,a_3) * t(a_1,a_3,i_2,i_1) -> I(a_1,i_1)
-Eval | Permute | 245132ns | 73536B | I(a_1,i_1)
-Term | End | (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2;i_3}:N-C-S) * t{a_1,a_3;i_2,i_1}:N-C-S
-Eval | SumInplace | 3252841ns | 73536B | I(a_1,i_1)
-Term | Begin | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2,a_3;i_2,i_1}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | Tensor | 21942ns | 84920312B | g(i_2,i_3,a_2,a_3)
-Eval | Tensor | 932ns | 88751616B | t(a_2,a_3,i_2,i_1)
-Eval | Product | 130516045ns | 173682680B | g(i_2,i_3,a_2,a_3) * t(a_2,a_3,i_2,i_1) -> I(i_3,i_1)
-Eval | Tensor | 2575ns | 36768B | t(a_1,i_3)
-Eval | Product | 6232376ns | 84288B | I(i_3,i_1) * t(a_1,i_3) -> I(a_1,i_1)
-Eval | Constant | 1313ns | 8B | {{{-2}}}
-Eval | Product | 765816ns | 73544B | I(a_1,i_1) * {{{-2}}} -> I(a_1,i_1)
-Eval | Permute | 1214712ns | 73536B | I(a_1,i_1)
-Term | End | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2,a_3;i_2,i_1}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | SumInplace | 2738039ns | 73536B | I(a_1,i_1)
-Term | Begin | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2;i_3}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S
-Cache | Access | 4354995230928331310 | 1/3 | 4 | 7007424B
-Eval | Tensor | 1071ns | 88751616B | t(a_1,a_3,i_1,i_2)
-Eval | Product | 32017279ns | 88825152B | I(i_2,a_3) * t(a_1,a_3,i_1,i_2) -> I(a_1,i_1)
-Eval | Constant | 972ns | 8B | {{{-2}}}
-Eval | Product | 169066ns | 73544B | I(a_1,i_1) * {{{-2}}} -> I(a_1,i_1)
-Eval | Permute | 969418ns | 73536B | I(a_1,i_1)
-Term | End | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2;i_3}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S
-Eval | SumInplace | 4101828ns | 73536B | I(a_1,i_1)
-Term | Begin | 2 (g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_3;i_1}:N-C-S
-Eval | Tensor | 24917ns | 1152043680B | g(i_2,a_1,a_2,a_3)
-Eval | Tensor | 872ns | 36768B | t(a_2,i_2)
-Eval | Product | 69858567ns | 1152438504B | g(i_2,a_1,a_2,a_3) * t(a_2,i_2) -> I(a_1,a_3)
-Eval | Tensor | 2304ns | 36768B | t(a_3,i_1)
-Eval | Product | 13267069ns | 431592B | I(a_1,a_3) * t(a_3,i_1) -> I(a_1,i_1)
-Eval | Constant | 1352ns | 8B | {{{2}}}
-Eval | Product | 1141130ns | 73544B | I(a_1,i_1) * {{{2}}} -> I(a_1,i_1)
-Eval | Permute | 1260310ns | 73536B | I(a_1,i_1)
-Term | End | 2 (g{i_2,a_1;a_2,a_3}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_3;i_1}:N-C-S
-Eval | SumInplace | 3867537ns | 73536B | I(a_1,i_1)
-Term | Begin | -2 (g{i_2,i_3;i_1,a_2}:N-C-S * t{a_2;i_3}:N-C-S) * t{a_1;i_2}:N-C-S
-Eval | Tensor | 24627ns | 6614112B | g(i_2,i_3,i_1,a_2)
-Eval | Tensor | 882ns | 36768B | t(a_2,i_3)
-Eval | Product | 23969012ns | 6661632B | g(i_2,i_3,i_1,a_2) * t(a_2,i_3) -> I(i_2,i_1)
-Eval | Tensor | 992ns | 36768B | t(a_1,i_2)
-Eval | Product | 6143134ns | 84288B | I(i_2,i_1) * t(a_1,i_2) -> I(a_1,i_1)
-Eval | Constant | 862ns | 8B | {{{-2}}}
-Eval | Product | 985019ns | 73544B | I(a_1,i_1) * {{{-2}}} -> I(a_1,i_1)
-Eval | Permute | 1140680ns | 73536B | I(a_1,i_1)
-Term | End | -2 (g{i_2,i_3;i_1,a_2}:N-C-S * t{a_2;i_3}:N-C-S) * t{a_1;i_2}:N-C-S
-Eval | SumInplace | 2957032ns | 73536B | I(a_1,i_1)
-Term | Begin | (g{i_2,i_3;i_1,a_2}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | Tensor | 13636ns | 6614112B | g(i_2,i_3,i_1,a_2)
-Eval | Tensor | 732ns | 36768B | t(a_2,i_2)
-Eval | Product | 19365878ns | 6661632B | g(i_2,i_3,i_1,a_2) * t(a_2,i_2) -> I(i_3,i_1)
-Eval | Tensor | 931ns | 36768B | t(a_1,i_3)
-Eval | Product | 6464663ns | 84288B | I(i_3,i_1) * t(a_1,i_3) -> I(a_1,i_1)
-Eval | Permute | 966894ns | 73536B | I(a_1,i_1)
-Term | End | (g{i_2,i_3;i_1,a_2}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | SumInplace | 2859864ns | 73536B | I(a_1,i_1)
-Term | Begin | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1,a_2;i_3,i_2}:N-C-S
-Cache | Release | 14406268377898944426 | 0/2 | 3 | 73536B
-Eval | Tensor | 1032ns | 88751616B | t(a_1,a_2,i_3,i_2)
-Eval | Product | 83594732ns | 95722272B | I(i_3,i_2,i_1,a_2) * t(a_1,a_2,i_3,i_2) -> I(a_1,i_1)
-Eval | Constant | 1422ns | 8B | {{{-2}}}
-Eval | Product | 1166990ns | 73544B | I(a_1,i_1) * {{{-2}}} -> I(a_1,i_1)
-Eval | Permute | 1185536ns | 73536B | I(a_1,i_1)
-Term | End | -2 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1,a_2;i_3,i_2}:N-C-S
-Eval | SumInplace | 3005344ns | 73536B | I(a_1,i_1)
-Term | Begin | -1 (f{i_2;a_2}:N-C-S * t{a_2;i_1}:N-C-S) * t{a_1;i_2}:N-C-S
-Eval | Tensor | 24397ns | 36768B | f(i_2,a_2)
-Eval | Tensor | 1653ns | 36768B | t(a_2,i_1)
-Eval | Product | 5986612ns | 84288B | f(i_2,a_2) * t(a_2,i_1) -> I(i_2,i_1)
-Eval | Tensor | 1011ns | 36768B | t(a_1,i_2)
-Eval | Product | 6318792ns | 84288B | I(i_2,i_1) * t(a_1,i_2) -> I(a_1,i_1)
-Eval | Constant | 581ns | 8B | {{{-1}}}
-Eval | Product | 1136832ns | 73544B | I(a_1,i_1) * {{{-1}}} -> I(a_1,i_1)
-Eval | Permute | 1083679ns | 73536B | I(a_1,i_1)
-Term | End | -1 (f{i_2;a_2}:N-C-S * t{a_2;i_1}:N-C-S) * t{a_1;i_2}:N-C-S
-Eval | SumInplace | 3283721ns | 73536B | I(a_1,i_1)
-Term | Begin | 4 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_1,i_2}:N-C-S
-Cache | Access | 6443766742777296727 | 1/3 | 2 | 73536B
-Eval | Tensor | 1252ns | 88751616B | t(a_1,a_2,i_1,i_2)
-Eval | Product | 33623477ns | 88825152B | I(i_2,a_2) * t(a_1,a_2,i_1,i_2) -> I(a_1,i_1)
-Eval | Constant | 732ns | 8B | {{{4}}}
-Eval | Product | 173093ns | 73544B | I(a_1,i_1) * {{{4}}} -> I(a_1,i_1)
-Eval | Permute | 777559ns | 73536B | I(a_1,i_1)
-Term | End | 4 (g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_1,i_2}:N-C-S
-Eval | SumInplace | 3388764ns | 73536B | I(a_1,i_1)
-Term | Begin | ((g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
-Cache | Release | 4354995230928331310 | 0/3 | 1 | 36768B
-Eval | Tensor | 1183ns | 36768B | t(a_2,i_1)
-Eval | Product | 6357477ns | 84288B | I(i_3,a_2) * t(a_2,i_1) -> I(i_3,i_1)
-Eval | Tensor | 901ns | 36768B | t(a_1,i_3)
-Eval | Product | 6430027ns | 84288B | I(i_3,i_1) * t(a_1,i_3) -> I(a_1,i_1)
-Eval | Permute | 1116974ns | 73536B | I(a_1,i_1)
-Term | End | ((g{i_2,i_3;a_2,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | SumInplace | 2602468ns | 73536B | I(a_1,i_1)
-Term | Begin | -2 ((g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_3;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
-Cache | Release | 6443766742777296727 | 0/3 | 0 | 0B
-Eval | Tensor | 972ns | 36768B | t(a_3,i_1)
-Eval | Product | 7172679ns | 84288B | I(i_3,a_3) * t(a_3,i_1) -> I(i_3,i_1)
-Eval | Tensor | 811ns | 36768B | t(a_1,i_3)
-Eval | Product | 6833926ns | 84288B | I(i_3,i_1) * t(a_1,i_3) -> I(a_1,i_1)
-Eval | Constant | 601ns | 8B | {{{-2}}}
-Eval | Product | 861992ns | 73544B | I(a_1,i_1) * {{{-2}}} -> I(a_1,i_1)
-Eval | Permute | 1557343ns | 73536B | I(a_1,i_1)
-Term | End | -2 ((g{i_2,i_3;a_2,a_3}:N-C-S * t{a_2;i_2}:N-C-S) * t{a_3;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | SumInplace | 2466124ns | 73536B | I(a_1,i_1)
-Eval | Symmetrize | 1229290ns | 73536B | f(a_1,i_1)
-Term | Begin | 1/2 g{a_1,a_2;i_1,i_2}:N-C-S
-Eval | Tensor | 45863355ns | 84920312B | g(a_1,a_2,i_1,i_2)
-Eval | Constant | 1563ns | 8B | {{{\frac{1}{2}}}}
-Eval | Product | 566092ns | 169840632B | g(a_1,a_2,i_1,i_2) * {{{\frac{1}{2}}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 365245ns | 169840624B | I(a_1,a_2,i_1,i_2)
-Term | End | 1/2 g{a_1,a_2;i_1,i_2}:N-C-S
-Term | Begin | -1 f{i_3;i_2}:N-C-S * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | Tensor | 19507ns | 10752B | f(i_3,i_2)
-Eval | Tensor | 1152ns | 88751616B | t(a_1,a_2,i_1,i_3)
-Eval | Product | 42784328ns | 177513984B | f(i_3,i_2) * t(a_1,a_2,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 2014ns | 8B | {{{-1}}}
-Eval | Product | 429889ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{-1}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1629041ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | -1 f{i_3;i_2}:N-C-S * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | SumInplace | 21396462ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | 1/2 g{a_1,a_2;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S
-Eval | Tensor | 2732827727ns | 14974417512B | g(a_1,a_2,a_3,a_4)
-Eval | Tensor | 7515ns | 88751616B | t(a_3,a_4,i_1,i_2)
-Eval | Product | 1302417788ns | 15151920744B | g(a_1,a_2,a_3,a_4) * t(a_3,a_4,i_1,i_2) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 2766ns | 8B | {{{\frac{1}{2}}}}
-Eval | Product | 764013ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{\frac{1}{2}}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 1583362ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | 1/2 g{a_1,a_2;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S
-Eval | SumInplace | 24303998ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | 2 g{i_3,a_1;a_3,i_1}:N-C-S * t{a_2,a_3;i_2,i_3}:N-C-S
-Eval | Tensor | 50099151ns | 84920312B | g(i_3,a_1,a_3,i_1)
-Eval | Tensor | 1894ns | 88751616B | t(a_2,a_3,i_2,i_3)
-Eval | Product | 123116018ns | 262423544B | g(i_3,a_1,a_3,i_1) * t(a_2,a_3,i_2,i_3) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1593ns | 8B | {{{2}}}
-Eval | Product | 341208ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{2}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 23273341ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | 2 g{i_3,a_1;a_3,i_1}:N-C-S * t{a_2,a_3;i_2,i_3}:N-C-S
-Eval | SumInplace | 3634127ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | 1/2 g{i_3,i_4;i_1,i_2}:N-C-S * t{a_1,a_2;i_3,i_4}:N-C-S
-Eval | Tensor | 55846493ns | 574912B | g(i_3,i_4,i_1,i_2)
-Eval | Tensor | 1253ns | 88751616B | t(a_1,a_2,i_3,i_4)
-Eval | Product | 112481505ns | 178078144B | g(i_3,i_4,i_1,i_2) * t(a_1,a_2,i_3,i_4) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1894ns | 8B | {{{\frac{1}{2}}}}
-Eval | Product | 856972ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{\frac{1}{2}}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 18455783ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | 1/2 g{i_3,i_4;i_1,i_2}:N-C-S * t{a_1,a_2;i_3,i_4}:N-C-S
-Eval | SumInplace | 25924172ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | -1 g{i_3,a_1;i_2,i_1}:N-C-S * t{a_2;i_3}:N-C-S
-Eval | Tensor | 47764961ns | 6614112B | g(i_3,a_1,i_2,i_1)
-Eval | Tensor | 1293ns | 36768B | t(a_2,i_3)
-Eval | Product | 24754397ns | 95402496B | g(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 811ns | 8B | {{{-1}}}
-Eval | Product | 349243ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{-1}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1126462ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | -1 g{i_3,a_1;i_2,i_1}:N-C-S * t{a_2;i_3}:N-C-S
-Eval | SumInplace | 28531018ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -1 g{i_3,a_1;i_1,a_3}:N-C-S * t{a_2,a_3;i_2,i_3}:N-C-S
-Eval | Tensor | 16552ns | 88751616B | g(i_3,a_1,i_1,a_3)
-Eval | Tensor | 1082ns | 88751616B | t(a_2,a_3,i_2,i_3)
-Eval | Product | 132115389ns | 266254848B | g(i_3,a_1,i_1,a_3) * t(a_2,a_3,i_2,i_3) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1514ns | 8B | {{{-1}}}
-Eval | Product | 622691ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{-1}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 18255777ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | -1 g{i_3,a_1;i_1,a_3}:N-C-S * t{a_2,a_3;i_2,i_3}:N-C-S
-Eval | SumInplace | 3699543ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | f{a_2;a_3}:N-C-S * t{a_1,a_3;i_1,i_2}:N-C-S
-Eval | Tensor | 28344ns | 358056B | f(a_2,a_3)
-Eval | Tensor | 1714ns | 88751616B | t(a_1,a_3,i_1,i_2)
-Eval | Product | 32730836ns | 177861288B | f(a_2,a_3) * t(a_1,a_3,i_1,i_2) -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 323874ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | f{a_2;a_3}:N-C-S * t{a_1,a_3;i_1,i_2}:N-C-S
-Eval | SumInplace | 21796524ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -1 g{i_3,a_1;a_3,i_1}:N-C-S * t{a_2,a_3;i_3,i_2}:N-C-S
-Eval | Tensor | 19387ns | 84920312B | g(i_3,a_1,a_3,i_1)
-Eval | Tensor | 1132ns | 88751616B | t(a_2,a_3,i_3,i_2)
-Eval | Product | 124130915ns | 262423544B | g(i_3,a_1,a_3,i_1) * t(a_2,a_3,i_3,i_2) -> I(a_1,a_2,i_2,i_1)
-Eval | Constant | 1864ns | 8B | {{{-1}}}
-Eval | Product | 369092ns | 177503240B | I(a_1,a_2,i_2,i_1) * {{{-1}}} -> I(a_1,a_2,i_2,i_1)
-Eval | Permute | 6587440ns | 177503232B | I(a_1,a_2,i_2,i_1)
-Term | End | -1 g{i_3,a_1;a_3,i_1}:N-C-S * t{a_2,a_3;i_3,i_2}:N-C-S
-Eval | SumInplace | 3875402ns | 177503232B | I(a_1,a_2,i_2,i_1)
-Term | Begin | -1 g{i_3,a_2;i_1,a_3}:N-C-S * t{a_1,a_3;i_3,i_2}:N-C-S
-Eval | Tensor | 25770ns | 88751616B | g(i_3,a_2,i_1,a_3)
-Eval | Tensor | 1463ns | 88751616B | t(a_1,a_3,i_3,i_2)
-Eval | Product | 121446740ns | 266254848B | g(i_3,a_2,i_1,a_3) * t(a_1,a_3,i_3,i_2) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1593ns | 8B | {{{-1}}}
-Eval | Product | 613463ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{-1}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 15821995ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | -1 g{i_3,a_2;i_1,a_3}:N-C-S * t{a_1,a_3;i_3,i_2}:N-C-S
-Eval | SumInplace | 4208804ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | g{a_1,a_2;i_1,a_3}:N-C-S * t{a_3;i_2}:N-C-S
-Eval | Tensor | 152411069ns | 1152043680B | g(a_1,a_2,i_1,a_3)
-Eval | Tensor | 2656ns | 36768B | t(a_3,i_2)
-Eval | Product | 76273536ns | 1240832064B | g(a_1,a_2,i_1,a_3) * t(a_3,i_2) -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 577474ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | g{a_1,a_2;i_1,a_3}:N-C-S * t{a_3;i_2}:N-C-S
-Eval | SumInplace | 26288295ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -1 (g{i_3,a_2;a_3,i_2}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | Tensor | 25469ns | 84920312B | g(i_3,a_2,a_3,i_2)
-Eval | Tensor | 1082ns | 36768B | t(a_3,i_1)
-Eval | Product | 30893282ns | 91890968B | g(i_3,a_2,a_3,i_2) * t(a_3,i_1) -> I(i_3,a_2,i_2,i_1)
-Eval | Tensor | 852ns | 36768B | t(a_1,i_3)
-Eval | Product | 31197359ns | 95722272B | I(i_3,a_2,i_2,i_1) * t(a_1,i_3) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1674ns | 8B | {{{-1}}}
-Eval | Product | 1107375ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{-1}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 20561934ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | -1 (g{i_3,a_2;a_3,i_2}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | SumInplace | 26717761ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | -2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_4}:N-C-S) * t{a_2,a_3;i_3,i_2}:N-C-S
-Eval | Tensor | 44743416ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 2174ns | 88751616B | t(a_1,a_4,i_1,i_4)
-Eval | Product | 126122575ns | 262423544B | g(i_3,i_4,a_3,a_4) * t(a_1,a_4,i_1,i_4) -> I(i_3,a_1,i_1,a_3)
-Cache | Store | 223784662887107466 | 1/2 | 1 | 88751616B
-Eval | Tensor | 2495ns | 88751616B | t(a_2,a_3,i_3,i_2)
-Eval | Product | 127653015ns | 266254848B | I(i_3,a_1,i_1,a_3) * t(a_2,a_3,i_3,i_2) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1884ns | 8B | {{{-2}}}
-Eval | Product | 591921ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{-2}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 21742870ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | -2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_4}:N-C-S) * t{a_2,a_3;i_3,i_2}:N-C-S
-Eval | SumInplace | 3882846ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | -2 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_4}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | Tensor | 38861565ns | 6614112B | g(i_3,i_4,i_2,a_3)
-Eval | Tensor | 1513ns | 36768B | t(a_3,i_4)
-Eval | Product | 24026583ns | 6661632B | g(i_3,i_4,i_2,a_3) * t(a_3,i_4) -> I(i_3,i_2)
-Eval | Tensor | 1373ns | 88751616B | t(a_1,a_2,i_1,i_3)
-Eval | Product | 40321069ns | 177513984B | I(i_3,i_2) * t(a_1,a_2,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 1413ns | 8B | {{{-2}}}
-Eval | Product | 858335ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{-2}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 960863ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | -2 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_4}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | SumInplace | 22325895ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_4,i_1}:N-C-S) * t{a_2;i_3}:N-C-S
-Eval | Tensor | 25399ns | 6614112B | g(i_3,i_4,i_2,a_3)
-Eval | Tensor | 1102ns | 88751616B | t(a_1,a_3,i_4,i_1)
-Eval | Product | 90370445ns | 102299616B | g(i_3,i_4,i_2,a_3) * t(a_1,a_3,i_4,i_1) -> I(i_3,a_1,i_1,i_2)
-Eval | Tensor | 2415ns | 36768B | t(a_2,i_3)
-Eval | Product | 25050668ns | 95722272B | I(i_3,a_1,i_1,i_2) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1279447ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_4,i_1}:N-C-S) * t{a_2;i_3}:N-C-S
-Eval | SumInplace | 25422685ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | 1/2 (g{a_1,a_2;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S
-Eval | Tensor | 25840ns | 14974417512B | g(a_1,a_2,a_3,a_4)
-Eval | Tensor | 1432ns | 36768B | t(a_3,i_1)
-Eval | Product | 1095839314ns | 16126497960B | g(a_1,a_2,a_3,a_4) * t(a_3,i_1) -> I(a_2,a_1,i_1,a_4)
-Eval | Tensor | 2605ns | 36768B | t(a_4,i_2)
-Eval | Product | 102080180ns | 1240832064B | I(a_2,a_1,i_1,a_4) * t(a_4,i_2) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1543ns | 8B | {{{\frac{1}{2}}}}
-Eval | Product | 818127ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{\frac{1}{2}}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 12213648ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | 1/2 (g{a_1,a_2;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S
-Eval | SumInplace | 24302485ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_4,i_2}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | Tensor | 26531ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 3957ns | 88751616B | t(a_3,a_4,i_4,i_2)
-Eval | Product | 123539195ns | 173682680B | g(i_3,i_4,a_3,a_4) * t(a_3,a_4,i_4,i_2) -> I(i_3,i_2)
-Eval | Tensor | 2265ns | 88751616B | t(a_1,a_2,i_1,i_3)
-Eval | Product | 32384688ns | 177513984B | I(i_3,i_2) * t(a_1,a_2,i_1,i_3) -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 17751996ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_4,i_2}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | SumInplace | 22009935ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | -2 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_1,i_4}:N-C-S) * t{a_2;i_3}:N-C-S
-Eval | Tensor | 25739ns | 6614112B | g(i_3,i_4,i_2,a_3)
-Eval | Tensor | 1172ns | 88751616B | t(a_1,a_3,i_1,i_4)
-Eval | Product | 95934041ns | 102299616B | g(i_3,i_4,i_2,a_3) * t(a_1,a_3,i_1,i_4) -> I(i_3,a_1,i_1,i_2)
-Eval | Tensor | 2214ns | 36768B | t(a_2,i_3)
-Eval | Product | 18441306ns | 95722272B | I(i_3,a_1,i_1,i_2) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 1273ns | 8B | {{{-2}}}
-Eval | Product | 894124ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{-2}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 992183ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | -2 (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_1,i_4}:N-C-S) * t{a_2;i_3}:N-C-S
-Eval | SumInplace | 27097785ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | (g{i_3,i_4;i_1,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
-Eval | Tensor | 27062ns | 6614112B | g(i_3,i_4,i_1,a_3)
-Eval | Tensor | 1022ns | 36768B | t(a_3,i_2)
-Eval | Product | 21680881ns | 7270272B | g(i_3,i_4,i_1,a_3) * t(a_3,i_2) -> I(i_3,i_4,i_1,i_2)
-Cache | Store | 10186165109937716840 | 1/2 | 2 | 89371008B
-Eval | Tensor | 1452ns | 88751616B | t(a_1,a_2,i_3,i_4)
-Eval | Product | 117426639ns | 178122624B | I(i_3,i_4,i_1,i_2) * t(a_1,a_2,i_3,i_4) -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 410271ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | (g{i_3,i_4;i_1,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
-Eval | SumInplace | 23051874ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | 2 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_1,i_3}:N-C-S
-Eval | Tensor | 143020665ns | 1152043680B | g(i_3,a_2,a_3,a_4)
-Eval | Tensor | 2344ns | 36768B | t(a_4,i_2)
-Eval | Product | 72421098ns | 1240832064B | g(i_3,a_2,a_3,a_4) * t(a_4,i_2) -> I(i_3,a_2,i_2,a_3)
-Cache | Store | 11539558536615948187 | 1/2 | 3 | 178122624B
-Eval | Tensor | 2435ns | 88751616B | t(a_1,a_3,i_1,i_3)
-Eval | Product | 121820200ns | 266254848B | I(i_3,a_2,i_2,a_3) * t(a_1,a_3,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 1664ns | 8B | {{{2}}}
-Eval | Product | 278738ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{2}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 731501ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | 2 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_1,i_3}:N-C-S
-Eval | SumInplace | 3829383ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -1 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S
-Eval | Tensor | 28896ns | 1152043680B | g(i_3,a_2,a_3,a_4)
-Eval | Tensor | 1092ns | 36768B | t(a_4,i_3)
-Eval | Product | 70071879ns | 1152438504B | g(i_3,a_2,a_3,a_4) * t(a_4,i_3) -> I(a_2,a_3)
-Eval | Tensor | 2134ns | 88751616B | t(a_1,a_3,i_1,i_2)
-Eval | Product | 29798772ns | 177861288B | I(a_2,a_3) * t(a_1,a_3,i_1,i_2) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 1393ns | 8B | {{{-1}}}
-Eval | Product | 1031088ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{-1}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1911786ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | -1 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S
-Eval | SumInplace | 22847780ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -1 (f{i_3;a_3}:N-C-S * t{a_1,a_3;i_1,i_2}:N-C-S) * t{a_2;i_3}:N-C-S
-Eval | Tensor | 23866ns | 36768B | f(i_3,a_3)
-Eval | Tensor | 1283ns | 88751616B | t(a_1,a_3,i_1,i_2)
-Eval | Product | 33311666ns | 95722272B | f(i_3,a_3) * t(a_1,a_3,i_1,i_2) -> I(i_3,a_1,i_2,i_1)
-Eval | Tensor | 1713ns | 36768B | t(a_2,i_3)
-Eval | Product | 18437608ns | 95722272B | I(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 1293ns | 8B | {{{-1}}}
-Eval | Product | 624794ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{-1}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1655362ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | -1 (f{i_3;a_3}:N-C-S * t{a_1,a_3;i_1,i_2}:N-C-S) * t{a_2;i_3}:N-C-S
-Eval | SumInplace | 25608533ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -1 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_3,i_1}:N-C-S
-Cache | Release | 11539558536615948187 | 0/2 | 2 | 89371008B
-Eval | Tensor | 2254ns | 88751616B | t(a_1,a_3,i_3,i_1)
-Eval | Product | 131665623ns | 266254848B | I(i_3,a_2,i_2,a_3) * t(a_1,a_3,i_3,i_1) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 1573ns | 8B | {{{-1}}}
-Eval | Product | 977926ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{-1}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1881157ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | -1 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_3,i_1}:N-C-S
-Eval | SumInplace | 3608327ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -1 (g{i_3,a_1;a_3,a_4}:N-C-S * t{a_3,a_4;i_2,i_1}:N-C-S) * t{a_2;i_3}:N-C-S
-Eval | Tensor | 28875ns | 1152043680B | g(i_3,a_1,a_3,a_4)
-Eval | Tensor | 1102ns | 88751616B | t(a_3,a_4,i_2,i_1)
-Eval | Product | 188365620ns | 1247729184B | g(i_3,a_1,a_3,a_4) * t(a_3,a_4,i_2,i_1) -> I(i_3,a_1,i_2,i_1)
-Eval | Tensor | 2374ns | 36768B | t(a_2,i_3)
-Eval | Product | 33169531ns | 95722272B | I(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 1443ns | 8B | {{{-1}}}
-Eval | Product | 1001511ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{-1}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1205555ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | -1 (g{i_3,a_1;a_3,a_4}:N-C-S * t{a_3,a_4;i_2,i_1}:N-C-S) * t{a_2;i_3}:N-C-S
-Eval | SumInplace | 26919180ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -1 (g{i_3,a_2;i_1,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | Tensor | 25820ns | 88751616B | g(i_3,a_2,i_1,a_3)
-Eval | Tensor | 1102ns | 36768B | t(a_3,i_2)
-Eval | Product | 30061960ns | 95722272B | g(i_3,a_2,i_1,a_3) * t(a_3,i_2) -> I(i_3,a_2,i_1,i_2)
-Eval | Tensor | 2124ns | 36768B | t(a_1,i_3)
-Eval | Product | 32135938ns | 95722272B | I(i_3,a_2,i_1,i_2) * t(a_1,i_3) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1373ns | 8B | {{{-1}}}
-Eval | Product | 677837ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{-1}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 18656820ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | -1 (g{i_3,a_2;i_1,a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | SumInplace | 29481430ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S) * t{a_2;i_4}:N-C-S
-Eval | Tensor | 29907ns | 6614112B | g(i_3,i_4,i_2,a_3)
-Eval | Tensor | 1232ns | 88751616B | t(a_1,a_3,i_1,i_3)
-Eval | Product | 86093479ns | 102299616B | g(i_3,i_4,i_2,a_3) * t(a_1,a_3,i_1,i_3) -> I(i_4,a_1,i_1,i_2)
-Eval | Tensor | 2145ns | 36768B | t(a_2,i_4)
-Eval | Product | 27886485ns | 95722272B | I(i_4,a_1,i_1,i_2) * t(a_2,i_4) -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 943830ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S) * t{a_2;i_4}:N-C-S
-Eval | SumInplace | 29804623ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -1 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_4;i_1,i_3}:N-C-S
-Eval | Tensor | 24006ns | 1152043680B | g(i_3,a_2,a_3,a_4)
-Eval | Tensor | 1082ns | 36768B | t(a_3,i_2)
-Eval | Product | 83241911ns | 1240832064B | g(i_3,a_2,a_3,a_4) * t(a_3,i_2) -> I(i_3,a_2,i_2,a_4)
-Cache | Store | 10515943467231087096 | 2/3 | 4 | 178122624B
-Eval | Tensor | 2585ns | 88751616B | t(a_1,a_4,i_1,i_3)
-Eval | Product | 122063650ns | 266254848B | I(i_3,a_2,i_2,a_4) * t(a_1,a_4,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 1693ns | 8B | {{{-1}}}
-Eval | Product | 562645ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{-1}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1623320ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | -1 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_4;i_1,i_3}:N-C-S
-Eval | SumInplace | 3933805ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | 1/2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_3,i_1}:N-C-S) * t{a_2,a_4;i_4,i_2}:N-C-S
-Eval | Tensor | 25149ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 1363ns | 88751616B | t(a_1,a_3,i_3,i_1)
-Eval | Product | 117337127ns | 262423544B | g(i_3,i_4,a_3,a_4) * t(a_1,a_3,i_3,i_1) -> I(i_4,a_1,i_1,a_4)
-Eval | Tensor | 2304ns | 88751616B | t(a_2,a_4,i_4,i_2)
-Eval | Product | 121287533ns | 266254848B | I(i_4,a_1,i_1,a_4) * t(a_2,a_4,i_4,i_2) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1693ns | 8B | {{{\frac{1}{2}}}}
-Eval | Product | 889896ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{\frac{1}{2}}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 15113659ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | 1/2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_3,i_1}:N-C-S) * t{a_2,a_4;i_4,i_2}:N-C-S
-Eval | SumInplace | 3592888ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | -1 (g{i_3,a_1;a_3,a_4}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2,a_4;i_3,i_1}:N-C-S
-Cache | Access | 10515943467231087096 | 1/3 | 3 | 178122624B
-Eval | Tensor | 2385ns | 88751616B | t(a_2,a_4,i_3,i_1)
-Eval | Product | 124956698ns | 266254848B | I(i_3,a_1,i_2,a_4) * t(a_2,a_4,i_3,i_1) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 1512ns | 8B | {{{-1}}}
-Eval | Product | 406574ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{-1}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1051497ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | -1 (g{i_3,a_1;a_3,a_4}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_2,a_4;i_3,i_1}:N-C-S
-Eval | SumInplace | 3724952ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_2,i_4}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | Tensor | 26261ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 1293ns | 88751616B | t(a_3,a_4,i_2,i_4)
-Eval | Product | 123488707ns | 173682680B | g(i_3,i_4,a_3,a_4) * t(a_3,a_4,i_2,i_4) -> I(i_3,i_2)
-Eval | Tensor | 2023ns | 88751616B | t(a_1,a_2,i_1,i_3)
-Eval | Product | 34841855ns | 177513984B | I(i_3,i_2) * t(a_1,a_2,i_1,i_3) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1653ns | 8B | {{{-2}}}
-Eval | Product | 799933ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{-2}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 11514280ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | -2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_2,i_4}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | SumInplace | 22490772ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | 1/2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
-Eval | Tensor | 25850ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 1203ns | 88751616B | t(a_3,a_4,i_1,i_2)
-Eval | Product | 114275143ns | 174291320B | g(i_3,i_4,a_3,a_4) * t(a_3,a_4,i_1,i_2) -> I(i_4,i_3,i_2,i_1)
-Cache | Store | 14580268236581494750 | 1/2 | 4 | 178742016B
-Eval | Tensor | 2495ns | 88751616B | t(a_1,a_2,i_3,i_4)
-Eval | Product | 117289034ns | 178122624B | I(i_4,i_3,i_2,i_1) * t(a_1,a_2,i_3,i_4) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1533ns | 8B | {{{\frac{1}{2}}}}
-Eval | Product | 962656ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{\frac{1}{2}}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 20401724ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | 1/2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
-Eval | SumInplace | 24044688ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | -1 (f{i_3;a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | Tensor | 24808ns | 36768B | f(i_3,a_3)
-Eval | Tensor | 1122ns | 36768B | t(a_3,i_2)
-Eval | Product | 6780944ns | 84288B | f(i_3,a_3) * t(a_3,i_2) -> I(i_3,i_2)
-Eval | Tensor | 912ns | 88751616B | t(a_1,a_2,i_1,i_3)
-Eval | Product | 39114242ns | 177513984B | I(i_3,i_2) * t(a_1,a_2,i_1,i_3) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 1373ns | 8B | {{{-1}}}
-Eval | Product | 918861ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{-1}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 858585ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | -1 (f{i_3;a_3}:N-C-S * t{a_3;i_2}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | SumInplace | 21583753ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_2,a_4;i_3,i_4}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S
-Eval | Tensor | 24538ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 1002ns | 88751616B | t(a_2,a_4,i_3,i_4)
-Eval | Product | 108183289ns | 174029984B | g(i_3,i_4,a_3,a_4) * t(a_2,a_4,i_3,i_4) -> I(a_2,a_3)
-Eval | Tensor | 2374ns | 88751616B | t(a_1,a_3,i_1,i_2)
-Eval | Product | 38801710ns | 177861288B | I(a_2,a_3) * t(a_1,a_3,i_1,i_2) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1743ns | 8B | {{{-2}}}
-Eval | Product | 899915ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{-2}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 7743630ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | -2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_2,a_4;i_3,i_4}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S
-Eval | SumInplace | 22649218ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_1,i_4}:N-C-S) * t{a_2,a_4;i_3,i_2}:N-C-S
-Eval | Tensor | 25449ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 1162ns | 88751616B | t(a_1,a_3,i_1,i_4)
-Eval | Product | 123202945ns | 262423544B | g(i_3,i_4,a_3,a_4) * t(a_1,a_3,i_1,i_4) -> I(i_3,a_1,i_1,a_4)
-Cache | Store | 1502144429761737779 | 1/2 | 5 | 267493632B
-Eval | Tensor | 2596ns | 88751616B | t(a_2,a_4,i_3,i_2)
-Eval | Product | 129458908ns | 266254848B | I(i_3,a_1,i_1,a_4) * t(a_2,a_4,i_3,i_2) -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 17474110ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_1,i_4}:N-C-S) * t{a_2,a_4;i_3,i_2}:N-C-S
-Eval | SumInplace | 3794636ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
-Eval | Tensor | 26030ns | 6614112B | g(i_3,i_4,i_2,a_3)
-Eval | Tensor | 1053ns | 36768B | t(a_3,i_3)
-Eval | Product | 18842429ns | 6661632B | g(i_3,i_4,i_2,a_3) * t(a_3,i_3) -> I(i_4,i_2)
-Eval | Tensor | 942ns | 88751616B | t(a_1,a_2,i_1,i_4)
-Eval | Product | 41386113ns | 177513984B | I(i_4,i_2) * t(a_1,a_2,i_1,i_4) -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1039264ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | (g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
-Eval | SumInplace | 23497343ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | 1/2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_3,i_2}:N-C-S) * t{a_2,a_3;i_4,i_1}:N-C-S
-Eval | Tensor | 24877ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 1002ns | 88751616B | t(a_1,a_4,i_3,i_2)
-Eval | Product | 116189835ns | 262423544B | g(i_3,i_4,a_3,a_4) * t(a_1,a_4,i_3,i_2) -> I(i_4,a_1,i_2,a_3)
-Eval | Tensor | 2375ns | 88751616B | t(a_2,a_3,i_4,i_1)
-Eval | Product | 133674004ns | 266254848B | I(i_4,a_1,i_2,a_3) * t(a_2,a_3,i_4,i_1) -> I(a_2,a_1,i_1,i_2)
-Eval | Constant | 1302ns | 8B | {{{\frac{1}{2}}}}
-Eval | Product | 683608ns | 177503240B | I(a_2,a_1,i_1,i_2) * {{{\frac{1}{2}}}} -> I(a_2,a_1,i_1,i_2)
-Eval | Permute | 13405897ns | 177503232B | I(a_2,a_1,i_1,i_2)
-Term | End | 1/2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_3,i_2}:N-C-S) * t{a_2,a_3;i_4,i_1}:N-C-S
-Eval | SumInplace | 3925147ns | 177503232B | I(a_2,a_1,i_1,i_2)
-Term | Begin | (g{i_3,i_4;i_1,a_3}:N-C-S * t{a_1,a_3;i_3,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
-Eval | Tensor | 26631ns | 6614112B | g(i_3,i_4,i_1,a_3)
-Eval | Tensor | 1363ns | 88751616B | t(a_1,a_3,i_3,i_2)
-Eval | Product | 82868982ns | 102299616B | g(i_3,i_4,i_1,a_3) * t(a_1,a_3,i_3,i_2) -> I(i_4,a_1,i_2,i_1)
-Eval | Tensor | 2284ns | 36768B | t(a_2,i_4)
-Eval | Product | 25853786ns | 95722272B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1331507ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | (g{i_3,i_4;i_1,a_3}:N-C-S * t{a_1,a_3;i_3,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
-Eval | SumInplace | 25126934ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | 1/2 (g{i_3,i_4;i_1,i_2}:N-C-S * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
-Eval | Tensor | 29758ns | 574912B | g(i_3,i_4,i_1,i_2)
-Eval | Tensor | 1282ns | 36768B | t(a_1,i_3)
-Eval | Product | 31171158ns | 7545568B | g(i_3,i_4,i_1,i_2) * t(a_1,i_3) -> I(i_4,a_1,i_2,i_1)
-Eval | Tensor | 1282ns | 36768B | t(a_2,i_4)
-Eval | Product | 33928434ns | 95722272B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1282ns | 8B | {{{\frac{1}{2}}}}
-Eval | Product | 882050ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{\frac{1}{2}}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 24064105ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | 1/2 (g{i_3,i_4;i_1,i_2}:N-C-S * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
-Eval | SumInplace | 30051730ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | 2 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S
-Eval | Tensor | 25299ns | 1152043680B | g(i_3,a_2,a_3,a_4)
-Eval | Tensor | 1383ns | 36768B | t(a_3,i_3)
-Eval | Product | 69745950ns | 1152438504B | g(i_3,a_2,a_3,a_4) * t(a_3,i_3) -> I(a_2,a_4)
-Eval | Tensor | 2695ns | 88751616B | t(a_1,a_4,i_1,i_2)
-Eval | Product | 32630452ns | 177861288B | I(a_2,a_4) * t(a_1,a_4,i_1,i_2) -> I(a_1,a_2,i_1,i_2)
-Eval | Constant | 1213ns | 8B | {{{2}}}
-Eval | Product | 902540ns | 177503240B | I(a_1,a_2,i_1,i_2) * {{{2}}} -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 999287ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | 2 (g{i_3,a_2;a_3,a_4}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S
-Eval | SumInplace | 22757295ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -1 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_3}:N-C-S) * t{a_2,a_3;i_2,i_4}:N-C-S
-Cache | Release | 1502144429761737779 | 0/2 | 4 | 178742016B
-Eval | Tensor | 2455ns | 88751616B | t(a_2,a_3,i_2,i_4)
-Eval | Product | 124384093ns | 266254848B | I(i_4,a_1,i_1,a_3) * t(a_2,a_3,i_2,i_4) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1422ns | 8B | {{{-1}}}
-Eval | Product | 1544838ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{-1}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 16662305ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | -1 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_4;i_1,i_3}:N-C-S) * t{a_2,a_3;i_2,i_4}:N-C-S
-Eval | SumInplace | 3248353ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_2,a_3;i_3,i_4}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S
-Eval | Tensor | 29346ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 1212ns | 88751616B | t(a_2,a_3,i_3,i_4)
-Eval | Product | 107021538ns | 174029984B | g(i_3,i_4,a_3,a_4) * t(a_2,a_3,i_3,i_4) -> I(a_2,a_4)
-Eval | Tensor | 2394ns | 88751616B | t(a_1,a_4,i_1,i_2)
-Eval | Product | 36367185ns | 177861288B | I(a_2,a_4) * t(a_1,a_4,i_1,i_2) -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 17591487ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_2,a_3;i_3,i_4}:N-C-S) * t{a_1,a_4;i_1,i_2}:N-C-S
-Eval | SumInplace | 21623922ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S) * t{a_2,a_4;i_2,i_4}:N-C-S
-Cache | Release | 223784662887107466 | 0/2 | 3 | 89990400B
-Eval | Tensor | 2875ns | 88751616B | t(a_2,a_4,i_2,i_4)
-Eval | Product | 120865359ns | 266254848B | I(i_4,a_1,i_1,a_4) * t(a_2,a_4,i_2,i_4) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1393ns | 8B | {{{2}}}
-Eval | Product | 989668ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{2}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 21278345ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | 2 (g{i_3,i_4;a_3,a_4}:N-C-S * t{a_1,a_3;i_1,i_3}:N-C-S) * t{a_2,a_4;i_2,i_4}:N-C-S
-Eval | SumInplace | 4522169ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_2,a_3;i_4,i_1}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | Tensor | 28875ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 1373ns | 36768B | t(a_4,i_2)
-Eval | Product | 36615264ns | 91890968B | g(i_3,i_4,a_3,a_4) * t(a_4,i_2) -> I(i_4,i_3,i_2,a_3)
-Cache | Store | 14406268377898944426 | 4/5 | 7 | 96924288B
-Eval | Tensor | 1834ns | 88751616B | t(a_2,a_3,i_4,i_1)
-Eval | Product | 90152935ns | 102619392B | I(i_4,i_3,i_2,a_3) * t(a_2,a_3,i_4,i_1) -> I(i_3,a_2,i_1,i_2)
-Eval | Tensor | 2344ns | 36768B | t(a_1,i_3)
-Eval | Product | 26913770ns | 95722272B | I(i_3,a_2,i_1,i_2) * t(a_1,i_3) -> I(a_1,a_2,i_1,i_2)
-Eval | Permute | 1312381ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | End | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_2,a_3;i_4,i_1}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | SumInplace | 26789119ns | 177503232B | I(a_1,a_2,i_1,i_2)
-Term | Begin | -2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
-Eval | Tensor | 25509ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 1103ns | 36768B | t(a_3,i_3)
-Eval | Product | 27110990ns | 84993848B | g(i_3,i_4,a_3,a_4) * t(a_3,i_3) -> I(i_4,a_4)
-Cache | Store | 6443766742777296727 | 1/2 | 8 | 96961056B
-Eval | Tensor | 1603ns | 36768B | t(a_4,i_2)
-Eval | Product | 5897891ns | 84288B | I(i_4,a_4) * t(a_4,i_2) -> I(i_4,i_2)
-Eval | Tensor | 1052ns | 88751616B | t(a_1,a_2,i_1,i_4)
-Eval | Product | 33499017ns | 177513984B | I(i_4,i_2) * t(a_1,a_2,i_1,i_4) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1683ns | 8B | {{{-2}}}
-Eval | Product | 1408195ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{-2}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 16942706ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | -2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_3}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1,a_2;i_1,i_4}:N-C-S
-Eval | SumInplace | 22132391ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_4}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | Tensor | 25910ns | 84920312B | g(i_3,i_4,a_3,a_4)
-Eval | Tensor | 1162ns | 36768B | t(a_3,i_4)
-Eval | Product | 31830980ns | 84993848B | g(i_3,i_4,a_3,a_4) * t(a_3,i_4) -> I(i_3,a_4)
-Cache | Store | 4354995230928331310 | 1/2 | 9 | 96997824B
-Eval | Tensor | 1634ns | 36768B | t(a_4,i_2)
-Eval | Product | 7297369ns | 84288B | I(i_3,a_4) * t(a_4,i_2) -> I(i_3,i_2)
-Eval | Tensor | 911ns | 88751616B | t(a_1,a_2,i_1,i_3)
-Eval | Product | 33080951ns | 177513984B | I(i_3,i_2) * t(a_1,a_2,i_1,i_3) -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 14774465ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_4}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1,a_2;i_1,i_3}:N-C-S
-Eval | SumInplace | 20644824ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_1,i_4}:N-C-S) * t{a_2;i_3}:N-C-S
-Cache | Access | 14406268377898944426 | 3/5 | 8 | 96997824B
-Eval | Tensor | 2255ns | 88751616B | t(a_1,a_3,i_1,i_4)
-Eval | Product | 85457002ns | 102619392B | I(i_4,i_3,i_2,a_3) * t(a_1,a_3,i_1,i_4) -> I(i_3,a_1,i_1,i_2)
-Eval | Tensor | 2134ns | 36768B | t(a_2,i_3)
-Eval | Product | 22890904ns | 95722272B | I(i_3,a_1,i_1,i_2) * t(a_2,i_3) -> I(a_2,a_1,i_1,i_2)
-Eval | Permute | 13873037ns | 177503232B | I(a_2,a_1,i_1,i_2)
-Term | End | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_1,i_4}:N-C-S) * t{a_2;i_3}:N-C-S
-Eval | SumInplace | 25246816ns | 177503232B | I(a_2,a_1,i_1,i_2)
-Term | Begin | -2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S) * t{a_2;i_3}:N-C-S
-Cache | Release | 6443766742777296727 | 0/2 | 7 | 96961056B
-Eval | Tensor | 2385ns | 88751616B | t(a_1,a_3,i_1,i_2)
-Eval | Product | 30947297ns | 95722272B | I(i_3,a_3) * t(a_1,a_3,i_1,i_2) -> I(i_3,a_1,i_2,i_1)
-Eval | Tensor | 2053ns | 36768B | t(a_2,i_3)
-Eval | Product | 12500421ns | 95722272B | I(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_2,a_1,i_1,i_2)
-Eval | Constant | 1393ns | 8B | {{{-2}}}
-Eval | Product | 1087967ns | 177503240B | I(a_2,a_1,i_1,i_2) * {{{-2}}} -> I(a_2,a_1,i_1,i_2)
-Eval | Permute | 12743640ns | 177503232B | I(a_2,a_1,i_1,i_2)
-Term | End | -2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_4}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S) * t{a_2;i_3}:N-C-S
-Eval | SumInplace | 28793684ns | 177503232B | I(a_2,a_1,i_1,i_2)
-Term | Begin | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_3,i_1}:N-C-S) * t{a_2;i_4}:N-C-S
-Cache | Access | 14406268377898944426 | 2/5 | 6 | 96961056B
-Eval | Tensor | 2235ns | 88751616B | t(a_1,a_3,i_3,i_1)
-Eval | Product | 85305089ns | 102619392B | I(i_4,i_3,i_2,a_3) * t(a_1,a_3,i_3,i_1) -> I(i_4,a_1,i_1,i_2)
-Eval | Tensor | 2375ns | 36768B | t(a_2,i_4)
-Eval | Product | 22304814ns | 95722272B | I(i_4,a_1,i_1,i_2) * t(a_2,i_4) -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 20621228ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_3,i_1}:N-C-S) * t{a_2;i_4}:N-C-S
-Eval | SumInplace | 28168498ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | ((g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1;i_4}:N-C-S) * t{a_2;i_3}:N-C-S
-Cache | Release | 10186165109937716840 | 0/2 | 5 | 96341664B
-Eval | Tensor | 2425ns | 36768B | t(a_1,i_4)
-Eval | Product | 27818153ns | 7590048B | I(i_3,i_4,i_2,i_1) * t(a_1,i_4) -> I(i_3,a_1,i_2,i_1)
-Eval | Tensor | 1383ns | 36768B | t(a_2,i_3)
-Eval | Product | 37284354ns | 95722272B | I(i_3,a_1,i_2,i_1) * t(a_2,i_3) -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 18914247ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | ((g{i_3,i_4;i_2,a_3}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_1;i_4}:N-C-S) * t{a_2;i_3}:N-C-S
-Eval | SumInplace | 25921557ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
-Cache | Release | 4354995230928331310 | 0/2 | 4 | 96304896B
-Eval | Tensor | 2254ns | 88751616B | t(a_1,a_3,i_1,i_2)
-Eval | Product | 32036226ns | 95722272B | I(i_4,a_3) * t(a_1,a_3,i_1,i_2) -> I(i_4,a_1,i_2,i_1)
-Eval | Tensor | 2635ns | 36768B | t(a_2,i_4)
-Eval | Product | 20068212ns | 95722272B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_2,a_1,i_1,i_2)
-Eval | Permute | 14438297ns | 177503232B | I(a_2,a_1,i_1,i_2)
-Term | End | ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_3}:N-C-S) * t{a_1,a_3;i_1,i_2}:N-C-S) * t{a_2;i_4}:N-C-S
-Eval | SumInplace | 29506939ns | 177503232B | I(a_2,a_1,i_1,i_2)
-Term | Begin | 1/2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
-Cache | Access | 14406268377898944426 | 1/5 | 3 | 96304896B
-Eval | Tensor | 2264ns | 36768B | t(a_4,i_2)
-Eval | Product | 28757244ns | 7590048B | I(i_3,i_4,i_1,a_4) * t(a_4,i_2) -> I(i_4,i_3,i_2,i_1)
-Cache | Store | 13639596688665582564 | 1/2 | 4 | 96924288B
-Eval | Tensor | 1643ns | 88751616B | t(a_1,a_2,i_3,i_4)
-Eval | Product | 115120954ns | 178122624B | I(i_4,i_3,i_2,i_1) * t(a_1,a_2,i_3,i_4) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1623ns | 8B | {{{\frac{1}{2}}}}
-Eval | Product | 875037ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{\frac{1}{2}}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 14803171ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | 1/2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1,a_2;i_3,i_4}:N-C-S
-Eval | SumInplace | 22515049ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | 1/2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S) * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
-Cache | Release | 14580268236581494750 | 0/2 | 3 | 96304896B
-Eval | Tensor | 2435ns | 36768B | t(a_1,i_3)
-Eval | Product | 24484576ns | 7590048B | I(i_4,i_3,i_2,i_1) * t(a_1,i_3) -> I(i_4,a_1,i_2,i_1)
-Eval | Tensor | 1392ns | 36768B | t(a_2,i_4)
-Eval | Product | 33570233ns | 95722272B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1603ns | 8B | {{{\frac{1}{2}}}}
-Eval | Product | 809481ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{\frac{1}{2}}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 16094770ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | 1/2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3,a_4;i_1,i_2}:N-C-S) * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
-Eval | SumInplace | 26613441ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | -1 ((g{i_3,a_2;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1;i_3}:N-C-S
-Cache | Release | 10515943467231087096 | 0/3 | 2 | 7553280B
-Eval | Tensor | 2826ns | 36768B | t(a_4,i_2)
-Eval | Product | 31527706ns | 95722272B | I(i_3,a_2,i_1,a_4) * t(a_4,i_2) -> I(i_3,a_2,i_1,i_2)
-Eval | Tensor | 1493ns | 36768B | t(a_1,i_3)
-Eval | Product | 36673837ns | 95722272B | I(i_3,a_2,i_1,i_2) * t(a_1,i_3) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1523ns | 8B | {{{-1}}}
-Eval | Product | 662968ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{-1}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 14007988ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | -1 ((g{i_3,a_2;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1;i_3}:N-C-S
-Eval | SumInplace | 28352384ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | -2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_1,i_3}:N-C-S) * t{a_2;i_4}:N-C-S
-Cache | Release | 14406268377898944426 | 0/5 | 1 | 619392B
-Eval | Tensor | 2304ns | 88751616B | t(a_1,a_3,i_1,i_3)
-Eval | Product | 90246305ns | 102619392B | I(i_4,i_3,i_2,a_3) * t(a_1,a_3,i_1,i_3) -> I(i_4,a_1,i_1,i_2)
-Eval | Tensor | 2044ns | 36768B | t(a_2,i_4)
-Eval | Product | 23938884ns | 95722272B | I(i_4,a_1,i_1,i_2) * t(a_2,i_4) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1282ns | 8B | {{{-2}}}
-Eval | Product | 698557ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{-2}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 18561737ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | -2 ((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_4;i_2}:N-C-S) * t{a_1,a_3;i_1,i_3}:N-C-S) * t{a_2;i_4}:N-C-S
-Eval | SumInplace | 28888868ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | Begin | 1/2 (((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
-Cache | Release | 13639596688665582564 | 0/2 | 0 | 0B
-Eval | Tensor | 2224ns | 36768B | t(a_1,i_3)
-Eval | Product | 30375184ns | 7590048B | I(i_4,i_3,i_2,i_1) * t(a_1,i_3) -> I(i_4,a_1,i_2,i_1)
-Eval | Tensor | 1263ns | 36768B | t(a_2,i_4)
-Eval | Product | 31757258ns | 95722272B | I(i_4,a_1,i_2,i_1) * t(a_2,i_4) -> I(a_2,a_1,i_2,i_1)
-Eval | Constant | 1373ns | 8B | {{{\frac{1}{2}}}}
-Eval | Product | 923321ns | 177503240B | I(a_2,a_1,i_2,i_1) * {{{\frac{1}{2}}}} -> I(a_2,a_1,i_2,i_1)
-Eval | Permute | 22182128ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Term | End | 1/2 (((g{i_3,i_4;a_3,a_4}:N-C-S * t{a_3;i_1}:N-C-S) * t{a_4;i_2}:N-C-S) * t{a_1;i_3}:N-C-S) * t{a_2;i_4}:N-C-S
-Eval | SumInplace | 28545316ns | 177503232B | I(a_2,a_1,i_2,i_1)
-Eval | Symmetrize | 26495984ns | 177503232B | I(a_1,a_2,i_1,i_2)

From 22ae856bea9ad85639772c28966085316de8388a Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 12 May 2026 16:49:59 -0400
Subject: [PATCH 5/6] ResultTensorOfTensorTA: use TA::Tensor as outer of
 "regular" companion array

The "regular" (non-nested) companion array used in ToT * T einsum
contractions had its outer tile set to the *inner* tile type of the
input ToT array. For TA-inner ToT that happens to work (TA::Tensor is a
valid outer tile too), but for btas-inner ToT it produced a
DistArray<btas::Tensor, ...> whose tile lacks the outer-tile API einsum
needs (permute/reshape/batch/...).

The outer tile must always be TA::Tensor; inner-tile types like
btas::Tensor are *inner-only*. Fix compatible_regular_distarray_type
to wrap the inner's numeric type in TA::Tensor.

Also bumps the TiledArray pin to the version that lifts the matching
TA-side restrictions (ValeevGroup/tiledarray#546).
---
 SeQuant/core/eval/backends/tiledarray/result.hpp | 8 +++++++-
 external/versions.cmake                          | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/SeQuant/core/eval/backends/tiledarray/result.hpp b/SeQuant/core/eval/backends/tiledarray/result.hpp
index c38640b985..2c9047e380 100644
--- a/SeQuant/core/eval/backends/tiledarray/result.hpp
+++ b/SeQuant/core/eval/backends/tiledarray/result.hpp
@@ -317,8 +317,14 @@ class ResultTensorOfTensorTA final : public Result {
 
   using _inner_tensor_type = typename ArrayT::value_type::value_type;
 
+  // "Regular" (non-nested) companion array for ToT * T einsum. The OUTER tile
+  // type must be a TA::Tensor — inner tile types like btas::Tensor are only
+  // valid as the *innermost* tile (they don't support permute/reshape/batch
+  // and so can't drive einsum's outer kernel). So we wrap the inner's numeric
+  // type in TA::Tensor here, rather than re-using the inner tile type as the
+  // outer tile.
   using compatible_regular_distarray_type =
-      TA::DistArray<_inner_tensor_type, typename ArrayT::policy_type>;
+      TA::DistArray<TA::Tensor<numeric_type>, typename ArrayT::policy_type>;
 
   // Only @c that_type type is allowed for ToT * T computation
   using that_type = ResultTensorTA<compatible_regular_distarray_type>;
diff --git a/external/versions.cmake b/external/versions.cmake
index c4a35110d5..ede8d041f2 100644
--- a/external/versions.cmake
+++ b/external/versions.cmake
@@ -5,7 +5,7 @@ set(SEQUANT_TRACKED_VGCMAKEKIT_TAG 256d9462bb765787f5acb69be154b26d6efba8b6)
 
 set(SEQUANT_TRACKED_RANGEV3_TAG 0.12.0)
 
-set(SEQUANT_TRACKED_TILEDARRAY_TAG 7f76cda06fd19658d376fd79b3d80dfe8e32c61e)
+set(SEQUANT_TRACKED_TILEDARRAY_TAG f06e9fca6dbd5fe07ae1ce6efc74e6b0a9d9e4eb)
 
 set(SEQUANT_TRACKED_LIBPERM_TAG cada3e185549896203cf4d0c7f26ea22c7de428f)
 

From 5c26211f2900928baa93a17f3840374a0bb168d9 Mon Sep 17 00:00:00 2001
From: Eduard Valeyev <eduard@valeyev.net>
Date: Tue, 12 May 2026 16:49:59 -0400
Subject: [PATCH 6/6] ResultTensorOfTensorTA: use TA::Tensor as outer of
 "regular" companion array

The "regular" (non-nested) companion array used in ToT * T einsum
contractions had its outer tile set to the *inner* tile type of the
input ToT array. For TA-inner ToT that happens to work (TA::Tensor is a
valid outer tile too), but for btas-inner ToT it produced a
DistArray<btas::Tensor, ...> whose tile lacks the outer-tile API einsum
needs (permute/reshape/batch/...).

The outer tile must always be TA::Tensor; inner-tile types like
btas::Tensor are *inner-only*. Fix compatible_regular_distarray_type
to wrap the inner's numeric type in TA::Tensor.

Also bumps the TiledArray pin to the version that lifts the matching
TA-side restrictions (ValeevGroup/tiledarray#546).
---
 SeQuant/core/eval/backends/tiledarray/result.hpp | 8 +++++++-
 external/versions.cmake                          | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/SeQuant/core/eval/backends/tiledarray/result.hpp b/SeQuant/core/eval/backends/tiledarray/result.hpp
index c38640b985..2c9047e380 100644
--- a/SeQuant/core/eval/backends/tiledarray/result.hpp
+++ b/SeQuant/core/eval/backends/tiledarray/result.hpp
@@ -317,8 +317,14 @@ class ResultTensorOfTensorTA final : public Result {
 
   using _inner_tensor_type = typename ArrayT::value_type::value_type;
 
+  // "Regular" (non-nested) companion array for ToT * T einsum. The OUTER tile
+  // type must be a TA::Tensor — inner tile types like btas::Tensor are only
+  // valid as the *innermost* tile (they don't support permute/reshape/batch
+  // and so can't drive einsum's outer kernel). So we wrap the inner's numeric
+  // type in TA::Tensor here, rather than re-using the inner tile type as the
+  // outer tile.
   using compatible_regular_distarray_type =
-      TA::DistArray<_inner_tensor_type, typename ArrayT::policy_type>;
+      TA::DistArray<TA::Tensor<numeric_type>, typename ArrayT::policy_type>;
 
   // Only @c that_type type is allowed for ToT * T computation
   using that_type = ResultTensorTA<compatible_regular_distarray_type>;
diff --git a/external/versions.cmake b/external/versions.cmake
index c4a35110d5..9c0ea8c3d5 100644
--- a/external/versions.cmake
+++ b/external/versions.cmake
@@ -5,7 +5,7 @@ set(SEQUANT_TRACKED_VGCMAKEKIT_TAG 256d9462bb765787f5acb69be154b26d6efba8b6)
 
 set(SEQUANT_TRACKED_RANGEV3_TAG 0.12.0)
 
-set(SEQUANT_TRACKED_TILEDARRAY_TAG 7f76cda06fd19658d376fd79b3d80dfe8e32c61e)
+set(SEQUANT_TRACKED_TILEDARRAY_TAG c782d06a0f796dabd33de4581fe59887f7bc668d)
 
 set(SEQUANT_TRACKED_LIBPERM_TAG cada3e185549896203cf4d0c7f26ea22c7de428f)