diff --git a/crates/fayalite/src/sim.rs b/crates/fayalite/src/sim.rs
index 45691ea..b3e4cd6 100644
--- a/crates/fayalite/src/sim.rs
+++ b/crates/fayalite/src/sim.rs
@@ -828,6 +828,7 @@ where
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub(crate) struct SimTrace<K, S> {
     kind: K,
+    maybe_changed: bool,
     state: S,
     last_state: S,
 }
@@ -848,12 +849,14 @@ impl<K: fmt::Debug> SimTraceDebug<TraceScalarId> for SimTrace<K, ()> {
     fn fmt(&self, id: TraceScalarId, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let Self {
             kind,
+            maybe_changed,
             state,
             last_state,
         } = self;
         f.debug_struct("SimTrace")
             .field("id", &id)
             .field("kind", kind)
+            .field("maybe_changed", maybe_changed)
             .field("state", state)
             .field("last_state", last_state)
             .finish()
@@ -864,12 +867,14 @@ impl<K: fmt::Debug> SimTraceDebug<TraceScalarId> for SimTrace<K, SimTraceState>
     fn fmt(&self, id: TraceScalarId, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let Self {
             kind,
+            maybe_changed,
             state,
             last_state,
         } = self;
         f.debug_struct("SimTrace")
             .field("id", &id)
             .field("kind", kind)
+            .field("maybe_changed", maybe_changed)
             .field("state", state)
             .field("last_state", last_state)
             .finish()
@@ -2078,10 +2083,12 @@ impl SimulationImpl {
             traces: SimTraces(Box::from_iter(compiled.traces.0.iter().map(
                 |&SimTrace {
                      kind,
+                     maybe_changed: _,
                      state: _,
                      last_state: _,
                  }| SimTrace {
                     kind,
+                    maybe_changed: true,
                     state: kind.make_state(),
                     last_state: kind.make_state(),
                 },
@@ -2126,13 +2133,16 @@ impl SimulationImpl {
             id,
             &SimTrace {
                 kind,
+                maybe_changed,
                 ref state,
                 ref last_state,
             },
         ) in self.traces.0.iter().enumerate()
         {
-            if ONLY_IF_CHANGED && state == last_state {
-                continue;
+            if ONLY_IF_CHANGED {
+                if !(maybe_changed && state != last_state) {
+                    continue;
+                }
             }
             let id = TraceScalarId(id);
             match kind {
@@ -2193,10 +2203,45 @@ impl SimulationImpl {
     fn read_traces<const IS_INITIAL_STEP: bool>(&mut self) {
         for &mut SimTrace {
             kind,
+            ref mut maybe_changed,
             ref mut state,
             ref mut last_state,
         } in &mut self.traces.0
         {
+            let new_maybe_changed = match kind {
+                SimTraceKind::BigUInt { index, ty: _ }
+                | SimTraceKind::BigSInt { index, ty: _ }
+                | SimTraceKind::BigBool { index }
+                | SimTraceKind::BigAsyncReset { index }
+                | SimTraceKind::BigSyncReset { index }
+                | SimTraceKind::BigClock { index } => self
+                    .state
+                    .big_slots
+                    .state_index_fetch_and_clear_maybe_modified_flag(index),
+                SimTraceKind::SmallUInt { index, ty: _ }
+                | SimTraceKind::SmallSInt { index, ty: _ }
+                | SimTraceKind::SmallBool { index }
+                | SimTraceKind::SmallAsyncReset { index }
+                | SimTraceKind::SmallSyncReset { index }
+                | SimTraceKind::SmallClock { index }
+                | SimTraceKind::EnumDiscriminant { index, ty: _ } => self
+                    .state
+                    .small_slots
+                    .state_index_fetch_and_clear_maybe_modified_flag(index),
+                SimTraceKind::SimOnly { index, ty: _ } => self
+                    .state
+                    .sim_only_slots
+                    .state_index_fetch_and_clear_maybe_modified_flag(index),
+                SimTraceKind::PhantomConst { ty: _ } => IS_INITIAL_STEP,
+            };
+            if !new_maybe_changed && !IS_INITIAL_STEP {
+                if *maybe_changed {
+                    last_state.clone_from(state);
+                }
+                *maybe_changed = false;
+                continue;
+            }
+            *maybe_changed = new_maybe_changed;
             if !IS_INITIAL_STEP {
                 mem::swap(state, last_state);
             }
diff --git a/crates/fayalite/src/sim/compiler.rs b/crates/fayalite/src/sim/compiler.rs
index e85ff0f..dbdbffb 100644
--- a/crates/fayalite/src/sim/compiler.rs
+++ b/crates/fayalite/src/sim/compiler.rs
@@ -2234,6 +2234,7 @@ impl Compiler {
         let id = TraceScalarId(self.traces.0.len());
         self.traces.0.push(SimTrace {
             kind,
+            maybe_changed: true,
             state: (),
             last_state: (),
         });
diff --git a/crates/fayalite/src/sim/interpreter.rs b/crates/fayalite/src/sim/interpreter.rs
index 2b121b5..0cf98d0 100644
--- a/crates/fayalite/src/sim/interpreter.rs
+++ b/crates/fayalite/src/sim/interpreter.rs
@@ -17,12 +17,11 @@ use bitvec::slice::BitSlice;
 use num_bigint::BigInt;
 use num_traits::{One, Signed, ToPrimitive, Zero};
 use std::{
-    borrow::BorrowMut,
     convert::Infallible,
     fmt::{self, Write},
     hash::Hash,
     marker::PhantomData,
-    ops::{ControlFlow, Deref, DerefMut, Index, IndexMut},
+    ops::{ControlFlow, Deref, Index, IndexMut},
 };
 use vec_map::VecMap;
 
@@ -915,6 +914,12 @@ impl<K: StatePartKind> StatePart<K> {
             value: K::borrow_state(&mut self.value),
         }
     }
+    pub(crate) fn state_index_fetch_and_clear_maybe_modified_flag(
+        &mut self,
+        part_index: StatePartIndex<K>,
+    ) -> bool {
+        K::state_index_fetch_and_clear_maybe_modified_flag(&mut self.value, part_index)
+    }
 }
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
@@ -922,56 +927,38 @@ pub(crate) struct BorrowedStatePart<'a, K: StatePartKind> {
     pub(crate) value: K::BorrowedState<'a>,
 }
 
-impl<
-    'a,
-    K: StatePartKind<
-        BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T> + BorrowMut<[T]>>,
-    >,
-    T,
-> BorrowedStatePart<'a, K>
-{
+impl<K: StatePartKind> BorrowedStatePart<'_, K> {
     pub(crate) fn get_disjoint_mut<const N: usize>(
         &mut self,
         indexes: [StatePartIndex<K>; N],
-    ) -> [&mut T; N] {
-        (*self.value)
-            .borrow_mut()
-            .get_disjoint_mut(indexes.map(|v| v.value as usize))
-            .expect("indexes are disjoint")
+    ) -> [&mut K::StateElement; N] {
+        K::borrowed_state_get_disjoint_mut(&mut self.value, indexes)
     }
 }
 
-impl<K: StatePartKind<State: Deref<Target: Index<usize, Output = T>>>, T> Index<StatePartIndex<K>>
-    for StatePart<K>
-{
-    type Output = T;
+impl<K: StatePartKind> Index<StatePartIndex<K>> for StatePart<K> {
+    type Output = K::StateElement;
     fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
-        &self.value[index.value as usize]
+        K::state_index(&self.value, index)
     }
 }
 
-impl<K: StatePartKind<State: DerefMut<Target: IndexMut<usize, Output = T>>>, T>
-    IndexMut<StatePartIndex<K>> for StatePart<K>
-{
+impl<K: StatePartKind> IndexMut<StatePartIndex<K>> for StatePart<K> {
     fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
-        &mut self.value[index.value as usize]
+        K::state_index_mut(&mut self.value, index)
     }
 }
 
-impl<'a, K: StatePartKind<BorrowedState<'a>: Deref<Target: Index<usize, Output = T>>>, T>
-    Index<StatePartIndex<K>> for BorrowedStatePart<'a, K>
-{
-    type Output = T;
+impl<K: StatePartKind> Index<StatePartIndex<K>> for BorrowedStatePart<'_, K> {
+    type Output = K::StateElement;
     fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
-        &self.value[index.value as usize]
+        K::borrowed_state_index(&self.value, index)
     }
 }
 
-impl<'a, K: StatePartKind<BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T>>>, T>
-    IndexMut<StatePartIndex<K>> for BorrowedStatePart<'a, K>
-{
+impl<K: StatePartKind> IndexMut<StatePartIndex<K>> for BorrowedStatePart<'_, K> {
     fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
-        &mut self.value[index.value as usize]
+        K::borrowed_state_index_mut(&mut self.value, index)
     }
 }
 
diff --git a/crates/fayalite/src/sim/interpreter/parts.rs b/crates/fayalite/src/sim/interpreter/parts.rs
index 75427c9..d9e4214 100644
--- a/crates/fayalite/src/sim/interpreter/parts.rs
+++ b/crates/fayalite/src/sim/interpreter/parts.rs
@@ -236,6 +236,7 @@ pub(crate) trait StatePartKind:
     type LayoutData: Send + Sync + Eq + Hash + fmt::Debug + 'static + Copy;
     type State: fmt::Debug + 'static + Clone;
     type BorrowedState<'a>: 'a;
+    type StateElement;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State;
     fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a>;
     fn part_debug_data<BK: InsnsBuildingKind>(
@@ -247,6 +248,30 @@ pub(crate) trait StatePartKind:
         index: StatePartIndex<Self>,
         f: &mut impl fmt::Write,
     ) -> fmt::Result;
+    fn state_index<'a>(
+        state: &'a Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement;
+    fn state_index_mut<'a>(
+        state: &'a mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement;
+    fn state_index_fetch_and_clear_maybe_modified_flag(
+        state: &mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> bool;
+    fn borrowed_state_index<'a, 'b>(
+        state: &'a Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement;
+    fn borrowed_state_index_mut<'a, 'b>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement;
+    fn borrowed_state_get_disjoint_mut<'a, 'b, const N: usize>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_indexes: [StatePartIndex<Self>; N],
+    ) -> [&'a mut Self::StateElement; N];
 }
 
 macro_rules! make_state_part_kinds {
@@ -272,6 +297,7 @@ impl StatePartKind for StatePartKindMemories {
     type LayoutData = MemoryData<Interned<BitSlice>>;
     type State = Box<[MemoryData<BitBox>]>;
     type BorrowedState<'a> = &'a mut [MemoryData<BitBox>];
+    type StateElement = MemoryData<BitBox>;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
         layout_data
             .iter()
@@ -297,19 +323,88 @@ impl StatePartKind for StatePartKindMemories {
     ) -> fmt::Result {
         write!(f, "{:#?}", &state.memories[index])
     }
+    fn state_index<'a>(
+        state: &'a Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state[part_index.as_usize()]
+    }
+    fn state_index_mut<'a>(
+        state: &'a mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        &mut state[part_index.as_usize()]
+    }
+    fn state_index_fetch_and_clear_maybe_modified_flag(
+        _state: &mut Self::State,
+        _part_index: StatePartIndex<Self>,
+    ) -> bool {
+        true
+    }
+    fn borrowed_state_index<'a, 'b>(
+        state: &'a Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state[part_index.as_usize()]
+    }
+    fn borrowed_state_index_mut<'a, 'b>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        &mut state[part_index.as_usize()]
+    }
+    fn borrowed_state_get_disjoint_mut<'a, 'b, const N: usize>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_indexes: [StatePartIndex<Self>; N],
+    ) -> [&'a mut Self::StateElement; N] {
+        state
+            .get_disjoint_mut(part_indexes.map(StatePartIndex::as_usize))
+            .expect("indexes are disjoint")
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
+pub(crate) struct StateAndModified<T, M> {
+    pub(crate) state: T,
+    pub(crate) modified: M,
+}
+
+impl<T: Deref<Target = [E]>, M: Deref<Target = [bool]>, E: fmt::Debug> fmt::Debug
+    for StateAndModified<T, M>
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list()
+            .entries(self.state.iter().zip(self.modified.iter().copied()).map(
+                |(state, modified)| {
+                    fmt::from_fn(move |f| {
+                        state.fmt(f)?;
+                        if modified {
+                            f.write_str(" (modified)")?;
+                        }
+                        Ok(())
+                    })
+                },
+            ))
+            .finish()
+    }
 }
 
 impl StatePartKind for StatePartKindSmallSlots {
     const NAME: &'static str = "SmallSlots";
     type DebugData = SlotDebugData;
     type LayoutData = ();
-    type State = Box<[SmallUInt]>;
-    type BorrowedState<'a> = &'a mut [SmallUInt];
+    type State = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
+    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
+    type StateElement = SmallUInt;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        vec![0; layout_data.len()].into_boxed_slice()
+        StateAndModified {
+            state: vec![0; layout_data.len()].into_boxed_slice(),
+            modified: vec![false; layout_data.len()].into_boxed_slice(),
+        }
     }
     fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
-        state
+        let StateAndModified { state, modified } = state;
+        StateAndModified { state, modified }
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -330,19 +425,69 @@ impl StatePartKind for StatePartKindSmallSlots {
         write!(f, "{value:#x} {}", value as SmallSInt)?;
         Ok(())
     }
+    fn state_index<'a>(
+        state: &'a Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn state_index_mut<'a>(
+        state: &'a mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn state_index_fetch_and_clear_maybe_modified_flag(
+        state: &mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> bool {
+        std::mem::replace(&mut state.modified[part_index.as_usize()], false)
+    }
+    fn borrowed_state_index<'a, 'b>(
+        state: &'a Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_index_mut<'a, 'b>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_get_disjoint_mut<'a, 'b, const N: usize>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_indexes: [StatePartIndex<Self>; N],
+    ) -> [&'a mut Self::StateElement; N] {
+        for part_index in part_indexes {
+            state.modified[part_index.as_usize()] = true;
+        }
+        state
+            .state
+            .get_disjoint_mut(part_indexes.map(StatePartIndex::as_usize))
+            .expect("indexes are disjoint")
+    }
 }
 
 impl StatePartKind for StatePartKindBigSlots {
     const NAME: &'static str = "BigSlots";
     type DebugData = SlotDebugData;
     type LayoutData = ();
-    type State = Box<[BigInt]>;
-    type BorrowedState<'a> = &'a mut [BigInt];
+    type State = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
+    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
+    type StateElement = BigInt;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        layout_data.iter().map(|_| BigInt::default()).collect()
+        let state: Box<[_]> = layout_data.iter().map(|_| BigInt::default()).collect();
+        StateAndModified {
+            modified: vec![false; state.len()].into_boxed_slice(),
+            state,
+        }
     }
     fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
-        state
+        let StateAndModified { state, modified } = state;
+        StateAndModified { state, modified }
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -361,19 +506,69 @@ impl StatePartKind for StatePartKindBigSlots {
     ) -> fmt::Result {
         write!(f, "{:#x}", state.big_slots[index])
     }
+    fn state_index<'a>(
+        state: &'a Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn state_index_mut<'a>(
+        state: &'a mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn state_index_fetch_and_clear_maybe_modified_flag(
+        state: &mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> bool {
+        std::mem::replace(&mut state.modified[part_index.as_usize()], false)
+    }
+    fn borrowed_state_index<'a, 'b>(
+        state: &'a Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_index_mut<'a, 'b>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_get_disjoint_mut<'a, 'b, const N: usize>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_indexes: [StatePartIndex<Self>; N],
+    ) -> [&'a mut Self::StateElement; N] {
+        for part_index in part_indexes {
+            state.modified[part_index.as_usize()] = true;
+        }
+        state
+            .state
+            .get_disjoint_mut(part_indexes.map(StatePartIndex::as_usize))
+            .expect("indexes are disjoint")
+    }
 }
 
 impl StatePartKind for StatePartKindSimOnlySlots {
     const NAME: &'static str = "SimOnlySlots";
     type DebugData = SlotDebugData;
     type LayoutData = DynSimOnly;
-    type State = Box<[DynSimOnlyValue]>;
-    type BorrowedState<'a> = &'a mut [DynSimOnlyValue];
+    type State = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
+    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
+    type StateElement = DynSimOnlyValue;
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        layout_data.iter().map(|ty| ty.default_value()).collect()
+        let state: Box<[_]> = layout_data.iter().map(|ty| ty.default_value()).collect();
+        StateAndModified {
+            modified: vec![false; state.len()].into_boxed_slice(),
+            state,
+        }
     }
     fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
-        state
+        let StateAndModified { state, modified } = state;
+        StateAndModified { state, modified }
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -392,6 +587,50 @@ impl StatePartKind for StatePartKindSimOnlySlots {
     ) -> fmt::Result {
         write!(f, "{:?}", state.sim_only_slots[index])
     }
+    fn state_index<'a>(
+        state: &'a Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn state_index_mut<'a>(
+        state: &'a mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn state_index_fetch_and_clear_maybe_modified_flag(
+        state: &mut Self::State,
+        part_index: StatePartIndex<Self>,
+    ) -> bool {
+        std::mem::replace(&mut state.modified[part_index.as_usize()], false)
+    }
+    fn borrowed_state_index<'a, 'b>(
+        state: &'a Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a Self::StateElement {
+        &state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_index_mut<'a, 'b>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_index: StatePartIndex<Self>,
+    ) -> &'a mut Self::StateElement {
+        state.modified[part_index.as_usize()] = true;
+        &mut state.state[part_index.as_usize()]
+    }
+    fn borrowed_state_get_disjoint_mut<'a, 'b, const N: usize>(
+        state: &'a mut Self::BorrowedState<'b>,
+        part_indexes: [StatePartIndex<Self>; N],
+    ) -> [&'a mut Self::StateElement; N] {
+        for part_index in part_indexes {
+            state.modified[part_index.as_usize()] = true;
+        }
+        state
+            .state
+            .get_disjoint_mut(part_indexes.map(StatePartIndex::as_usize))
+            .expect("indexes are disjoint")
+    }
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
diff --git a/crates/fayalite/tests/sim/expected/array_rw.txt b/crates/fayalite/tests/sim/expected/array_rw.txt
index 27b040d..2486eaa 100644
--- a/crates/fayalite/tests/sim/expected/array_rw.txt
+++ b/crates/fayalite/tests/sim/expected/array_rw.txt
@@ -424,8 +424,8 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                16,
-                0,
+                16 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
@@ -483,7 +483,7 @@ Simulation {
                 248,
                 252,
                 254,
-                255,
+                255 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1218,6 +1218,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1227,6 +1228,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(1),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x7f,
             last_state: 0x7f,
         },
@@ -1236,6 +1238,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x3f,
             last_state: 0x3f,
         },
@@ -1245,6 +1248,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1254,6 +1258,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x0f,
             last_state: 0x0f,
         },
@@ -1263,6 +1268,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x07,
             last_state: 0x07,
         },
@@ -1272,6 +1278,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x03,
             last_state: 0x03,
         },
@@ -1281,6 +1288,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(7),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x01,
             last_state: 0x01,
         },
@@ -1290,6 +1298,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1299,6 +1308,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x80,
             last_state: 0x80,
         },
