diff --git a/src/adiar/internal/io/arc_stream.h b/src/adiar/internal/io/arc_stream.h
index 317e40338..d8eebbeb6 100644
--- a/src/adiar/internal/io/arc_stream.h
+++ b/src/adiar/internal/io/arc_stream.h
@@ -52,17 +52,17 @@ namespace adiar::internal
     ////////////////////////////////////////////////////////////////////////////
     /// \brief Construct a stream attached to an arc file.
     ////////////////////////////////////////////////////////////////////////////
-    arc_stream(const levelized_file<arc>& file, bool negate = false)
+    arc_stream(const levelized_file<arc>& file)
     {
-      attach(file, negate);
+      attach(file);
     }
 
     ////////////////////////////////////////////////////////////////////////////
     /// \brief Construct a stream unattached to a shared arc file.
     ////////////////////////////////////////////////////////////////////////////
-    arc_stream(const shared_ptr<levelized_file<arc>>& file, bool negate = false)
+    arc_stream(const shared_ptr<levelized_file<arc>>& file)
     {
-      attach(file, negate);
+      attach(file);
     }
 
     ////////////////////////////////////////////////////////////////////////////
@@ -77,12 +77,12 @@ namespace adiar::internal
     /// \pre No `levelized_file_writer` is currently attached to this file.
     ////////////////////////////////////////////////////////////////////////////
     void
-    attach(const levelized_file<arc>& f, const bool negate = false)
+    attach(const levelized_file<arc>& f)
     {
       // adiar_assert(f.semi_transposed);
-      parent_t::attach(f, negate);
-      _unread_terminals[negate ^ false] = f.number_of_terminals[false];
-      _unread_terminals[negate ^ true]  = f.number_of_terminals[true];
+      parent_t::attach(f);
+      _unread_terminals[false] = f.number_of_terminals[false];
+      _unread_terminals[true]  = f.number_of_terminals[true];
     }
 
     ////////////////////////////////////////////////////////////////////////////
@@ -91,12 +91,12 @@ namespace adiar::internal
     /// \pre No `levelized_file_writer` is currently attached to this file.
     ////////////////////////////////////////////////////////////////////////////
     void
-    attach(const shared_ptr<levelized_file<arc>>& f, const bool negate = false)
+    attach(const shared_ptr<levelized_file<arc>>& f)
     {
       // adiar_assert(f->semi_transposed);
-      parent_t::attach(f, negate);
-      _unread_terminals[negate ^ false] = f->number_of_terminals[false];
-      _unread_terminals[negate ^ true]  = f->number_of_terminals[true];
+      parent_t::attach(f);
+      _unread_terminals[false] = f->number_of_terminals[false];
+      _unread_terminals[true]  = f->number_of_terminals[true];
     }
 
   public:
diff --git a/src/adiar/internal/io/file_stream.h b/src/adiar/internal/io/file_stream.h
index 4d790e00c..e8aa5e923 100644
--- a/src/adiar/internal/io/file_stream.h
+++ b/src/adiar/internal/io/file_stream.h
@@ -46,11 +46,6 @@ namespace adiar::internal
     ////////////////////////////////////////////////////////////////////////////////////////////////
     mutable bool _has_peeked = false;
 
-    ////////////////////////////////////////////////////////////////////////////////////////////////
-    /// \brief Whether elements should be \em negated on-the-fly.
-    ////////////////////////////////////////////////////////////////////////////////////////////////
-    bool _negate = false;
-
     ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief TPIE's file stream object to read the file with.
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -76,17 +71,17 @@ namespace adiar::internal
     ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Construct attached to a given shared `file<value_type>`.
     ////////////////////////////////////////////////////////////////////////////////////////////////