@@ -1308,6 +1318,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1317,6 +1328,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1326,6 +1338,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(12),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf0,
             last_state: 0xf0,
         },
@@ -1335,6 +1348,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(13),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf8,
             last_state: 0xf8,
         },
@@ -1344,6 +1358,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfc,
             last_state: 0xfc,
         },
@@ -1353,6 +1368,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfe,
             last_state: 0xfe,
         },
@@ -1362,6 +1378,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1371,6 +1388,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x7f,
             last_state: 0x7f,
         },
@@ -1380,6 +1398,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x3f,
             last_state: 0x3f,
         },
@@ -1389,6 +1408,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(19),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1398,6 +1418,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x0f,
             last_state: 0x0f,
         },
@@ -1407,6 +1428,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(21),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x07,
             last_state: 0x07,
         },
@@ -1416,6 +1438,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x03,
             last_state: 0x03,
         },
@@ -1425,6 +1448,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(23),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x01,
             last_state: 0x01,
         },
@@ -1434,6 +1458,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(24),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1443,6 +1468,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x80,
             last_state: 0x80,
         },
@@ -1452,6 +1478,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(26),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1461,6 +1488,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(27),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1470,6 +1498,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(28),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf0,
             last_state: 0xf0,
         },
@@ -1479,6 +1508,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(29),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf8,
             last_state: 0xf8,
         },
@@ -1488,6 +1518,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(30),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfc,
             last_state: 0xfc,
         },
@@ -1497,6 +1528,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(31),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfe,
             last_state: 0xe1,
         },
@@ -1506,6 +1538,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(32),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1515,6 +1548,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(33),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1524,6 +1558,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(34),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x10,
             last_state: 0x0f,
         },
@@ -1533,6 +1568,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(35),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0xe1,
         },
@@ -1541,6 +1577,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1550,6 +1587,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(37),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1559,6 +1597,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(38),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x7f,
             last_state: 0x7f,
         },
@@ -1568,6 +1607,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(39),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x3f,
             last_state: 0x3f,
         },
@@ -1577,6 +1617,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(40),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1586,6 +1627,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(41),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x0f,
             last_state: 0x0f,
         },
@@ -1595,6 +1637,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x07,
             last_state: 0x07,
         },
@@ -1604,6 +1647,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(43),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x03,
             last_state: 0x03,
         },
@@ -1613,6 +1657,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(44),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x01,
             last_state: 0x01,
         },
@@ -1622,6 +1667,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(45),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1631,6 +1677,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(46),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x80,
             last_state: 0x80,
         },
@@ -1640,6 +1687,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(47),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1649,6 +1697,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(48),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1658,6 +1707,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(49),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf0,
             last_state: 0xf0,
         },
@@ -1667,6 +1717,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(50),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xf8,
             last_state: 0xf8,
         },
@@ -1676,6 +1727,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(51),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfc,
             last_state: 0xfc,
         },
@@ -1685,6 +1737,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(52),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xfe,
             last_state: 0xe1,
         },
diff --git a/crates/fayalite/tests/sim/expected/conditional_assignment_last.txt b/crates/fayalite/tests/sim/expected/conditional_assignment_last.txt
index d470792..0df7f20 100644
--- a/crates/fayalite/tests/sim/expected/conditional_assignment_last.txt
+++ b/crates/fayalite/tests/sim/expected/conditional_assignment_last.txt
@@ -86,8 +86,8 @@ Simulation {
             value: [
                 1,
                 0,
-                1,
-                0,
+                1 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -155,6 +155,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -163,6 +164,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
diff --git a/crates/fayalite/tests/sim/expected/connect_const.txt b/crates/fayalite/tests/sim/expected/connect_const.txt
index 56ea4ad..6cf4014 100644
--- a/crates/fayalite/tests/sim/expected/connect_const.txt
+++ b/crates/fayalite/tests/sim/expected/connect_const.txt
@@ -63,7 +63,7 @@ Simulation {
         big_slots: StatePart {
             value: [
                 5,
-                5,
+                5 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -124,6 +124,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x05,
             last_state: 0x05,
         },
diff --git a/crates/fayalite/tests/sim/expected/connect_const_reset.txt b/crates/fayalite/tests/sim/expected/connect_const_reset.txt
index 6b5814a..a75ff8a 100644
--- a/crates/fayalite/tests/sim/expected/connect_const_reset.txt
+++ b/crates/fayalite/tests/sim/expected/connect_const_reset.txt
@@ -90,9 +90,9 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                1,
-                1,
+                1 (modified),
+                1 (modified),
+                1 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -175,6 +175,7 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -183,6 +184,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
diff --git a/crates/fayalite/tests/sim/expected/counter_async.txt b/crates/fayalite/tests/sim/expected/counter_async.txt
index 2bdd665..256e1b7 100644
--- a/crates/fayalite/tests/sim/expected/counter_async.txt
+++ b/crates/fayalite/tests/sim/expected/counter_async.txt
@@ -185,10 +185,10 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                0,
-                0,
-                1,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
@@ -197,12 +197,12 @@ Simulation {
                 0,
                 3,
                 3,
-                4,
-                3,
-                0,
-                1,
-                4,
-                4,
+                4 (modified),
+                3 (modified),
+                0 (modified),
+                1 (modified),
+                4 (modified),
+                4 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -332,6 +332,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -340,6 +341,7 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -349,6 +351,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },
@@ -358,6 +361,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },
diff --git a/crates/fayalite/tests/sim/expected/counter_sync.txt b/crates/fayalite/tests/sim/expected/counter_sync.txt
index 87c2098..1448f58 100644
--- a/crates/fayalite/tests/sim/expected/counter_sync.txt
+++ b/crates/fayalite/tests/sim/expected/counter_sync.txt
@@ -167,10 +167,10 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                0,
-                0,
-                1,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
@@ -179,11 +179,11 @@ Simulation {
                 0,
                 3,
                 3,
-                4,
-                3,
-                1,
-                4,
-                4,
+                4 (modified),
+                3 (modified),
+                1 (modified),
+                4 (modified),
+                4 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -313,6 +313,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -321,6 +322,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -330,6 +332,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },
@@ -339,6 +342,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },
diff --git a/crates/fayalite/tests/sim/expected/duplicate_names.txt b/crates/fayalite/tests/sim/expected/duplicate_names.txt
index 64bbbe6..394cfbb 100644
--- a/crates/fayalite/tests/sim/expected/duplicate_names.txt
+++ b/crates/fayalite/tests/sim/expected/duplicate_names.txt
@@ -81,9 +81,9 @@ Simulation {
         big_slots: StatePart {
             value: [
                 5,
-                5,
-                6,
+                5 (modified),
                 6,
+                6 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -137,6 +137,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x05,
             last_state: 0x05,
         },
@@ -146,6 +147,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x06,
             last_state: 0x06,
         },
diff --git a/crates/fayalite/tests/sim/expected/enums.txt b/crates/fayalite/tests/sim/expected/enums.txt
index a3a52cb..2b00f05 100644
--- a/crates/fayalite/tests/sim/expected/enums.txt
+++ b/crates/fayalite/tests/sim/expected/enums.txt
@@ -1191,10 +1191,10 @@ Simulation {
             value: [
                 0,
                 0,
-                0,
-                0,
-                1,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
                 2,
             ],
         },
@@ -1207,110 +1207,110 @@ Simulation {
                 15,
                 2,
                 15,
+                0 (modified),
                 0,
                 0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
                 0,
                 0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                62,
-                62,
-                0,
-                0,
-                1,
-                1,
-                62,
-                3,
-                1,
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                62 (modified),
+                62 (modified),
+                0 (modified),
+                0 (modified),
                 1,
                 1,
+                62 (modified),
+                3 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
                 1,
                 1,
                 -1,
-                1,
-                1,
-                15,
-                3,
-                1,
-                1,
-                3,
-                -1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                2,
-                3,
-                12,
-                13,
-                13,
-                13,
-                2,
-                1,
-                1,
-                -1,
-                2,
-                1,
-                1,
-                -1,
-                1,
-                1,
-                1,
-                3,
-                -1,
-                2,
-                3,
-                3,
-                12,
-                15,
-                60,
-                62,
-                62,
-                62,
-                0,
-                0,
-                0,
-                1,
-                2,
-                3,
-                3,
-                1,
-                1,
-                1,
-                1,
-                1,
-                2,
-                3,
-                6,
-                7,
-                7,
-                7,
-                2,
-                3,
-                3,
-                12,
-                15,
+                1 (modified),
+                1 (modified),
+                15 (modified),
+                3 (modified),
+                1 (modified),
+                1 (modified),
+                3 (modified),
+                -1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                2 (modified),
+                3 (modified),
+                12 (modified),
+                13 (modified),
+                13 (modified),
+                13 (modified),
+                2 (modified),
+                1 (modified),
+                1 (modified),
+                -1 (modified),
+                2 (modified),
+                1 (modified),
+                1 (modified),
+                -1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                3 (modified),
+                -1 (modified),
+                2 (modified),
+                3 (modified),
+                3 (modified),
+                12 (modified),
+                15 (modified),
+                60 (modified),
+                62 (modified),
+                62 (modified),
+                62 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                2 (modified),
+                3 (modified),
+                3 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                2 (modified),
+                3 (modified),
+                6 (modified),
+                7 (modified),
+                7 (modified),
+                7 (modified),
+                2 (modified),
+                3 (modified),
+                3 (modified),
+                12 (modified),
+                15 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1746,6 +1746,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -1754,6 +1755,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1762,6 +1764,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1771,6 +1774,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<2>,
             },
+            maybe_changed: false,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1780,6 +1784,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<4>,
             },
+            maybe_changed: false,
             state: 0xf,
             last_state: 0xf,
         },
@@ -1789,6 +1794,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1798,6 +1804,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -1810,6 +1817,7 @@ Simulation {
                     HdlSome(Bundle {0: UInt<1>, 1: Bool}),
                 },
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1819,6 +1827,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1827,6 +1836,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(9),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1839,6 +1849,7 @@ Simulation {
                     HdlSome(Bundle {0: UInt<1>, 1: Bool}),
                 },
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1848,6 +1859,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1856,6 +1868,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1869,6 +1882,7 @@ Simulation {
                     C(Bundle {a: Array<UInt<1>, 2>, b: SInt<2>}),
                 },
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1878,6 +1892,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(27),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1886,6 +1901,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(28),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1895,6 +1911,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(34),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1904,6 +1921,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(35),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1913,6 +1931,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(36),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
diff --git a/crates/fayalite/tests/sim/expected/extern_module.txt b/crates/fayalite/tests/sim/expected/extern_module.txt
index f49106f..48a3af5 100644
--- a/crates/fayalite/tests/sim/expected/extern_module.txt
+++ b/crates/fayalite/tests/sim/expected/extern_module.txt
@@ -221,6 +221,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -229,6 +230,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/extern_module2.txt b/crates/fayalite/tests/sim/expected/extern_module2.txt
index 365830f..d488666 100644
--- a/crates/fayalite/tests/sim/expected/extern_module2.txt
+++ b/crates/fayalite/tests/sim/expected/extern_module2.txt
@@ -57,7 +57,7 @@ Simulation {
         big_slots: StatePart {
             value: [
                 0,
-                1,
+                1 (modified),
                 101,
             ],
         },
@@ -280,6 +280,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -288,6 +289,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -297,6 +299,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x65,
             last_state: 0x65,
         },
diff --git a/crates/fayalite/tests/sim/expected/last_connect.txt b/crates/fayalite/tests/sim/expected/last_connect.txt
index 6a43497..297d395 100644
--- a/crates/fayalite/tests/sim/expected/last_connect.txt
+++ b/crates/fayalite/tests/sim/expected/last_connect.txt
@@ -418,39 +418,39 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
-                31,
+                31 (modified),
                 1,
                 1,
                 1,
                 1,
-                31,
-                15,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                7,
-                7,
+                31 (modified),
+                15 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                7 (modified),
+                7 (modified),
                 3,
-                0,
-                0,
-                3,
-                1,
-                3,
-                1,
-                6,
-                7,
-                7,
-                7,
-                4,
-                0,
-                1,
-                2,
+                0 (modified),
+                0 (modified),
                 3,
+                1 (modified),
+                3 (modified),
+                1 (modified),
+                6 (modified),
+                7 (modified),
+                7 (modified),
+                7 (modified),
+                4 (modified),
+                0 (modified),
+                1 (modified),
+                2 (modified),
+                3 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -614,6 +614,7 @@ Simulation {
                     HdlSome(Array<Bool, 4>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -622,6 +623,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -630,6 +632,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -638,6 +641,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -646,6 +650,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -658,6 +663,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -667,6 +673,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x03,
             last_state: 0x02,
         },
@@ -676,6 +683,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x03,
             last_state: 0x02,
         },
diff --git a/crates/fayalite/tests/sim/expected/many_memories.txt b/crates/fayalite/tests/sim/expected/many_memories.txt
index c521d72..84d9162 100644
--- a/crates/fayalite/tests/sim/expected/many_memories.txt
+++ b/crates/fayalite/tests/sim/expected/many_memories.txt
@@ -2910,102 +2910,102 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                1,
-                0,
-                0,
-                1,
-                15,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                1,
-                15,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                1,
-                15,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                1,
-                15,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                1,
-                15,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                1,
-                15,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                1,
-                15,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                1,
-                15,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                15 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                15 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                15 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                15 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                15 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                15 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                15 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                15 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
@@ -3091,8 +3091,8 @@ Simulation {
                 0,
                 0,
                 1,
-                0,
-                1,
+                0 (modified),
+                1 (modified),
                 15,
                 1,
                 0,
@@ -3102,8 +3102,8 @@ Simulation {
                 0,
                 0,
                 1,
-                0,
-                1,
+                0 (modified),
+                1 (modified),
                 15,
                 1,
                 0,
@@ -3113,8 +3113,8 @@ Simulation {
                 0,
                 0,
                 1,
-                0,
-                1,
+                0 (modified),
+                1 (modified),
                 15,
                 1,
                 0,
@@ -3124,8 +3124,8 @@ Simulation {
                 0,
                 0,
                 1,
-                0,
-                1,
+                0 (modified),
+                1 (modified),
                 15,
                 1,
                 0,
@@ -3135,8 +3135,8 @@ Simulation {
                 0,
                 0,
                 1,
-                0,
-                1,
+                0 (modified),
+                1 (modified),
                 15,
                 1,
                 0,
@@ -3146,8 +3146,8 @@ Simulation {
                 0,
                 0,
                 1,
-                0,
-                1,
+                0 (modified),
+                1 (modified),
                 15,
                 1,
                 0,
@@ -3157,8 +3157,8 @@ Simulation {
                 0,
                 0,
                 1,
-                0,
-                1,
+                0 (modified),
+                1 (modified),
                 15,
                 1,
                 0,
@@ -3168,8 +3168,8 @@ Simulation {
                 0,
                 0,
                 1,
-                0,
-                1,
+                0 (modified),
+                1 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -5545,6 +5545,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5553,6 +5554,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5561,6 +5563,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5569,6 +5572,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5578,6 +5582,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5586,6 +5591,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(5),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5594,6 +5600,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(6),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5602,6 +5609,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5611,6 +5619,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5619,6 +5628,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(9),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5627,6 +5637,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(10),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5635,6 +5646,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(11),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5644,6 +5656,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(12),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5652,6 +5665,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5660,6 +5674,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(14),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5668,6 +5683,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(15),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5677,6 +5693,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5685,6 +5702,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5693,6 +5711,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(18),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5701,6 +5720,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5710,6 +5730,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5718,6 +5739,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(21),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5726,6 +5748,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(22),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5734,6 +5757,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(23),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5743,6 +5767,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(24),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5751,6 +5776,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(25),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5759,6 +5785,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(26),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5767,6 +5794,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5776,6 +5804,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(28),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5784,6 +5813,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(29),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5792,6 +5822,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5800,6 +5831,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5809,6 +5841,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(32),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5817,6 +5850,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5825,6 +5859,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5833,6 +5868,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(35),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5841,6 +5877,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5850,6 +5887,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(37),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5858,6 +5896,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(38),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5866,6 +5905,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5874,6 +5914,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(40),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5882,6 +5923,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(41),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5891,6 +5933,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5899,6 +5942,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(43),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5907,6 +5951,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(44),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5915,6 +5960,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(45),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5923,6 +5969,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(46),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5932,6 +5979,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(47),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5940,6 +5988,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(48),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5948,6 +5997,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(49),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5956,6 +6006,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(50),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5964,6 +6015,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(51),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5973,6 +6025,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(52),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5981,6 +6034,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(53),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5989,6 +6043,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(54),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5997,6 +6052,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(55),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6005,6 +6061,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(56),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6014,6 +6071,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(57),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6022,6 +6080,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(58),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6030,6 +6089,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(59),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6038,6 +6098,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(60),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6046,6 +6107,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(61),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6055,6 +6117,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(62),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6063,6 +6126,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(63),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6071,6 +6135,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(64),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6079,6 +6144,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(65),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6087,6 +6153,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(66),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6096,6 +6163,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(67),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6104,6 +6172,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(68),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6112,6 +6181,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(69),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6120,6 +6190,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(70),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6128,6 +6199,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(71),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6137,6 +6209,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(72),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6145,6 +6218,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(73),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6153,6 +6227,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(74),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6161,6 +6236,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(75),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6170,6 +6246,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(76),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6178,6 +6255,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(77),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6186,6 +6264,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(78),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6194,6 +6273,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(79),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6202,6 +6282,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(80),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6211,6 +6292,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(83),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6219,6 +6301,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(84),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6227,6 +6310,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(85),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6235,6 +6319,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(86),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6244,6 +6329,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(87),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6252,6 +6338,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(88),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6260,6 +6347,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(89),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6268,6 +6356,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(90),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6276,6 +6365,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(91),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6285,6 +6375,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(94),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6293,6 +6384,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(95),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6301,6 +6393,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(96),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6309,6 +6402,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(97),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6318,6 +6412,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(98),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6326,6 +6421,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(99),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6334,6 +6430,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(100),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6342,6 +6439,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(101),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6350,6 +6448,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(102),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6359,6 +6458,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(105),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6367,6 +6467,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(106),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6375,6 +6476,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(107),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6383,6 +6485,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(108),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6392,6 +6495,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(109),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6400,6 +6504,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(110),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6408,6 +6513,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(111),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6416,6 +6522,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(112),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6424,6 +6531,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(113),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6433,6 +6541,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(116),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6441,6 +6550,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(117),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6449,6 +6559,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(118),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6457,6 +6568,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(119),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6466,6 +6578,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(120),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6474,6 +6587,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(121),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6482,6 +6596,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(122),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6490,6 +6605,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(123),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6498,6 +6614,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(124),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6507,6 +6624,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(127),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6515,6 +6633,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(128),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6523,6 +6642,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(129),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6531,6 +6651,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(130),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6540,6 +6661,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(131),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6548,6 +6670,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(132),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6556,6 +6679,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(133),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6564,6 +6688,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(134),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6572,6 +6697,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(135),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6581,6 +6707,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(138),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6589,6 +6716,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(139),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6597,6 +6725,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(140),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6605,6 +6734,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(141),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6614,6 +6744,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(142),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6622,6 +6753,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(143),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6630,6 +6762,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(144),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6638,6 +6771,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(145),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6646,6 +6780,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(146),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6655,6 +6790,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(149),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6663,6 +6799,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(150),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6671,6 +6808,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(151),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6679,6 +6817,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(152),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6688,6 +6827,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(153),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6696,6 +6836,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(154),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6704,6 +6845,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(155),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6712,6 +6854,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(156),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6720,6 +6863,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(157),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
diff --git a/crates/fayalite/tests/sim/expected/memories.txt b/crates/fayalite/tests/sim/expected/memories.txt
index 0358bb3..db5a2f3 100644
--- a/crates/fayalite/tests/sim/expected/memories.txt
+++ b/crates/fayalite/tests/sim/expected/memories.txt
@@ -522,18 +522,18 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                1,
-                0,
-                0,
-                1,
-                2,
-                1,
-                0,
-                0,
-                0,
-                2,
-                2,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                2 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                2 (modified),
+                2 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
@@ -562,10 +562,10 @@ Simulation {
                 -32,
                 1,
                 1,
-                208,
-                -32,
-                1,
-                1,
+                208 (modified),
+                -32 (modified),
+                1 (modified),
+                1 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1168,6 +1168,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1176,6 +1177,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1184,6 +1186,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1193,6 +1196,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xb0,
             last_state: 0xb0,
         },
@@ -1202,6 +1206,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: SInt<8>,
             },
+            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1211,6 +1216,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1219,6 +1225,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1227,6 +1234,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1236,6 +1244,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xd0,
             last_state: 0xd0,
         },
@@ -1245,6 +1254,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: SInt<8>,
             },
+            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1253,6 +1263,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(10),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1261,6 +1272,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(11),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1270,6 +1282,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(12),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1278,6 +1291,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1286,6 +1300,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(14),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1295,6 +1310,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xb0,
             last_state: 0xb0,
         },
@@ -1304,6 +1320,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: SInt<8>,
             },
+            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1313,6 +1330,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1321,6 +1339,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(18),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1329,6 +1348,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1338,6 +1358,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0xd0,
             last_state: 0xd0,
         },
@@ -1347,6 +1368,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(21),
                 ty: SInt<8>,
             },
+            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1355,6 +1377,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(22),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1363,6 +1386,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(23),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
diff --git a/crates/fayalite/tests/sim/expected/memories2.txt b/crates/fayalite/tests/sim/expected/memories2.txt
index b4041ba..5a82b91 100644
--- a/crates/fayalite/tests/sim/expected/memories2.txt
+++ b/crates/fayalite/tests/sim/expected/memories2.txt
@@ -545,15 +545,15 @@ Simulation {
             value: [
                 0,
                 0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
@@ -568,32 +568,32 @@ Simulation {
                 0,
                 0,
                 0,
+                0 (modified),
                 0,
+                0 (modified),
                 0,
+                0 (modified),
+                0 (modified),
                 0,
+                0 (modified),
+                0 (modified),
                 0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -943,6 +943,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -951,6 +952,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -959,6 +961,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -968,6 +971,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -976,6 +980,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -985,6 +990,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<2>,
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -993,6 +999,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1002,6 +1009,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(7),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1010,6 +1018,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(8),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1018,6 +1027,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(9),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1030,6 +1040,7 @@ Simulation {
                     HdlSome(Bool),
                 },
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1038,6 +1049,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1046,6 +1058,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(11),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1058,6 +1071,7 @@ Simulation {
                     HdlSome(Bool),
                 },
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1066,6 +1080,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1074,6 +1089,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/memories3.txt b/crates/fayalite/tests/sim/expected/memories3.txt
index 2213912..7522430 100644
--- a/crates/fayalite/tests/sim/expected/memories3.txt
+++ b/crates/fayalite/tests/sim/expected/memories3.txt
@@ -1356,20 +1356,20 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                1,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
@@ -1415,6 +1415,22 @@ Simulation {
                 0,
                 0,
                 0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
                 0,
                 0,
                 0,
@@ -1434,54 +1450,38 @@ Simulation {
                 0,
                 0,
                 0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -2391,6 +2391,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2399,6 +2400,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2407,6 +2409,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2416,6 +2419,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2425,6 +2429,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2434,6 +2439,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2443,6 +2449,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2452,6 +2459,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(7),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2461,6 +2469,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2470,6 +2479,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2479,6 +2489,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2488,6 +2499,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2496,6 +2508,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2504,6 +2517,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2513,6 +2527,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2522,6 +2537,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2531,6 +2547,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2540,6 +2557,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2549,6 +2567,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2558,6 +2577,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(19),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2567,6 +2587,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2576,6 +2597,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(21),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2584,6 +2606,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(22),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2592,6 +2615,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(23),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2600,6 +2624,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(24),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2608,6 +2633,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(25),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2616,6 +2642,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(26),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2624,6 +2651,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2632,6 +2660,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(28),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2640,6 +2669,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(29),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2649,6 +2679,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(30),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2657,6 +2688,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2665,6 +2697,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2674,6 +2707,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(33),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2683,6 +2717,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(34),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2692,6 +2727,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(35),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2701,6 +2737,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(36),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2710,6 +2747,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(37),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2719,6 +2757,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(38),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2728,6 +2767,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(39),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2737,6 +2777,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(40),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2746,6 +2787,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(57),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2754,6 +2796,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(58),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2762,6 +2805,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(59),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2771,6 +2815,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(60),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2780,6 +2825,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(61),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2789,6 +2835,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(62),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2798,6 +2845,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(63),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2807,6 +2855,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(64),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2816,6 +2865,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(65),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2825,6 +2875,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2834,6 +2885,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(67),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2842,6 +2894,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(68),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2850,6 +2903,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(69),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2858,6 +2912,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(70),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2866,6 +2921,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(71),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2874,6 +2930,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(72),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2882,6 +2939,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(73),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2890,6 +2948,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(74),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2898,6 +2957,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(75),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/mod1.txt b/crates/fayalite/tests/sim/expected/mod1.txt
index 3f7a55e..7f89a66 100644
--- a/crates/fayalite/tests/sim/expected/mod1.txt
+++ b/crates/fayalite/tests/sim/expected/mod1.txt
@@ -207,11 +207,11 @@ Simulation {
                 -2,
                 -2,
                 15,
-                -2,
-                14,
-                5,
-                1,
-                15,
+                -2 (modified),
+                14 (modified),
+                5 (modified),
+                1 (modified),
+                15 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -445,6 +445,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xa,
             last_state: 0x3,
         },
@@ -454,6 +455,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(1),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x3,
         },
@@ -463,6 +465,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -472,6 +475,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xe,
         },
@@ -481,6 +485,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xa,
             last_state: 0x3,
         },
@@ -490,6 +495,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x3,
         },
@@ -499,6 +505,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -508,6 +515,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xe,
         },
@@ -517,6 +525,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xa,
             last_state: 0x3,
         },
@@ -526,6 +535,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x3,
         },