-    file_stream(const file<value_type>& f, bool negate = false)
+    file_stream(const file<value_type>& f)
     {
-      attach(f, negate);
+      attach(f);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Construct attached to a given shared `file<value_type>`.
     ////////////////////////////////////////////////////////////////////////////////////////////////
-    file_stream(const adiar::shared_ptr<file<value_type>>& f, bool negate = false)
+    file_stream(const adiar::shared_ptr<file<value_type>>& f)
     {
-      attach(f, negate);
+      attach(f);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -100,7 +95,7 @@ namespace adiar::internal
   protected:
     ////////////////////////////////////////////////////////////////////////////////////////////////
     void
-    attach(const file<value_type>& f, const adiar::shared_ptr<void>& shared_ptr, bool negate)
+    attach(const file<value_type>& f, const adiar::shared_ptr<void>& shared_ptr)
     {
       // Detach from prior file, if any.
       if (attached()) { detach(); }
@@ -115,9 +110,6 @@ namespace adiar::internal
       // Open the stream to the file
       _stream.open(f._tpie_file, file<value_type>::read_access);
       reset();
-
-      // Store negation flag.
-      _negate = negate;
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -132,9 +124,9 @@ namespace adiar::internal
     /// \pre No `file_writer` is currently attached to this file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
     void
-    attach(const file<value_type>& f, bool negate = false)
+    attach(const file<value_type>& f)
     {
-      attach(f, nullptr, negate);
+      attach(f, nullptr);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -143,9 +135,9 @@ namespace adiar::internal
     /// \pre No `file_writer` is currently attached to this file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
     void
-    attach(const adiar::shared_ptr<file<value_type>>& f, bool negate = false)
+    attach(const adiar::shared_ptr<file<value_type>>& f)
     {
-      attach(*f, f, negate);
+      attach(*f, f);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -207,13 +199,11 @@ namespace adiar::internal
     const value_type
     __read()
     {
-      value_type v;
       if constexpr (Reverse) {
-        v = _stream.read_back();
+        return _stream.read_back();
       } else {
-        v = _stream.read();
+        return _stream.read();
       }
-      return _negate ? !v : v;
     }
 
   public:
diff --git a/src/adiar/internal/io/levelized_file_stream.h b/src/adiar/internal/io/levelized_file_stream.h
index 327722af3..974d3460c 100644
--- a/src/adiar/internal/io/levelized_file_stream.h
+++ b/src/adiar/internal/io/levelized_file_stream.h
@@ -59,18 +59,17 @@ namespace adiar::internal
     ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Create attached to a levelized file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
-    levelized_file_stream(const levelized_file<value_type>& lf, const bool negate = false)
+    levelized_file_stream(const levelized_file<value_type>& lf)
     {
-      attach(lf, negate);
+      attach(lf);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Create attached to a shared levelized file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
-    levelized_file_stream(const shared_ptr<levelized_file<value_type>>& lf,
-                          const bool negate = false)
+    levelized_file_stream(const shared_ptr<levelized_file<value_type>>& lf)
     {
-      attach(lf, negate);
+      attach(lf);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -85,12 +84,12 @@ namespace adiar::internal
     /// \pre No `levelized_file_writer` is currently attached to this file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
     void
-    attach(const levelized_file<value_type>& f, const bool negate = false)
+    attach(const levelized_file<value_type>& f)
     {
       if (!f.exists()) f.__touch();
 
       for (size_t s_idx = 0; s_idx < streams; s_idx++)
-        _streams[s_idx].attach(f._files[s_idx], nullptr, negate);
+        _streams[s_idx].attach(f._files[s_idx], nullptr);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -99,12 +98,12 @@ namespace adiar::internal
     /// \pre No `levelized_file_writer` is currently attached to this file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
     void
-    attach(const shared_ptr<levelized_file<value_type>>& f, const bool negate = false)
+    attach(const shared_ptr<levelized_file<value_type>>& f)
     {
       if (!f->exists()) f->touch();
 
       for (size_t s_idx = 0; s_idx < streams; s_idx++)
-        _streams[s_idx].attach(f->_files[s_idx], f, negate);
+        _streams[s_idx].attach(f->_files[s_idx], f);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -262,7 +261,7 @@ namespace adiar::internal
     attach(const levelized_file<value_type, false>& lf)
     {
       if (!lf.exists()) lf.__touch();
-      parent_type::attach(lf._level_info_file, nullptr, false);
+      parent_type::attach(lf._level_info_file, nullptr);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -273,7 +272,7 @@ namespace adiar::internal
     attach(const adiar::shared_ptr<levelized_file<value_type, false>>& lf)
     {
       if (!lf->exists()) lf->touch();
-      parent_type::attach(lf->_level_info_file, lf, false);
+      parent_type::attach(lf->_level_info_file, lf);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/adiar/internal/io/node_arc_random_access.h b/src/adiar/internal/io/node_arc_random_access.h
index 91ad756a9..f1989a199 100644
--- a/src/adiar/internal/io/node_arc_random_access.h
+++ b/src/adiar/internal/io/node_arc_random_access.h
@@ -38,6 +38,7 @@ namespace adiar::internal
       : parent_type(f, negate)
     {
       // adiar_assert(f.indexable);
+      adiar_assert(negate == false);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -49,6 +50,7 @@ namespace adiar::internal
       : parent_type(f, negate)
     {
       // adiar_assert(f->indexable);
+      adiar_assert(negate == false);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -58,9 +60,7 @@ namespace adiar::internal
     ////////////////////////////////////////////////////////////////////////////////////////////////
     node_arc_random_access(const __dd& diagram)
       : node_arc_random_access(diagram.template get<__dd::shared_arc_file_type>(), diagram._negate)
-    {
-      // adiar_assert(diagram->indexable);
-    }
+    {}
 
   public:
     ////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/adiar/internal/io/node_arc_stream.h b/src/adiar/internal/io/node_arc_stream.h
index d7f7d8a13..dae9a06bb 100644
--- a/src/adiar/internal/io/node_arc_stream.h
+++ b/src/adiar/internal/io/node_arc_stream.h
@@ -26,13 +26,19 @@ namespace adiar::internal
     using value_type = node;
 
   private:
+    ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Arc-based input to-be converted into nodes on-the-fly.
+    ////////////////////////////////////////////////////////////////////////////////////////////////
     arc_stream<!Reverse> _stream;
 
+    ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Whether a converted node has been buffered.
+    ////////////////////////////////////////////////////////////////////////////////////////////////
     bool _has_peeked = false;
 
+    ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Latest converted node.
+    ////////////////////////////////////////////////////////////////////////////////////////////////
     node _peeked;
 
   public:
@@ -63,19 +69,23 @@ namespace adiar::internal
     ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Create attached to an arc file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
-    node_arc_stream(levelized_file<arc>& file, const bool negate = false)
+    node_arc_stream(levelized_file<arc>& file,
+                    [[maybe_unused]] const bool negate = false)
       : _stream(/*need to sort before attach*/)
     {
-      attach(file, negate);
+      adiar_assert(negate == false);
+      attach(file);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Create attached to a shared arc file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
-    node_arc_stream(const shared_ptr<levelized_file<arc>>& file, const bool negate = false)
+    node_arc_stream(const shared_ptr<levelized_file<arc>>& file,
+                    [[maybe_unused]] const bool negate = false)
       : _stream(/*need to sort before attach*/)
     {
-      attach(file, negate);
+      adiar_assert(negate == false);
+      attach(file);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -87,7 +97,8 @@ namespace adiar::internal
       : _stream(/*need to sort before attach*/)
     {
       adiar_assert(diagram.template has<__dd::shared_arc_file_type>());
-      attach(diagram.template get<__dd::shared_arc_file_type>(), diagram._negate);
+      adiar_assert(diagram._negate == false);
+      attach(diagram.template get<__dd::shared_arc_file_type>());
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -96,13 +107,13 @@ namespace adiar::internal
     /// \remark This sorts the internal arcs of the file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
     void
-    attach(levelized_file<arc>& file, const bool negate = false)
+    attach(levelized_file<arc>& file)
     {
       if (file.semi_transposed) {
         file.sort<arc_source_lt>(idx__internal);
         file.semi_transposed = false;
       }
-      _stream.attach(file, negate);
+      _stream.attach(file);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -111,13 +122,13 @@ namespace adiar::internal
     /// \remark This sorts the internal arcs of the file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
     void
-    attach(const shared_ptr<levelized_file<arc>>& file, const bool negate = false)
+    attach(const shared_ptr<levelized_file<arc>>& file)
     {
       if (file->semi_transposed) {
         file->sort<arc_source_lt>(idx__internal);
         file->semi_transposed = false;
       }
-      _stream.attach(file, negate);
+      _stream.attach(file);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/adiar/internal/io/node_stream.h b/src/adiar/internal/io/node_stream.h
index 44bb0e931..7dcdee5d6 100644
--- a/src/adiar/internal/io/node_stream.h
+++ b/src/adiar/internal/io/node_stream.h
@@ -23,6 +23,11 @@ namespace adiar::internal
   {
     using parent_type = levelized_file_stream<node, !Reverse>;
 
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    /// \brief Whether nodes should be \em negated on-the-fly.
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    bool _negate = false;
+
   public:
     ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Create unattached to any file.
@@ -37,21 +42,24 @@ namespace adiar::internal
     /// \brief Create attached to a node file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
     node_stream(const levelized_file<node>& file, bool negate = false)
-      : parent_type(file, negate)
+      : parent_type(file)
+      , _negate(negate)
     {}
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Create attached to a shared node file.
     ////////////////////////////////////////////////////////////////////////////////////////////////
     node_stream(const shared_ptr<levelized_file<node>>& file, bool negate = false)
-      : parent_type(file, negate)
+      : parent_type(file)
+      , _negate(negate)
     {}
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
     /// \brief Create attached to a Decision Diagram.
     ////////////////////////////////////////////////////////////////////////////////////////////////
     node_stream(const dd& diagram)
-      : parent_type(diagram.file_ptr(), diagram.is_negated())
+      : parent_type(diagram.file_ptr())
+      , _negate(diagram.is_negated())
     {}
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -71,7 +79,7 @@ namespace adiar::internal
     const node
     pull()
     {
-      return parent_type::template pull<0>();
+      return cnot(parent_type::template pull<0>(), this->_negate);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -82,7 +90,7 @@ namespace adiar::internal
     const node
     peek()
     {
-      return parent_type::template peek<0>();
+      return cnot(parent_type::template peek<0>(), this->_negate);
     }
 
     ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -95,7 +103,7 @@ namespace adiar::internal
     const node
     seek(const node::uid_type& u)
     {
-      return parent_type::_streams[0].seek(u);
+      return cnot(parent_type::_streams[0].seek(u), this->_negate);
     }
   };
 }
diff --git a/test/adiar/internal/io/test_arc_file.cpp b/test/adiar/internal/io/test_arc_file.cpp
index 273c83291..768ca6b19 100644
--- a/test/adiar/internal/io/test_arc_file.cpp
+++ b/test/adiar/internal/io/test_arc_file.cpp
@@ -239,6 +239,7 @@ go_bandit([]() {
         AssertThat(as.can_pull_terminal(), Is().False());
       });
 
+      /*
       it("merges terminal arcs on 'pull' [negated]", [&af]() {
         arc_stream<> as(af, true);
 
@@ -259,6 +260,7 @@ go_bandit([]() {
                    Is().EqualTo(arc(arc::pointer_type(1, 0), true, arc::pointer_type(false))));
         AssertThat(as.can_pull_terminal(), Is().False());
       });
+      */
 
       it("reads internal arcs as given [non-default: forwards]", [&af]() {
         arc_stream<> as(af);
@@ -318,6 +320,7 @@ go_bandit([]() {
         AssertThat(as.unread_terminals(true), Is().EqualTo(0u));
       });
 
+      /*
       it("provides number of unread terminals [negate=true]", [&af]() {
         arc_stream<> as(af, true);
 
@@ -360,6 +363,7 @@ go_bandit([]() {
         AssertThat(as.unread_terminals(false), Is().EqualTo(0u));
         AssertThat(as.unread_terminals(true), Is().EqualTo(0u));
       });
+      */
     });
 
     describe("arc_writer + node_arc_stream", []() {
@@ -460,6 +464,7 @@ go_bandit([]() {
         AssertThat(ns.can_pull(), Is().True());
       });
 
+      /*
       it("can read single-node BDD [negated]", [&]() {
         node_arc_stream ns(x0_ordered, true);
 
@@ -469,6 +474,7 @@ go_bandit([]() {
 
         AssertThat(ns.can_pull(), Is().False());
       });
+      */
 
       it("can pull after peek of single-node BDD", [&]() {
         node_arc_stream ns(x0_ordered);
@@ -746,6 +752,7 @@ go_bandit([]() {
         AssertThat(ns.can_pull(), Is().False());
       });
 
+      /*
       it("can pull larger BDD [negated + reverse]", [&]() {
         AssertThat(large_untransposed2.semi_transposed, Is().False());
 
@@ -773,6 +780,7 @@ go_bandit([]() {
 
         AssertThat(ns.can_pull(), Is().False());
       });
+      */
     });
 
     describe("arc_writer + node_arc_random_access", []() {