@@ -535,6 +545,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: SInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -544,6 +555,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(7),
                 ty: UInt<4>,
             },
+            maybe_changed: true,
             state: 0xf,
             last_state: 0xe,
         },
diff --git a/crates/fayalite/tests/sim/expected/phantom_const.txt b/crates/fayalite/tests/sim/expected/phantom_const.txt
index 94072ac..864a4f7 100644
--- a/crates/fayalite/tests/sim/expected/phantom_const.txt
+++ b/crates/fayalite/tests/sim/expected/phantom_const.txt
@@ -185,11 +185,11 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                1,
-                0,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
@@ -197,11 +197,11 @@ Simulation {
                 0,
                 0,
                 0,
-                0,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -373,6 +373,7 @@ Simulation {
                     ["a","b"],
                 ),
             },
+            maybe_changed: true,
             state: PhantomConst,
             last_state: PhantomConst,
         },
@@ -383,6 +384,7 @@ Simulation {
                     ["a","b"],
                 ),
             },
+            maybe_changed: true,
             state: PhantomConst,
             last_state: PhantomConst,
         },
@@ -392,6 +394,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -400,6 +403,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -408,6 +412,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -418,6 +423,7 @@ Simulation {
                     "mem_element",
                 ),
             },
+            maybe_changed: true,
             state: PhantomConst,
             last_state: PhantomConst,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_1_false_false.txt b/crates/fayalite/tests/sim/expected/queue_1_false_false.txt
index 570c08d..1ac0403 100644
--- a/crates/fayalite/tests/sim/expected/queue_1_false_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_1_false_false.txt
@@ -1098,35 +1098,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                51,
+                51 (modified),
                 0,
-                51,
+                51 (modified),
                 25,
-                51,
+                51 (modified),
                 0,
-                51,
+                51 (modified),
                 25,
                 1,
                 0,
@@ -1138,56 +1138,56 @@ Simulation {
                 0,
                 25,
                 1,
+                25 (modified),
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                1,
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1 (modified),
                 25,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                25,
-                0,
-                0,
-                1,
-                1,
-                25,
-                1,
-                50,
-                51,
-                51,
-                51,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                25 (modified),
+                1 (modified),
+                50 (modified),
+                51 (modified),
+                51 (modified),
+                51 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
                 0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1722,6 +1722,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1730,6 +1731,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1742,6 +1744,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1751,6 +1754,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1759,6 +1763,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1771,6 +1776,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1780,6 +1786,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1788,6 +1795,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1797,6 +1805,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1806,6 +1815,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1814,6 +1824,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1822,6 +1833,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1831,6 +1843,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1840,6 +1853,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1848,6 +1862,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1856,6 +1871,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1865,6 +1881,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1873,6 +1890,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1882,6 +1900,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1891,6 +1910,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1899,6 +1919,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1907,6 +1928,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1915,6 +1937,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1923,6 +1946,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1931,6 +1955,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1939,6 +1964,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1947,6 +1973,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1955,6 +1982,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1964,6 +1992,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1973,6 +2002,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_1_false_true.txt b/crates/fayalite/tests/sim/expected/queue_1_false_true.txt
index 5bff275..5b56068 100644
--- a/crates/fayalite/tests/sim/expected/queue_1_false_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_1_false_true.txt
@@ -1079,35 +1079,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                63,
+                63 (modified),
                 0,
-                63,
+                63 (modified),
                 31,
-                63,
+                63 (modified),
                 0,
-                63,
+                63 (modified),
                 31,
                 1,
                 0,
@@ -1119,54 +1119,54 @@ Simulation {
                 0,
                 31,
                 1,
+                31 (modified),
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                1,
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1 (modified),
                 31,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                31,
-                0,
-                0,
-                1,
-                1,
-                31,
-                1,
-                62,
-                63,
-                63,
-                63,
-                0,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                31 (modified),
+                1 (modified),
+                62 (modified),
+                63 (modified),
+                63 (modified),
+                63 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
                 0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1701,6 +1701,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1709,6 +1710,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1721,6 +1723,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1730,6 +1733,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1738,6 +1742,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1750,6 +1755,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1759,6 +1765,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1767,6 +1774,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1776,6 +1784,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1785,6 +1794,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1793,6 +1803,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1801,6 +1812,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1810,6 +1822,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1819,6 +1832,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1827,6 +1841,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1835,6 +1850,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1844,6 +1860,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1852,6 +1869,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1861,6 +1879,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1870,6 +1889,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1878,6 +1898,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1886,6 +1907,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1894,6 +1916,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1902,6 +1925,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1910,6 +1934,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1918,6 +1943,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1926,6 +1952,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1934,6 +1961,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1943,6 +1971,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1952,6 +1981,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(64),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_1_true_false.txt b/crates/fayalite/tests/sim/expected/queue_1_true_false.txt
index d9771dc..6076237 100644
--- a/crates/fayalite/tests/sim/expected/queue_1_true_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_1_true_false.txt
@@ -1108,35 +1108,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                63,
+                63 (modified),
                 0,
-                63,
+                63 (modified),
                 31,
-                63,
+                63 (modified),
                 0,
-                63,
+                63 (modified),
                 31,
                 1,
                 0,
@@ -1148,56 +1148,56 @@ Simulation {
                 0,
                 31,
                 1,
+                31 (modified),
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                1,
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1 (modified),
                 31,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                31,
-                0,
-                0,
-                1,
-                1,
-                31,
-                1,
-                62,
-                63,
-                63,
-                63,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                31 (modified),
+                1 (modified),
+                62 (modified),
+                63 (modified),
+                63 (modified),
+                63 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
                 0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1732,6 +1732,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1740,6 +1741,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1752,6 +1754,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1761,6 +1764,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1769,6 +1773,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1781,6 +1786,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1790,6 +1796,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1798,6 +1805,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1807,6 +1815,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1816,6 +1825,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1824,6 +1834,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1832,6 +1843,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1841,6 +1853,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1850,6 +1863,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1858,6 +1872,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1866,6 +1881,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1875,6 +1891,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1883,6 +1900,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1892,6 +1910,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1901,6 +1920,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1909,6 +1929,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1917,6 +1938,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1925,6 +1947,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1933,6 +1956,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1941,6 +1965,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1949,6 +1974,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1957,6 +1983,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1965,6 +1992,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1974,6 +2002,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1983,6 +2012,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_1_true_true.txt b/crates/fayalite/tests/sim/expected/queue_1_true_true.txt
index 0e16d2d..8fe32ad 100644
--- a/crates/fayalite/tests/sim/expected/queue_1_true_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_1_true_true.txt
@@ -1089,35 +1089,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                71,
+                71 (modified),
                 0,
-                71,
+                71 (modified),
                 35,
-                71,
+                71 (modified),
                 0,
-                71,
+                71 (modified),
                 35,
                 1,
                 0,
@@ -1129,54 +1129,54 @@ Simulation {
                 0,
                 35,
                 1,
+                35 (modified),
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                1,
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1 (modified),
                 35,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                35,
-                0,
-                0,
-                1,
-                1,
-                35,
-                1,
-                70,
-                71,
-                71,
-                71,
-                0,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                35 (modified),
+                1 (modified),
+                70 (modified),
+                71 (modified),
+                71 (modified),
+                71 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
                 0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1711,6 +1711,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1719,6 +1720,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1731,6 +1733,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1740,6 +1743,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1748,6 +1752,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1760,6 +1765,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1769,6 +1775,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1777,6 +1784,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1786,6 +1794,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1795,6 +1804,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1803,6 +1813,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1811,6 +1822,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1820,6 +1832,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1829,6 +1842,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1837,6 +1851,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1845,6 +1860,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1854,6 +1870,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1862,6 +1879,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1871,6 +1889,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1880,6 +1899,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1888,6 +1908,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1896,6 +1917,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1904,6 +1926,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1912,6 +1935,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1920,6 +1944,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1928,6 +1953,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1936,6 +1962,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1944,6 +1971,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1953,6 +1981,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1962,6 +1991,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(64),
                 ty: UInt<0>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_2_false_false.txt b/crates/fayalite/tests/sim/expected/queue_2_false_false.txt
index 23b0a7b..5a5c47d 100644
--- a/crates/fayalite/tests/sim/expected/queue_2_false_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_2_false_false.txt
@@ -1114,35 +1114,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                71,
+                71 (modified),
                 1,
-                71,
+                71 (modified),
                 35,
-                71,
+                71 (modified),
                 0,
-                71,
+                71 (modified),
                 35,
                 1,
                 1,
@@ -1154,58 +1154,58 @@ Simulation {
                 0,
                 35,
                 1,
+                35 (modified),
+                1 (modified),
+                0,
+                1 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                1,
+                1,
+                0,
+                0,
+                0,
+                0 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1 (modified),
                 35,
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                35 (modified),
+                1 (modified),
+                70 (modified),
+                71 (modified),
+                71 (modified),
+                71 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                2 (modified),
+                0 (modified),
+                2 (modified),
+                2 (modified),
+                0 (modified),
                 1,
-                0,
-                1,
-                0,
-                1,
-                1,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                35,
-                0,
-                1,
-                1,
-                1,
-                35,
-                1,
-                70,
-                71,
-                71,
-                71,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                2,
-                0,
-                2,
-                2,
-                0,
-                1,
-                3,
-                1,
-                1,
+                3 (modified),
+                1 (modified),
+                1 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1740,6 +1740,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1748,6 +1749,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1760,6 +1762,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1769,6 +1772,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1777,6 +1781,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1789,6 +1794,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1798,6 +1804,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1806,6 +1813,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1815,6 +1823,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1824,6 +1833,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1832,6 +1842,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1840,6 +1851,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1849,6 +1861,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1858,6 +1871,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1866,6 +1880,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1874,6 +1889,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1883,6 +1899,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1891,6 +1908,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1900,6 +1918,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1909,6 +1928,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1917,6 +1937,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1925,6 +1946,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1933,6 +1955,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1941,6 +1964,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1949,6 +1973,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1957,6 +1982,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1965,6 +1991,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1973,6 +2000,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1982,6 +2010,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1991,6 +2020,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(68),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_2_false_true.txt b/crates/fayalite/tests/sim/expected/queue_2_false_true.txt
index a057fa7..2d9ea3f 100644
--- a/crates/fayalite/tests/sim/expected/queue_2_false_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_2_false_true.txt
@@ -1095,35 +1095,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                0,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                77,
+                77 (modified),
                 1,
-                77,
+                77 (modified),
                 38,
-                77,
+                77 (modified),
                 0,
-                77,
+                77 (modified),
                 38,
                 1,
                 0,
@@ -1135,56 +1135,56 @@ Simulation {
                 0,
                 38,
                 1,
+                38 (modified),
+                1 (modified),
+                1,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                1,
+                1,
+                0,
+                0,
+                0,
+                0 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1 (modified),
                 38,
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                38 (modified),
+                1 (modified),
+                76 (modified),
+                77 (modified),
+                77 (modified),
+                77 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                2 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                2 (modified),
+                2 (modified),
+                0 (modified),
                 1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                38,
-                0,
-                1,
-                1,
-                1,
-                38,
-                1,
-                76,
-                77,
-                77,
-                77,
-                1,
-                1,
-                1,
-                0,
-                0,
-                2,
-                0,
-                0,
-                1,
-                1,
-                2,
-                2,
-                0,
-                1,
-                1,
-                1,
-                1,
+                1 (modified),
+                1 (modified),
+                1 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1719,6 +1719,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1727,6 +1728,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1739,6 +1741,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1748,6 +1751,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1756,6 +1760,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1768,6 +1773,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1777,6 +1783,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1785,6 +1792,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1794,6 +1802,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1803,6 +1812,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1811,6 +1821,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1819,6 +1830,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1828,6 +1840,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1837,6 +1850,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1845,6 +1859,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1853,6 +1868,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1862,6 +1878,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1870,6 +1887,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1879,6 +1897,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1888,6 +1907,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1896,6 +1916,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1904,6 +1925,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1912,6 +1934,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1920,6 +1943,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1928,6 +1952,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1936,6 +1961,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1944,6 +1970,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1952,6 +1979,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1961,6 +1989,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1970,6 +1999,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_2_true_false.txt b/crates/fayalite/tests/sim/expected/queue_2_true_false.txt
index 1f6d8ec..3d16da2 100644
--- a/crates/fayalite/tests/sim/expected/queue_2_true_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_2_true_false.txt
@@ -1124,35 +1124,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                79,
+                79 (modified),
                 0,
-                79,
+                79 (modified),
                 39,
-                77,
+                77 (modified),
                 0,
-                77,
+                77 (modified),
                 38,
                 2,
                 0,
@@ -1164,58 +1164,58 @@ Simulation {
                 0,
                 39,
                 1,
+                39 (modified),
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                1,
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1 (modified),
                 39,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                39,
-                0,
-                0,
-                1,
-                1,
-                38,
-                1,
-                76,
-                77,
-                77,
-                77,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                2,
-                2,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                38 (modified),
+                1 (modified),
+                76 (modified),
+                77 (modified),
+                77 (modified),
+                77 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                2 (modified),
+                2 (modified),
+                0 (modified),
                 0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1750,6 +1750,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1758,6 +1759,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1770,6 +1772,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1779,6 +1782,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1787,6 +1791,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1799,6 +1804,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1808,6 +1814,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1816,6 +1823,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1825,6 +1833,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1834,6 +1843,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1842,6 +1852,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1850,6 +1861,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1859,6 +1871,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1868,6 +1881,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1876,6 +1890,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1884,6 +1899,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1893,6 +1909,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1901,6 +1918,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1910,6 +1928,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1919,6 +1938,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1927,6 +1947,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1935,6 +1956,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1943,6 +1965,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1951,6 +1974,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1959,6 +1983,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1967,6 +1992,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1975,6 +2001,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1983,6 +2010,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1992,6 +2020,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -2001,6 +2030,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(68),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_2_true_true.txt b/crates/fayalite/tests/sim/expected/queue_2_true_true.txt
index 25b08a1..041e62d 100644
--- a/crates/fayalite/tests/sim/expected/queue_2_true_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_2_true_true.txt
@@ -1105,35 +1105,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                85,
+                85 (modified),
                 0,
-                85,
+                85 (modified),
                 42,
-                83,
+                83 (modified),
                 0,
-                83,
+                83 (modified),
                 41,
                 2,
                 1,
@@ -1145,56 +1145,56 @@ Simulation {
                 0,
                 42,
                 1,
+                42 (modified),
+                1 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                1,
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1 (modified),
                 42,
-                1,
-                1,
-                1,
-                0,
-                1,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                42,
-                0,
-                0,
-                1,
-                1,
-                41,
-                1,
-                82,
-                83,
-                83,
-                83,
-                0,
-                1,
-                1,
-                0,
-                0,
-                2,
-                0,
-                1,
-                2,
-                0,
-                2,
-                2,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                41 (modified),
+                1 (modified),
+                82 (modified),
+                83 (modified),
+                83 (modified),
+                83 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                2 (modified),
+                0 (modified),
+                1 (modified),
+                2 (modified),
+                0 (modified),
+                2 (modified),
+                2 (modified),
+                0 (modified),
                 0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1729,6 +1729,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1737,6 +1738,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1749,6 +1751,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1758,6 +1761,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1766,6 +1770,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1778,6 +1783,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1787,6 +1793,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1795,6 +1802,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1804,6 +1812,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1813,6 +1822,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1821,6 +1831,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1829,6 +1840,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1838,6 +1850,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1847,6 +1860,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1855,6 +1869,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1863,6 +1878,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1872,6 +1888,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1880,6 +1897,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1889,6 +1907,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1898,6 +1917,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1906,6 +1926,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1914,6 +1935,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1922,6 +1944,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1930,6 +1953,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1938,6 +1962,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1946,6 +1971,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1954,6 +1980,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1962,6 +1989,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1971,6 +1999,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1980,6 +2009,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<1>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_3_false_false.txt b/crates/fayalite/tests/sim/expected/queue_3_false_false.txt
index 6f65006..f9c68cc 100644
--- a/crates/fayalite/tests/sim/expected/queue_3_false_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_3_false_false.txt
@@ -1142,35 +1142,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                0,
-                0,
-                1,
-                2,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                2 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                81,
+                81 (modified),
                 1,
-                81,
+                81 (modified),
                 40,
-                79,
+                79 (modified),
                 0,
-                79,
+                79 (modified),
                 39,
                 2,
                 0,
@@ -1182,59 +1182,59 @@ Simulation {
                 0,
                 40,
                 1,
+                40 (modified),
+                1 (modified),
+                2,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                1,
+                1,
+                0,
+                0,
+                0,
+                0 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1 (modified),
                 40,
-                1,
-                2,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                40,
-                0,
-                1,
-                1,
-                1,
-                39,
-                1,
-                78,
-                79,
-                79,
-                79,
-                0,
-                0,
-                1,
-                2,
-                1,
-                0,
-                0,
-                3,
-                3,
-                0,
-                1,
-                1,
-                3,
-                3,
-                0,
-                5,
-                5,
-                1,
-                2,
-                2,
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                39 (modified),
+                1 (modified),
+                78 (modified),
+                79 (modified),
+                79 (modified),
+                79 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                2 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                3 (modified),
+                3 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                3 (modified),
+                3 (modified),
+                0 (modified),
+                5 (modified),
+                5 (modified),
+                1 (modified),
+                2 (modified),
+                2 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1759,6 +1759,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1767,6 +1768,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1779,6 +1781,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1788,6 +1791,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x28,
             last_state: 0x28,
         },
@@ -1796,6 +1800,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1808,6 +1813,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1817,6 +1823,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1825,6 +1832,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1834,6 +1842,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1843,6 +1852,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1851,6 +1861,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1859,6 +1870,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1868,6 +1880,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1877,6 +1890,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1885,6 +1899,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1893,6 +1908,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1902,6 +1918,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x28,
             last_state: 0x28,
         },
@@ -1910,6 +1927,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1919,6 +1937,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1928,6 +1947,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1936,6 +1956,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1944,6 +1965,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1952,6 +1974,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1960,6 +1983,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1968,6 +1992,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1976,6 +2001,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1984,6 +2010,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1992,6 +2019,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2001,6 +2029,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x28,
             last_state: 0x28,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_3_false_true.txt b/crates/fayalite/tests/sim/expected/queue_3_false_true.txt
index 4cffcd6..9b0a7ea 100644
--- a/crates/fayalite/tests/sim/expected/queue_3_false_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_3_false_true.txt
@@ -1123,35 +1123,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                2,
-                1,
-                0,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                2 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                85,
+                85 (modified),
                 1,
-                85,
+                85 (modified),
                 42,
-                83,
+                83 (modified),
                 0,
-                83,
+                83 (modified),
                 41,
                 2,
                 2,
@@ -1163,57 +1163,57 @@ Simulation {
                 0,
                 42,
                 1,
+                42 (modified),
+                1 (modified),
+                1,
+                2 (modified),
+                0 (modified),
+                2,
+                2 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                1,
+                1,
+                0,
+                0,
+                0,
+                0 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1 (modified),
                 42,
-                1,
-                1,
-                2,
-                0,
-                2,
-                2,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                42,
-                0,
-                1,
-                1,
-                1,
-                41,
-                1,
-                82,
-                83,
-                83,
-                83,
-                1,
-                2,
-                0,
-                0,
-                0,
-                2,
-                2,
-                1,
-                3,
-                3,
-                3,
-                3,
-                1,
-                4,
-                2,
-                2,
-                7,
-                3,
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                41 (modified),
+                1 (modified),
+                82 (modified),
+                83 (modified),
+                83 (modified),
+                83 (modified),
+                1 (modified),
+                2 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                2 (modified),
+                2 (modified),
+                1 (modified),
+                3 (modified),
+                3 (modified),
+                3 (modified),
+                3 (modified),
+                1 (modified),
+                4 (modified),
+                2 (modified),
+                2 (modified),
+                7 (modified),
+                3 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1738,6 +1738,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1746,6 +1747,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1758,6 +1760,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1767,6 +1770,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1775,6 +1779,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1787,6 +1792,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1796,6 +1802,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1804,6 +1811,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1813,6 +1821,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1822,6 +1831,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1830,6 +1840,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1838,6 +1849,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1847,6 +1859,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1856,6 +1869,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1864,6 +1878,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1872,6 +1887,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1881,6 +1897,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1889,6 +1906,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1898,6 +1916,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1907,6 +1926,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1915,6 +1935,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1923,6 +1944,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1931,6 +1953,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1939,6 +1962,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1947,6 +1971,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1955,6 +1980,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1963,6 +1989,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1971,6 +1998,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1980,6 +2008,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_3_true_false.txt b/crates/fayalite/tests/sim/expected/queue_3_true_false.txt
index 03d3aba..1b486d6 100644
--- a/crates/fayalite/tests/sim/expected/queue_3_true_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_3_true_false.txt
@@ -1152,35 +1152,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                2,
-                1,
-                0,
-                0,
-                0,
-                2,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                2 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                2 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                87,
+                87 (modified),
                 0,
-                87,
+                87 (modified),
                 43,
-                83,
+                83 (modified),
                 0,
-                83,
+                83 (modified),
                 41,
                 3,
                 2,
@@ -1192,59 +1192,59 @@ Simulation {
                 0,
                 43,
                 1,
+                43 (modified),
+                1 (modified),
+                2,
+                2 (modified),
+                0 (modified),
+                2,
+                2 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                1,
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1 (modified),
                 43,
-                1,
-                2,
-                2,
-                0,
-                2,
-                2,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                43,
-                0,
-                0,
-                1,
-                1,
-                41,
-                1,
-                82,
-                83,
-                83,
-                83,
-                0,
-                0,
-                0,
-                2,
-                1,
-                0,
-                0,
-                3,
-                3,
-                1,
-                3,
-                3,
-                3,
-                3,
-                0,
-                5,
-                3,
-                3,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                41 (modified),
+                1 (modified),
+                82 (modified),
+                83 (modified),
+                83 (modified),
+                83 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                2 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                3 (modified),
+                3 (modified),
+                1 (modified),
+                3 (modified),
+                3 (modified),
+                3 (modified),
+                3 (modified),
+                0 (modified),
+                5 (modified),
+                3 (modified),
+                3 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1769,6 +1769,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1777,6 +1778,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1789,6 +1791,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1798,6 +1801,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1806,6 +1810,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1818,6 +1823,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1827,6 +1833,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1835,6 +1842,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1844,6 +1852,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1853,6 +1862,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1861,6 +1871,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1869,6 +1880,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1878,6 +1890,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1887,6 +1900,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1895,6 +1909,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1903,6 +1918,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1912,6 +1928,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1920,6 +1937,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1929,6 +1947,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1938,6 +1957,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1946,6 +1966,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1954,6 +1975,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1962,6 +1984,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1970,6 +1993,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1978,6 +2002,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1986,6 +2011,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1994,6 +2020,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2002,6 +2029,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2011,6 +2039,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_3_true_true.txt b/crates/fayalite/tests/sim/expected/queue_3_true_true.txt
index a663e23..730e7e5 100644
--- a/crates/fayalite/tests/sim/expected/queue_3_true_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_3_true_true.txt
@@ -1133,35 +1133,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                2,
-                1,
-                0,
-                0,
-                0,
-                2,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                2 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                2 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                87,
+                87 (modified),
                 0,
-                87,
+                87 (modified),
                 43,
-                83,
+                83 (modified),
                 0,
-                83,
+                83 (modified),
                 41,
                 3,
                 2,
@@ -1173,57 +1173,57 @@ Simulation {
                 0,
                 43,
                 1,
+                43 (modified),
+                1 (modified),
+                2,
+                2 (modified),
+                0 (modified),
+                2,
+                2 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                1,
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1 (modified),
                 43,
-                1,
-                2,
-                2,
-                0,
-                2,
-                2,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                43,
-                0,
-                0,
-                1,
-                1,
-                41,
-                1,
-                82,
-                83,
-                83,
-                83,
-                0,
-                2,
-                1,
-                0,
-                0,
-                3,
-                3,
-                1,
-                3,
-                3,
-                3,
-                3,
-                0,
-                5,
-                3,
-                3,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                41 (modified),
+                1 (modified),
+                82 (modified),
+                83 (modified),
+                83 (modified),
+                83 (modified),
+                0 (modified),
+                2 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                3 (modified),
+                3 (modified),
+                1 (modified),
+                3 (modified),
+                3 (modified),
+                3 (modified),
+                3 (modified),
+                0 (modified),
+                5 (modified),
+                3 (modified),
+                3 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1748,6 +1748,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1756,6 +1757,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1768,6 +1770,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1777,6 +1780,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1785,6 +1789,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1797,6 +1802,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1806,6 +1812,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1814,6 +1821,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1823,6 +1831,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1832,6 +1841,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1840,6 +1850,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1848,6 +1859,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1857,6 +1869,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1866,6 +1879,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1874,6 +1888,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1882,6 +1897,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1891,6 +1907,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1899,6 +1916,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1908,6 +1926,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1917,6 +1936,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1925,6 +1945,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1933,6 +1954,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1941,6 +1963,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1949,6 +1972,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1957,6 +1981,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1965,6 +1990,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1973,6 +1999,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1981,6 +2008,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1990,6 +2018,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_4_false_false.txt b/crates/fayalite/tests/sim/expected/queue_4_false_false.txt
index 445d9d0..e549ced 100644
--- a/crates/fayalite/tests/sim/expected/queue_4_false_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_4_false_false.txt
@@ -1122,35 +1122,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                3,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                3 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                87,
+                87 (modified),
                 1,
-                87,
+                87 (modified),
                 43,
-                83,
+                83 (modified),
                 0,
-                83,
+                83 (modified),
                 41,
                 3,
                 1,
@@ -1162,58 +1162,58 @@ Simulation {
                 0,
                 43,
                 1,
+                43 (modified),
+                1 (modified),
+                0,
+                1 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                1,
+                1,
+                0,
+                0,
+                0,
+                0 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1 (modified),
                 43,
-                1,
-                0,
-                1,
-                0,
-                1,
-                1,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                43,
-                0,
-                1,
-                1,
-                1,
-                41,
-                1,
-                82,
-                83,
-                83,
-                83,
-                0,
-                0,
-                1,
-                3,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                2,
-                2,
-                4,
-                4,
-                0,
-                3,
-                7,
-                3,
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                41 (modified),
+                1 (modified),
+                82 (modified),
+                83 (modified),
+                83 (modified),
+                83 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                3 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                2 (modified),
+                2 (modified),
+                4 (modified),
+                4 (modified),
+                0 (modified),
                 3,
+                7 (modified),
+                3 (modified),
+                3 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1748,6 +1748,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1756,6 +1757,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1768,6 +1770,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1777,6 +1780,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1785,6 +1789,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1797,6 +1802,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1806,6 +1812,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1814,6 +1821,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1823,6 +1831,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1832,6 +1841,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1840,6 +1850,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1848,6 +1859,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1857,6 +1869,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1866,6 +1879,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1874,6 +1888,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1882,6 +1897,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1891,6 +1907,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1899,6 +1916,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1908,6 +1926,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1917,6 +1936,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1925,6 +1945,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1933,6 +1954,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1941,6 +1963,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1949,6 +1972,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1957,6 +1981,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1965,6 +1990,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1973,6 +1999,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1981,6 +2008,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1990,6 +2018,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1999,6 +2028,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(68),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_4_false_true.txt b/crates/fayalite/tests/sim/expected/queue_4_false_true.txt
index 5e7ada2..9f1d05b 100644
--- a/crates/fayalite/tests/sim/expected/queue_4_false_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_4_false_true.txt
@@ -1103,35 +1103,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                3,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                3 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                87,
+                87 (modified),
                 1,
-                87,
+                87 (modified),
                 43,
-                83,
+                83 (modified),
                 0,
-                83,
+                83 (modified),
                 41,
                 3,
                 1,
@@ -1143,56 +1143,56 @@ Simulation {
                 0,
                 43,
                 1,
+                43 (modified),
+                1 (modified),
+                0,
+                1 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                1,
+                1,
+                0,
+                0,
+                0,
+                0 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                0,
+                0 (modified),
+                1 (modified),
                 43,
-                1,
-                0,
-                1,
-                0,
-                1,
-                1,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                43,
-                0,
-                1,
-                1,
-                1,
-                41,
-                1,
-                82,
-                83,
-                83,
-                83,
-                1,
-                3,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                2,
-                2,
-                4,
-                4,
-                0,
-                3,
-                7,
-                3,
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                41 (modified),
+                1 (modified),
+                82 (modified),
+                83 (modified),
+                83 (modified),
+                83 (modified),
+                1 (modified),
+                3 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                2 (modified),
+                2 (modified),
+                4 (modified),
+                4 (modified),
+                0 (modified),
                 3,
+                7 (modified),
+                3 (modified),
+                3 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1727,6 +1727,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1735,6 +1736,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1747,6 +1749,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1756,6 +1759,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1764,6 +1768,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1776,6 +1781,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1785,6 +1791,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1793,6 +1800,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1802,6 +1810,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1811,6 +1820,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1819,6 +1829,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1827,6 +1838,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1836,6 +1848,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1845,6 +1858,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1853,6 +1867,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1861,6 +1876,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1870,6 +1886,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1878,6 +1895,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1887,6 +1905,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1896,6 +1915,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1904,6 +1924,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1912,6 +1933,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1920,6 +1942,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1928,6 +1951,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1936,6 +1960,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1944,6 +1969,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1952,6 +1978,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1960,6 +1987,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1969,6 +1997,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1978,6 +2007,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_4_true_false.txt b/crates/fayalite/tests/sim/expected/queue_4_true_false.txt
index 2701c1d..b37a9cd 100644
--- a/crates/fayalite/tests/sim/expected/queue_4_true_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_4_true_false.txt
@@ -1132,35 +1132,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                89,
+                89 (modified),
                 0,
-                89,
+                89 (modified),
                 44,
-                83,
+                83 (modified),
                 0,
-                83,
+                83 (modified),
                 41,
                 4,
                 1,
@@ -1172,58 +1172,58 @@ Simulation {
                 0,
                 44,
                 1,
+                44 (modified),
+                1 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                1,
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1 (modified),
                 44,
-                1,
-                1,
-                1,
-                0,
-                1,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                44,
-                0,
-                0,
-                1,
-                1,
-                41,
-                1,
-                82,
-                83,
-                83,
-                83,
-                0,
-                0,
-                0,
-                3,
-                0,
-                0,
-                0,
-                2,
-                2,
-                0,
-                2,
-                2,
-                4,
-                4,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                41 (modified),
+                1 (modified),
+                82 (modified),
+                83 (modified),
+                83 (modified),
+                83 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                3 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                2 (modified),
+                2 (modified),
+                0 (modified),
+                2 (modified),
+                2 (modified),
+                4 (modified),
+                4 (modified),
+                0 (modified),
                 0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1758,6 +1758,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1766,6 +1767,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1778,6 +1780,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1787,6 +1790,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1795,6 +1799,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1807,6 +1812,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1816,6 +1822,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1824,6 +1831,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1833,6 +1841,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x4,
             last_state: 0x4,
         },
@@ -1842,6 +1851,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1850,6 +1860,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1858,6 +1869,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1867,6 +1879,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1876,6 +1889,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1884,6 +1898,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1892,6 +1907,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1901,6 +1917,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1909,6 +1926,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1918,6 +1936,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1927,6 +1946,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1935,6 +1955,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1943,6 +1964,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1951,6 +1973,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1959,6 +1982,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1967,6 +1991,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1975,6 +2000,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1983,6 +2009,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1991,6 +2018,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2000,6 +2028,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -2009,6 +2038,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(68),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/queue_4_true_true.txt b/crates/fayalite/tests/sim/expected/queue_4_true_true.txt
index a52069d..051b203 100644
--- a/crates/fayalite/tests/sim/expected/queue_4_true_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_4_true_true.txt
@@ -1113,35 +1113,35 @@ Simulation {
             value: [
                 1,
                 1,
-                1,
-                0,
-                0,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
                 0,
                 0,
-                89,
+                89 (modified),
                 0,
-                89,
+                89 (modified),
                 44,
-                83,
+                83 (modified),
                 0,
-                83,
+                83 (modified),
                 41,
                 4,
                 1,
@@ -1153,56 +1153,56 @@ Simulation {
                 0,
                 44,
                 1,
+                44 (modified),
+                1 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1,
+                1 (modified),
+                0 (modified),
+                0,
+                0,
+                0,
+                0,
+                1,
+                1 (modified),
+                0,
+                0 (modified),
+                0 (modified),
+                1,
+                1 (modified),
+                1 (modified),
                 44,
-                1,
-                1,
-                1,
-                0,
-                1,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                44,
-                0,
-                0,
-                1,
-                1,
-                41,
-                1,
-                82,
-                83,
-                83,
-                83,
-                0,
-                3,
-                0,
-                0,
-                0,
-                2,
-                2,
-                0,
-                2,
-                2,
-                4,
-                4,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                41 (modified),
+                1 (modified),
+                82 (modified),
+                83 (modified),
+                83 (modified),
+                83 (modified),
+                0 (modified),
+                3 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                2 (modified),
+                2 (modified),
+                0 (modified),
+                2 (modified),
+                2 (modified),
+                4 (modified),
+                4 (modified),
+                0 (modified),
                 0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1737,6 +1737,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1745,6 +1746,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1757,6 +1759,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1766,6 +1769,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1774,6 +1778,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1786,6 +1791,7 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1795,6 +1801,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1803,6 +1810,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1812,6 +1820,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
+            maybe_changed: true,
             state: 0x4,
             last_state: 0x4,
         },
@@ -1821,6 +1830,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1829,6 +1839,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1837,6 +1848,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1846,6 +1858,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1855,6 +1868,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1863,6 +1877,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1871,6 +1886,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1880,6 +1896,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1888,6 +1905,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1897,6 +1915,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1906,6 +1925,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1914,6 +1934,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1922,6 +1943,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1930,6 +1952,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1938,6 +1961,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1946,6 +1970,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1954,6 +1979,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1962,6 +1988,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1970,6 +1997,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1979,6 +2007,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
+            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1988,6 +2017,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<2>,
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/ripple_counter.txt b/crates/fayalite/tests/sim/expected/ripple_counter.txt
index 1fb5fee..91bbffd 100644
--- a/crates/fayalite/tests/sim/expected/ripple_counter.txt
+++ b/crates/fayalite/tests/sim/expected/ripple_counter.txt
@@ -641,15 +641,15 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
@@ -662,56 +662,56 @@ Simulation {
                 0,
                 0,
                 0,
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                0,
+                1 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
                 0,
                 0,
+                0 (modified),
+                0,
+                0 (modified),
+                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
                 0,
                 0,
+                0 (modified),
+                0,
+                0 (modified),
+                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
                 0,
                 0,
+                0 (modified),
                 0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -1284,6 +1284,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1293,6 +1294,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(1),
                 ty: UInt<6>,
             },
+            maybe_changed: false,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1301,6 +1303,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1309,6 +1312,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1317,6 +1321,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1325,6 +1330,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(5),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1333,6 +1339,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1341,6 +1348,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1349,6 +1357,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(24),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1357,6 +1366,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(33),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1365,6 +1375,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1373,6 +1384,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(31),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1381,6 +1393,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1389,6 +1402,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1397,6 +1411,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(44),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1405,6 +1420,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(45),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1413,6 +1429,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(42),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1421,6 +1438,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(43),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1429,6 +1447,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(47),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1437,6 +1456,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(55),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1445,6 +1465,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(56),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1453,6 +1474,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(53),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1461,6 +1483,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(54),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/shift_register.txt b/crates/fayalite/tests/sim/expected/shift_register.txt
index 2e1b176..cc9d95a 100644
--- a/crates/fayalite/tests/sim/expected/shift_register.txt
+++ b/crates/fayalite/tests/sim/expected/shift_register.txt
@@ -259,10 +259,10 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                0,
-                0,
-                1,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
@@ -272,14 +272,14 @@ Simulation {
                 0,
                 0,
                 0,
+                0 (modified),
+                0 (modified),
                 0,
+                0 (modified),
                 0,
+                0 (modified),
                 0,
-                0,
-                0,
-                0,
-                0,
-                0,
+                0 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -458,6 +458,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -466,6 +467,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -474,6 +476,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -482,6 +485,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -490,6 +494,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -498,6 +503,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -506,6 +512,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(9),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -514,6 +521,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(11),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
diff --git a/crates/fayalite/tests/sim/expected/sim_fork_join.txt b/crates/fayalite/tests/sim/expected/sim_fork_join.txt
index df9c092..c66e77e 100644
--- a/crates/fayalite/tests/sim/expected/sim_fork_join.txt
+++ b/crates/fayalite/tests/sim/expected/sim_fork_join.txt
@@ -68,12 +68,12 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
+                0 (modified),
                 0,
                 0,
-                0,
-                49,
-                50,
-                50,
+                49 (modified),
+                50 (modified),
+                50 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -356,6 +356,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -364,6 +365,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -372,6 +374,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -381,6 +384,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -390,6 +394,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -399,6 +404,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
diff --git a/crates/fayalite/tests/sim/expected/sim_fork_join_scope.txt b/crates/fayalite/tests/sim/expected/sim_fork_join_scope.txt
index 917dd5d..ae88960 100644
--- a/crates/fayalite/tests/sim/expected/sim_fork_join_scope.txt
+++ b/crates/fayalite/tests/sim/expected/sim_fork_join_scope.txt
@@ -68,12 +68,12 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
+                0 (modified),
                 0,
                 0,
-                0,
-                49,
-                50,
-                50,
+                49 (modified),
+                50 (modified),
+                50 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -356,6 +356,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -364,6 +365,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -372,6 +374,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -381,6 +384,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -390,6 +394,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -399,6 +404,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
diff --git a/crates/fayalite/tests/sim/expected/sim_only_connects.txt b/crates/fayalite/tests/sim/expected/sim_only_connects.txt
index 827f3cc..3b90ca8 100644
--- a/crates/fayalite/tests/sim/expected/sim_only_connects.txt
+++ b/crates/fayalite/tests/sim/expected/sim_only_connects.txt
@@ -380,10 +380,10 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                0,
-                0,
-                1,
-                0,
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
@@ -392,15 +392,15 @@ Simulation {
                 0,
                 1,
                 0,
+                1 (modified),
+                0,
+                0,
+                0 (modified),
+                1 (modified),
+                0 (modified),
                 1,
                 0,
-                0,
-                0,
-                1,
-                0,
-                1,
-                0,
-                1,
+                1 (modified),
                 0,
             ],
         },
@@ -443,8 +443,8 @@ Simulation {
                 },
                 {
                     "extra": "value",
-                },
-                {},
+                } (modified),
+                {} (modified),
                 {
                     "bar": "",
                     "extra": "value",
@@ -1252,6 +1252,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1260,6 +1261,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1269,6 +1271,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(0),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "extra": "value",
             },
@@ -1282,6 +1285,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(1),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "extra": "value",
             },
@@ -1295,6 +1299,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(2),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "",
                 "extra": "value",
@@ -1312,6 +1317,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(3),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "baz",
                 "extra": "value",
@@ -1328,6 +1334,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(4),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1336,6 +1343,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(5),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1345,6 +1353,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(6),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "extra": "value",
             },
@@ -1358,6 +1367,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(7),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "",
                 "extra": "value",
@@ -1374,6 +1384,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1382,6 +1393,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(3),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1391,6 +1403,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(4),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "extra": "value",
             },
@@ -1404,6 +1417,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(5),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "",
                 "extra": "value",
@@ -1421,6 +1435,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(8),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "extra": "value",
             },
@@ -1433,6 +1448,7 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1441,6 +1457,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(12),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1449,6 +1466,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(13),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1458,6 +1476,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(13),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "",
                 "extra": "value",
@@ -1475,6 +1494,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(14),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "baz",
                 "extra": "value",
@@ -1491,6 +1511,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(10),
             },
+            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1499,6 +1520,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(11),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1508,6 +1530,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(11),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "",
                 "extra": "value",
@@ -1525,6 +1548,7 @@ Simulation {
                 index: StatePartIndex<SimOnlySlots>(12),
                 ty: SimOnly<alloc::collections::btree::map::BTreeMap<alloc::string::String, alloc::rc::Rc<str>>>,
             },
+            maybe_changed: true,
             state: {
                 "bar": "baz",
                 "extra": "value",
diff --git a/crates/fayalite/tests/sim/expected/sim_read_past.txt b/crates/fayalite/tests/sim/expected/sim_read_past.txt
index 6df4571..17156d0 100644
--- a/crates/fayalite/tests/sim/expected/sim_read_past.txt
+++ b/crates/fayalite/tests/sim/expected/sim_read_past.txt
@@ -517,67 +517,67 @@ Simulation {
         },
         small_slots: StatePart {
             value: [
-                1,
-                0,
-                0,
-                1,
-                0,
-                0,
-                1,
-                0,
-                0,
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
             ],
         },
         big_slots: StatePart {
             value: [
+                0 (modified),
                 0,
                 0,
-                0,
-                49,
-                50,
-                50,
-                0,
-                1,
-                0,
-                49,
-                49,
-                50,
-                1,
-                0,
-                0,
-                48,
-                49,
-                49,
-                0,
-                0,
-                1,
-                48,
-                49,
-                48,
-                0,
-                1,
-                0,
-                49,
-                49,
-                50,
-                0,
-                0,
-                1,
-                49,
-                49,
-                49,
-                0,
-                0,
-                1,
-                49,
-                50,
-                50,
-                0,
-                1,
-                0,
-                49,
-                49,
-                50,
+                49 (modified),
+                50 (modified),
+                50 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                49 (modified),
+                49 (modified),
+                50 (modified),
+                1 (modified),
+                0 (modified),
+                0 (modified),
+                48 (modified),
+                49 (modified),
+                49 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                48 (modified),
+                49 (modified),
+                48 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                49 (modified),
+                49 (modified),
+                50 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                49 (modified),
+                49 (modified),
+                49 (modified),
+                0 (modified),
+                0 (modified),
+                1 (modified),
+                49 (modified),
+                50 (modified),
+                50 (modified),
+                0 (modified),
+                1 (modified),
+                0 (modified),
+                49 (modified),
+                49 (modified),
+                50 (modified),
             ],
         },
         sim_only_slots: StatePart {
@@ -9500,6 +9500,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9508,6 +9509,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9516,6 +9518,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -9525,6 +9528,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9534,6 +9538,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -9543,6 +9548,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -9551,6 +9557,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(6),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9559,6 +9566,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(7),
             },
+            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -9567,6 +9575,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(8),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9576,6 +9585,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9585,6 +9595,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9594,6 +9605,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
diff --git a/crates/fayalite/tests/sim/expected/sim_resettable_counter_async.txt b/crates/fayalite/tests/sim/expected/sim_resettable_counter_async.txt
index 3fea928..5584b73 100644
--- a/crates/fayalite/tests/sim/expected/sim_resettable_counter_async.txt
+++ b/crates/fayalite/tests/sim/expected/sim_resettable_counter_async.txt
@@ -56,8 +56,8 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
-                0,
-                0,
+                0 (modified),
+                0 (modified),
                 3,
             ],
         },
@@ -310,6 +310,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -318,6 +319,7 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -327,6 +329,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x03,
             last_state: 0x03,
         },
diff --git a/crates/fayalite/tests/sim/expected/sim_resettable_counter_async_immediate_reset.txt b/crates/fayalite/tests/sim/expected/sim_resettable_counter_async_immediate_reset.txt
index 2283ce5..f03c25a 100644
--- a/crates/fayalite/tests/sim/expected/sim_resettable_counter_async_immediate_reset.txt
+++ b/crates/fayalite/tests/sim/expected/sim_resettable_counter_async_immediate_reset.txt
@@ -56,8 +56,8 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
-                0,
-                0,
+                0 (modified),
+                0 (modified),
                 3,
             ],
         },
@@ -310,6 +310,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -318,6 +319,7 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -327,6 +329,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x03,
             last_state: 0x03,
         },
diff --git a/crates/fayalite/tests/sim/expected/sim_resettable_counter_sync.txt b/crates/fayalite/tests/sim/expected/sim_resettable_counter_sync.txt
index c77046f..c93d6c1 100644
--- a/crates/fayalite/tests/sim/expected/sim_resettable_counter_sync.txt
+++ b/crates/fayalite/tests/sim/expected/sim_resettable_counter_sync.txt
@@ -56,7 +56,7 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
-                0,
+                0 (modified),
                 0,
                 3,
             ],
@@ -310,6 +310,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -318,6 +319,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -327,6 +329,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x03,
             last_state: 0x03,
         },
diff --git a/crates/fayalite/tests/sim/expected/sim_resettable_counter_sync_immediate_reset.txt b/crates/fayalite/tests/sim/expected/sim_resettable_counter_sync_immediate_reset.txt
index e1c565a..f13af84 100644
--- a/crates/fayalite/tests/sim/expected/sim_resettable_counter_sync_immediate_reset.txt
+++ b/crates/fayalite/tests/sim/expected/sim_resettable_counter_sync_immediate_reset.txt
@@ -56,7 +56,7 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
-                0,
+                0 (modified),
                 0,
                 3,
             ],
@@ -310,6 +310,7 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
+            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -318,6 +319,7 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
+            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -327,6 +329,7 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
+            maybe_changed: false,
             state: 0x03,
             last_state: 0x03,
         },