diff --git a/crates/fayalite-proc-macros-impl/src/fold.rs b/crates/fayalite-proc-macros-impl/src/fold.rs
index 50423b5..22e7b82 100644
--- a/crates/fayalite-proc-macros-impl/src/fold.rs
+++ b/crates/fayalite-proc-macros-impl/src/fold.rs
@@ -257,6 +257,5 @@ no_op_fold!(syn::Token![let]);
 no_op_fold!(syn::Token![mut]);
 no_op_fold!(syn::Token![static]);
 no_op_fold!(syn::Token![struct]);
-no_op_fold!(syn::Token![type]);
 no_op_fold!(syn::Token![where]);
 no_op_fold!(usize);
diff --git a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs
index f7ad68d..97fa3ff 100644
--- a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs
+++ b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs
@@ -3,9 +3,8 @@
 use crate::{
     Errors, HdlAttr, PairsIterExt,
     hdl_type_common::{
-        CustomDebugOptions, CustomDebugTrait, ItemOptions, MakeHdlTypeExpr, MaybeParsed,
-        ParsedField, ParsedFieldsNamed, ParsedGenerics, SplitForImpl, TypesParser, WrappedInConst,
-        common_derives, create_struct_debug_impl, get_target,
+        ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedField, ParsedFieldsNamed, ParsedGenerics,
+        SplitForImpl, TypesParser, WrappedInConst, common_derives, get_target,
     },
     kw,
 };
@@ -31,7 +30,6 @@ pub(crate) struct ParsedBundle {
     pub(crate) fields: MaybeParsed<ParsedFieldsNamed, FieldsNamed>,
     pub(crate) field_flips: Vec<Option<HdlAttr<kw::flip, kw::hdl>>>,
     pub(crate) mask_type_ident: Ident,
-    pub(crate) mask_type_name: String,
     pub(crate) mask_type_match_variant_ident: Ident,
     pub(crate) mask_type_sim_value_ident: Ident,
     pub(crate) match_variant_ident: Ident,
@@ -90,8 +88,6 @@ impl ParsedBundle {
             no_runtime_generics: _,
             cmp_eq: _,
             ref get,
-            custom_debug: _,
-            custom_sim_display: _,
         } = options.body;
         if let Some((get, ..)) = get {
             errors.error(get, "#[hdl(get(...))] is not allowed on structs");
@@ -135,7 +131,6 @@ impl ParsedBundle {
             fields,
             field_flips,
             mask_type_ident: format_ident!("__{}__MaskType", ident),
-            mask_type_name: format!("MaskType<{}>", ident),
             mask_type_match_variant_ident: format_ident!("__{}__MaskType__MatchVariant", ident),
             mask_type_sim_value_ident: format_ident!("__{}__MaskType__SimValue", ident),
             match_variant_ident: format_ident!("__{}__MatchVariant", ident),
@@ -453,7 +448,6 @@ impl ToTokens for ParsedBundle {
             fields,
             field_flips,
             mask_type_ident,
-            mask_type_name,
             mask_type_match_variant_ident,
             mask_type_sim_value_ident,
             match_variant_ident,
@@ -470,20 +464,11 @@ impl ToTokens for ParsedBundle {
             no_runtime_generics,
             cmp_eq,
             get: _,
-            custom_debug: _,
-            custom_sim_display,
         } = &options.body;
-        let CustomDebugOptions {
-            type_: custom_debug_type,
-            sim: custom_debug_sim,
-            mask_type: custom_debug_mask_type,
-            mask_sim: custom_debug_mask_sim,
-        } = options.body.custom_debug();
         let target = get_target(target, ident);
-        let struct_name = ident.to_string();
         let mut item_attrs = attrs.clone();
-        item_attrs.push(common_derives(span, false));
-        let type_struct = ItemStruct {
+        item_attrs.push(common_derives(span));
+        ItemStruct {
             attrs: item_attrs,
             vis: vis.clone(),
             struct_token: *struct_token,
@@ -491,8 +476,8 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(fields.clone().into()),
             semi_token: None,
-        };
-        type_struct.to_tokens(tokens);
+        }
+        .to_tokens(tokens);
         let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
         if let (MaybeParsed::Parsed(generics), MaybeParsed::Parsed(fields), None) =
             (generics, fields, no_runtime_generics)
@@ -518,9 +503,6 @@ impl ToTokens for ParsedBundle {
         }
         let mut wrapped_in_const = WrappedInConst::new(tokens, span);
         let tokens = wrapped_in_const.inner();
-        if custom_debug_type.is_none() {
-            create_struct_debug_impl(&type_struct, &struct_name, None).to_tokens(tokens);
-        }
         let builder = Builder {
             vis: vis.clone(),
             struct_token: *struct_token,
@@ -548,9 +530,9 @@ impl ToTokens for ParsedBundle {
         mask_type_builder.to_tokens(tokens);
         let unfilled_mask_type_builder_ty =
             mask_type_builder.builder_struct_ty(|_| BuilderFieldState::Unfilled);
-        let mask_type_struct = ItemStruct {
+        ItemStruct {
             attrs: vec![
-                common_derives(span, false),
+                common_derives(span),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types, dead_code)]
                 },
@@ -561,20 +543,17 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(mask_type_fields.clone()),
             semi_token: None,
-        };
-        mask_type_struct.to_tokens(tokens);
-        if custom_debug_mask_type.is_none() {
-            create_struct_debug_impl(&mask_type_struct, mask_type_name, None).to_tokens(tokens);
         }
+        .to_tokens(tokens);
         let mut mask_type_match_variant_fields = mask_type_fields.clone();
         for Field { ty, .. } in &mut mask_type_match_variant_fields.named {
             *ty = parse_quote_spanned! {span=>
                 ::fayalite::expr::Expr<#ty>
             };
         }
-        let mask_type_match_variant_struct = ItemStruct {
+        ItemStruct {
             attrs: vec![
-                common_derives(span, false),
+                common_derives(span),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types, dead_code)]
                 },
@@ -585,19 +564,17 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(mask_type_match_variant_fields),
             semi_token: None,
-        };
-        mask_type_match_variant_struct.to_tokens(tokens);
-        create_struct_debug_impl(&mask_type_match_variant_struct, mask_type_name, None)
-            .to_tokens(tokens);
+        }
+        .to_tokens(tokens);
         let mut match_variant_fields = FieldsNamed::from(fields.clone());
         for Field { ty, .. } in &mut match_variant_fields.named {
             *ty = parse_quote_spanned! {span=>
                 ::fayalite::expr::Expr<#ty>
             };
         }
-        let match_variant_struct = ItemStruct {
+        ItemStruct {
             attrs: vec![
-                common_derives(span, false),
+                common_derives(span),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types, dead_code)]
                 },
@@ -608,19 +585,19 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(match_variant_fields),
             semi_token: None,
-        };
-        match_variant_struct.to_tokens(tokens);
-        create_struct_debug_impl(&match_variant_struct, &struct_name, None).to_tokens(tokens);
+        }
+        .to_tokens(tokens);
         let mut mask_type_sim_value_fields = mask_type_fields;
         for Field { ty, .. } in &mut mask_type_sim_value_fields.named {
             *ty = parse_quote_spanned! {span=>
                 ::fayalite::sim::value::SimValue<#ty>
             };
         }
-        let mask_type_sim_value_struct = ItemStruct {
+        ItemStruct {
             attrs: vec![
                 parse_quote_spanned! {span=>
                     #[::fayalite::__std::prelude::v1::derive(
+                        ::fayalite::__std::fmt::Debug,
                         ::fayalite::__std::clone::Clone,
                     )]
                 },
@@ -634,34 +611,19 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(mask_type_sim_value_fields),
             semi_token: None,
-        };
-        mask_type_sim_value_struct.to_tokens(tokens);
-        if custom_debug_mask_sim.is_none() {
-            create_struct_debug_impl(
-                &mask_type_struct,
-                mask_type_name,
-                Some(CustomDebugTrait {
-                    trait_path: &parse_quote_spanned! {span=>
-                        ::fayalite::ty::SimValueDebug
-                    },
-                    fn_name: &format_ident!("sim_value_debug", span = span),
-                    this_arg: &parse_quote_spanned! {span=>
-                        value: &<Self as ::fayalite::ty::Type>::SimValue
-                    },
-                }),
-            )
-            .to_tokens(tokens);
         }
+        .to_tokens(tokens);
         let mut sim_value_fields = FieldsNamed::from(fields.clone());
         for Field { ty, .. } in &mut sim_value_fields.named {
             *ty = parse_quote_spanned! {span=>
                 ::fayalite::sim::value::SimValue<#ty>
             };
         }
-        let sim_value_struct = ItemStruct {
+        ItemStruct {
             attrs: vec![
                 parse_quote_spanned! {span=>
                     #[::fayalite::__std::prelude::v1::derive(
+                        ::fayalite::__std::fmt::Debug,
                         ::fayalite::__std::clone::Clone,
                     )]
                 },
@@ -675,36 +637,8 @@ impl ToTokens for ParsedBundle {
             generics: generics.into(),
             fields: Fields::Named(sim_value_fields),
             semi_token: None,
-        };
-        sim_value_struct.to_tokens(tokens);
-        if custom_debug_sim.is_none() {
-            create_struct_debug_impl(
-                &type_struct,
-                &struct_name,
-                Some(CustomDebugTrait {
-                    trait_path: &parse_quote_spanned! {span=>
-                        ::fayalite::ty::SimValueDebug
-                    },
-                    fn_name: &format_ident!("sim_value_debug", span = span),
-                    this_arg: &parse_quote_spanned! {span=>
-                        value: &<Self as ::fayalite::ty::Type>::SimValue
-                    },
-                }),
-            )
-            .to_tokens(tokens);
-        }
-        if custom_sim_display.is_some() {
-            quote_spanned! {span=>
-                #[automatically_derived]
-                impl #impl_generics ::fayalite::__std::fmt::Display for #sim_value_ident #type_generics
-                #where_clause
-                {
-                    fn fmt(&self, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
-                        <#target #type_generics as ::fayalite::ty::SimValueDisplay>::sim_value_display(self, f)
-                    }
-                }
-            }.to_tokens(tokens);
         }
+        .to_tokens(tokens);
         let this_token = Ident::new("__this", span);
         let fields_token = Ident::new("__fields", span);
         let self_token = Token![self](span);
@@ -886,14 +820,6 @@ impl ToTokens for ParsedBundle {
                 }
             }
             #[automatically_derived]
-            impl #impl_generics ::fayalite::__std::fmt::Debug for #mask_type_sim_value_ident #type_generics
-            #where_clause
-            {
-                fn fmt(&self, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
-                    <#mask_type_ident #type_generics as ::fayalite::ty::SimValueDebug>::sim_value_debug(self, f)
-                }
-            }
-            #[automatically_derived]
             impl #impl_generics ::fayalite::expr::ValueType for #mask_type_sim_value_ident #type_generics
             #where_clause
             {
@@ -1054,14 +980,6 @@ impl ToTokens for ParsedBundle {
                 }
             }
             #[automatically_derived]
-            impl #impl_generics ::fayalite::__std::fmt::Debug for #sim_value_ident #type_generics
-            #where_clause
-            {
-                fn fmt(&self, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
-                    <#target #type_generics as ::fayalite::ty::SimValueDebug>::sim_value_debug(self, f)
-                }
-            }
-            #[automatically_derived]
             impl #impl_generics ::fayalite::expr::ValueType for #sim_value_ident #type_generics
             #where_clause
             {
@@ -1223,7 +1141,7 @@ impl ToTokens for ParsedBundle {
                 valueless_eq_body = quote_spanned! {span=>
                     let __lhs = ::fayalite::expr::ValueType::ty(&__lhs);
                     let __rhs = ::fayalite::expr::ValueType::ty(&__rhs);
-                    #(#fields_valueless_eq)&*
+                    #(#fields_valueless_eq)|*
                 };
                 valueless_ne_body = quote_spanned! {span=>
                     let __lhs = ::fayalite::expr::ValueType::ty(&__lhs);
diff --git a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs
index e9f013b..ae0f8f4 100644
--- a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs
+++ b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs
@@ -3,9 +3,8 @@
 use crate::{
     Errors, HdlAttr, PairsIterExt,
     hdl_type_common::{
-        CustomDebugOptions, ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics, ParsedType,
-        SplitForImpl, TypesParser, WrappedInConst, common_derives, create_struct_debug_impl,
-        get_target,
+        ItemOptions, MakeHdlTypeExpr, MaybeParsed, ParsedGenerics, ParsedType, SplitForImpl,
+        TypesParser, WrappedInConst, common_derives, get_target,
     },
     kw,
 };
@@ -159,32 +158,15 @@ impl ParsedEnum {
             custom_bounds,
             no_static: _,
             no_runtime_generics: _,
-            cmp_eq: _,
+            cmp_eq,
             ref get,
-            custom_debug: _,
-            custom_sim_display: _,
         } = options.body;
+        if let Some((cmp_eq,)) = cmp_eq {
+            errors.error(cmp_eq, "#[hdl(cmp_eq)] is not yet implemented for enums");
+        }
         if let Some((get, ..)) = get {
             errors.error(get, "#[hdl(get(...))] is not allowed on enums");
         }
-        let CustomDebugOptions {
-            type_: _,
-            sim: _,
-            mask_type,
-            mask_sim,
-        } = options.body.custom_debug();
-        if let Some((mask_type,)) = mask_type {
-            errors.error(
-                mask_type,
-                "#[hdl(custom_debug(mask_type)] is not allowed on enums",
-            );
-        }
-        if let Some((mask_sim,)) = mask_sim {
-            errors.error(
-                mask_sim,
-                "#[hdl(custom_debug(mask_sim)] is not allowed on enums",
-            );
-        }
         attrs.retain(|attr| {
             if attr.path().is_ident("repr") {
                 errors.error(attr, "#[repr] is not supported on #[hdl] enums");
@@ -246,21 +228,12 @@ impl ToTokens for ParsedEnum {
             custom_bounds: _,
             no_static,
             no_runtime_generics,
-            cmp_eq,
+            cmp_eq: _, // TODO: implement cmp_eq for enums
             get: _,
-            custom_debug: _,
-            custom_sim_display,
         } = &options.body;
-        let CustomDebugOptions {
-            type_: custom_debug_type,
-            sim: custom_debug_sim,
-            mask_type: _,
-            mask_sim: _,
-        } = options.body.custom_debug();
         let target = get_target(target, ident);
-        let enum_name = ident.to_string();
         let mut struct_attrs = attrs.clone();
-        struct_attrs.push(common_derives(span, false));
+        struct_attrs.push(common_derives(span));
         struct_attrs.push(parse_quote_spanned! {span=>
             #[allow(non_snake_case)]
         });
@@ -300,7 +273,7 @@ impl ToTokens for ParsedEnum {
                 }
             },
         ));
-        let type_struct = ItemStruct {
+        ItemStruct {
             attrs: struct_attrs,
             vis: vis.clone(),
             struct_token: Token![struct](enum_token.span),
@@ -315,8 +288,8 @@ impl ToTokens for ParsedEnum {
                 })
             },
             semi_token: None,
-        };
-        type_struct.to_tokens(tokens);
+        }
+        .to_tokens(tokens);
         let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
         if let (MaybeParsed::Parsed(generics), None) = (generics, no_runtime_generics) {
             generics.make_runtime_generics(tokens, vis, ident, &target, |context| {
@@ -400,9 +373,6 @@ impl ToTokens for ParsedEnum {
             }
             .to_tokens(tokens);
         }
-        if custom_debug_type.is_none() {
-            create_struct_debug_impl(&type_struct, &enum_name, None).to_tokens(tokens);
-        }
         let mut enum_attrs = attrs.clone();
         enum_attrs.push(parse_quote_spanned! {span=>
             #[allow(dead_code, non_camel_case_types)]
@@ -483,6 +453,7 @@ impl ToTokens for ParsedEnum {
         let mut enum_attrs = attrs.clone();
         enum_attrs.push(parse_quote_spanned! {span=>
             #[::fayalite::__std::prelude::v1::derive(
+                ::fayalite::__std::fmt::Debug,
                 ::fayalite::__std::clone::Clone,
             )]
         });
@@ -867,240 +838,6 @@ impl ToTokens for ParsedEnum {
                     },
                 )),
         );
-        if custom_debug_sim.is_none() {
-            let debug_match_arms = Vec::from_iter(
-                variants
-                    .iter()
-                    .map(
-                        |ParsedVariant {
-                             attrs: _,
-                             options: _,
-                             ident,
-                             field,
-                         }| {
-                            let variant_name = ident.to_string();
-                            if let Some(_) = field {
-                                quote_spanned! {span=>
-                                    #sim_value_ident::#ident(field, _) => {
-                                        f.debug_tuple(#variant_name).field(field).finish()
-                                    }
-                                }
-                            } else {
-                                quote_spanned! {span=>
-                                    #sim_value_ident::#ident(_) => {
-                                        f.write_str(#variant_name)
-                                    }
-                                }
-                            }
-                        },
-                    )
-                    .chain(sim_value_unknown_variant_name.as_ref().map(
-                        |sim_value_unknown_variant_name| {
-                            let sim_value_unknown_variant_name_str =
-                                sim_value_unknown_variant_name.to_string();
-                            quote_spanned! {span=>
-                                #sim_value_ident::#sim_value_unknown_variant_name(_) => {
-                                    f.write_str(#sim_value_unknown_variant_name_str)
-                                }
-                            }
-                        },
-                    )),
-            );
-            quote_spanned! {span=>
-                #[automatically_derived]
-                impl #impl_generics ::fayalite::ty::SimValueDebug for #target #type_generics
-                #where_clause
-                {
-                    fn sim_value_debug(
-                        value: &<Self as ::fayalite::ty::Type>::SimValue,
-                        f: &mut ::fayalite::__std::fmt::Formatter<'_>,
-                    ) -> ::fayalite::__std::fmt::Result {
-                        match value {
-                            #(#debug_match_arms)*
-                        }
-                    }
-                }
-            }
-            .to_tokens(tokens);
-        }
-        if custom_sim_display.is_some() {
-            quote_spanned! {span=>
-                #[automatically_derived]
-                impl #impl_generics ::fayalite::__std::fmt::Display for #sim_value_ident #type_generics
-                #where_clause
-                {
-                    fn fmt(&self, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
-                        <#target #type_generics as ::fayalite::ty::SimValueDisplay>::sim_value_display(self, f)
-                    }
-                }
-            }.to_tokens(tokens);
-        }
-        if let Some((cmp_eq,)) = cmp_eq {
-            let mut cmp_eq_where_clause =
-                Generics::from(generics)
-                    .where_clause
-                    .unwrap_or_else(|| syn::WhereClause {
-                        where_token: Token![where](span),
-                        predicates: Punctuated::new(),
-                    });
-            let mut variants_value_eq = vec![];
-            let mut variants_expr_eq = vec![];
-            let mut fields_valueless_eq = vec![];
-            for (
-                variant_index,
-                ParsedVariant {
-                    attrs: _,
-                    options: variant_options,
-                    ident: variant_ident,
-                    field,
-                },
-            ) in variants.iter().enumerate()
-            {
-                let VariantOptions {} = variant_options.body;
-                if let Some(ParsedVariantField {
-                    paren_token: _,
-                    attrs: _,
-                    options: field_options,
-                    ty: field_ty,
-                    comma_token: _,
-                }) = field
-                {
-                    let FieldOptions {} = field_options.body;
-                    cmp_eq_where_clause
-                        .predicates
-                        .push(parse_quote_spanned! {cmp_eq.span=>
-                            #field_ty: ::fayalite::expr::HdlPartialEqImpl<#field_ty>
-                        });
-                    variants_value_eq.push(quote_spanned! {span=>
-                        (#sim_value_ident::#variant_ident(__lhs_field, _), #sim_value_ident::#variant_ident(__rhs_field, _)) => {
-                            ::fayalite::expr::HdlPartialEqImpl::cmp_value_eq(
-                                __lhs.#variant_ident,
-                                ::fayalite::__std::borrow::Cow::Borrowed(__lhs_field),
-                                __rhs.#variant_ident,
-                                ::fayalite::__std::borrow::Cow::Borrowed(__rhs_field),
-                            )
-                        }
-                    });
-                    variants_expr_eq.push(quote_spanned! {span=>
-                        {
-                            let (#match_variant_ident::#variant_ident(__lhs), __scope) =
-                                ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope(
-                                    ::fayalite::__std::iter::Iterator::next(&mut __lhs_match_variant_iter)
-                                        .expect("known to have enough variants"),
-                                )
-                            else {
-                                ::fayalite::__std::unreachable!();
-                            };
-                            let (#match_variant_ident::#variant_ident(__rhs), __scope) =
-                                ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope(
-                                    ::fayalite::__std::iter::Iterator::nth(
-                                        &mut ::fayalite::module::match_(__rhs),
-                                        #variant_index,
-                                    )
-                                        .expect("known to have variant"),
-                                )
-                            else {
-                                ::fayalite::__std::unreachable!();
-                            };
-                            ::fayalite::module::connect(__retval, ::fayalite::expr::HdlPartialEqImpl::cmp_expr_eq(__lhs, __rhs));
-                        }
-                    });
-                    fields_valueless_eq.push(quote_spanned! {span=>
-                        ::fayalite::expr::HdlPartialEqImpl::cmp_valueless_eq(
-                            ::fayalite::expr::Valueless::new(__lhs.#variant_ident),
-                            ::fayalite::expr::Valueless::new(__rhs.#variant_ident),
-                        )
-                    });
-                } else {
-                    variants_value_eq.push(quote_spanned! {span=>
-                        (#sim_value_ident::#variant_ident(_), #sim_value_ident::#variant_ident(_)) => true,
-                    });
-                    variants_expr_eq.push(quote_spanned! {span=>
-                        {
-                            let (#match_variant_ident::#variant_ident, __scope) =
-                                ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope(
-                                    ::fayalite::__std::iter::Iterator::next(&mut __lhs_match_variant_iter)
-                                        .expect("known to have enough variants"),
-                                )
-                            else {
-                                ::fayalite::__std::unreachable!();
-                            };
-                            let (#match_variant_ident::#variant_ident, __scope) =
-                                ::fayalite::ty::MatchVariantAndInactiveScope::match_activate_scope(
-                                    ::fayalite::__std::iter::Iterator::nth(
-                                        &mut ::fayalite::module::match_(__rhs),
-                                        #variant_index,
-                                    )
-                                        .expect("known to have variant"),
-                                )
-                            else {
-                                ::fayalite::__std::unreachable!();
-                            };
-                            ::fayalite::module::connect(__retval, true);
-                        }
-                    });
-                }
-            }
-            if let Some(sim_value_unknown_variant_name) = &sim_value_unknown_variant_name {
-                variants_value_eq.push(quote_spanned! {span=>
-                    (#sim_value_ident::#sim_value_unknown_variant_name(__lhs_unknown), #sim_value_ident::#sim_value_unknown_variant_name(__rhs_unknown)) => {
-                        __lhs_unknown == __rhs_unknown
-                    }
-                });
-            }
-            let valueless_eq_body = if fields_valueless_eq.is_empty() {
-                quote_spanned! {span=>
-                    ::fayalite::expr::Valueless::new(::fayalite::int::Bool)
-                }
-            } else {
-                quote_spanned! {span=>
-                    let __lhs = ::fayalite::expr::ValueType::ty(&__lhs);
-                    let __rhs = ::fayalite::expr::ValueType::ty(&__rhs);
-                    #(#fields_valueless_eq)&*
-                }
-            };
-            let cmp_expr_eq_wire_name = format!("{ident}_cmp_eq");
-            quote_spanned! {span=>
-                #[automatically_derived]
-                impl #impl_generics ::fayalite::expr::HdlPartialEqImpl<Self> for #target #type_generics
-                #cmp_eq_where_clause
-                {
-                    #[track_caller]
-                    fn cmp_value_eq(
-                        __lhs: Self,
-                        __lhs_value: ::fayalite::__std::borrow::Cow<'_, <Self as ::fayalite::ty::Type>::SimValue>,
-                        __rhs: Self,
-                        __rhs_value: ::fayalite::__std::borrow::Cow<'_, <Self as ::fayalite::ty::Type>::SimValue>,
-                    ) -> ::fayalite::__std::primitive::bool {
-                        match (&*__lhs_value, &*__rhs_value) {
-                            #(#variants_value_eq)*
-                            _ => false,
-                        }
-                    }
-
-                    #[track_caller]
-                    fn cmp_expr_eq(
-                        __lhs: ::fayalite::expr::Expr<Self>,
-                        __rhs: ::fayalite::expr::Expr<Self>,
-                    ) -> ::fayalite::expr::Expr<::fayalite::int::Bool> {
-                        let __retval = ::fayalite::module::wire(::fayalite::module::ImplicitName(#cmp_expr_eq_wire_name), ::fayalite::int::Bool);
-                        ::fayalite::module::connect(__retval, false);
-                        let mut __lhs_match_variant_iter = ::fayalite::module::match_(__lhs);
-                        #(#variants_expr_eq)*
-                        __retval
-                    }
-
-                    #[track_caller]
-                    fn cmp_valueless_eq(
-                        __lhs: ::fayalite::expr::Valueless<Self>,
-                        __rhs: ::fayalite::expr::Valueless<Self>,
-                    ) -> ::fayalite::expr::Valueless<::fayalite::int::Bool> {
-                        #valueless_eq_body
-                    }
-                }
-            }
-            .to_tokens(tokens);
-        }
         let variants_len = variants.len();
         quote_spanned! {span=>
             #[automatically_derived]
@@ -1197,14 +934,6 @@ impl ToTokens for ParsedEnum {
                 }
             }
             #[automatically_derived]
-            impl #impl_generics ::fayalite::__std::fmt::Debug for #sim_value_ident #type_generics
-            #where_clause
-            {
-                fn fmt(&self, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
-                    <#target #type_generics as ::fayalite::ty::SimValueDebug>::sim_value_debug(self, f)
-                }
-            }
-            #[automatically_derived]
             impl #impl_generics ::fayalite::sim::value::ToSimValueWithType<#target #type_generics>
             for #sim_value_ident #type_generics
             #where_clause
diff --git a/crates/fayalite-proc-macros-impl/src/hdl_type_alias.rs b/crates/fayalite-proc-macros-impl/src/hdl_type_alias.rs
index 556c15b..0fa2222 100644
--- a/crates/fayalite-proc-macros-impl/src/hdl_type_alias.rs
+++ b/crates/fayalite-proc-macros-impl/src/hdl_type_alias.rs
@@ -215,8 +215,6 @@ impl ParsedTypeAlias {
             no_runtime_generics,
             cmp_eq,
             get: _,
-            ref custom_debug,
-            custom_sim_display,
         } = options.body;
         if let Some((no_static,)) = no_static {
             errors.error(no_static, "no_static is not valid on type aliases");
@@ -236,15 +234,6 @@ impl ParsedTypeAlias {
         if let Some((cmp_eq,)) = cmp_eq {
             errors.error(cmp_eq, "cmp_eq is not valid on type aliases");
         }
-        if let Some((custom_debug, _, _)) = custom_debug {
-            errors.error(custom_debug, "custom_debug is not valid on type aliases");
-        }
-        if let Some((custom_sim_display,)) = custom_sim_display {
-            errors.error(
-                custom_sim_display,
-                "custom_sim_display is not valid on type aliases",
-            );
-        }
         if let Some((custom_bounds,)) = custom_bounds {
             errors.error(
                 custom_bounds,
@@ -298,8 +287,6 @@ impl ParsedTypeAlias {
             no_runtime_generics: _,
             cmp_eq,
             ref mut get,
-            ref custom_debug,
-            custom_sim_display,
         } = options.body;
         if let Some(get) = get.take() {
             return Self::parse_phantom_const_accessor(
@@ -324,15 +311,6 @@ impl ParsedTypeAlias {
         if let Some((cmp_eq,)) = cmp_eq {
             errors.error(cmp_eq, "cmp_eq is not valid on type aliases");
         }
-        if let Some((custom_debug, _, _)) = custom_debug {
-            errors.error(custom_debug, "custom_debug is not valid on type aliases");
-        }
-        if let Some((custom_sim_display,)) = custom_sim_display {
-            errors.error(
-                custom_sim_display,
-                "custom_sim_display is not valid on type aliases",
-            );
-        }
         let generics = if custom_bounds.is_some() {
             MaybeParsed::Unrecognized(generics)
         } else if let Some(generics) = errors.ok(ParsedGenerics::parse(&mut generics)) {
@@ -378,8 +356,6 @@ impl ToTokens for ParsedTypeAlias {
                     no_runtime_generics,
                     cmp_eq: _,
                     get: _,
-                    custom_debug: _,
-                    custom_sim_display: _,
                 } = &options.body;
                 let target = get_target(target, ident);
                 let mut type_attrs = attrs.clone();
@@ -426,8 +402,6 @@ impl ToTokens for ParsedTypeAlias {
                     no_runtime_generics: _,
                     cmp_eq: _,
                     get: _,
-                    custom_debug: _,
-                    custom_sim_display: _,
                 } = &options.body;
                 let span = ident.span();
                 let mut type_attrs = attrs.clone();
@@ -453,7 +427,7 @@ impl ToTokens for ParsedTypeAlias {
                     format_ident!("__{}__GenericsAccumulation", ident);
                 ItemStruct {
                     attrs: vec![
-                        common_derives(span, true),
+                        common_derives(span),
                         parse_quote_spanned! {span=>
                             #[allow(non_camel_case_types)]
                         },
diff --git a/crates/fayalite-proc-macros-impl/src/hdl_type_common.rs b/crates/fayalite-proc-macros-impl/src/hdl_type_common.rs
index 18cffc6..3a0e5e9 100644
--- a/crates/fayalite-proc-macros-impl/src/hdl_type_common.rs
+++ b/crates/fayalite-proc-macros-impl/src/hdl_type_common.rs
@@ -7,10 +7,10 @@ use std::{collections::HashMap, fmt, mem};
 use syn::{
     AngleBracketedGenericArguments, Attribute, Block, ConstParam, Expr, ExprBlock, ExprGroup,
     ExprIndex, ExprParen, ExprPath, ExprTuple, Field, FieldMutability, Fields, FieldsNamed,
-    FieldsUnnamed, FnArg, GenericArgument, GenericParam, Generics, Ident, ImplGenerics, Index,
-    ItemStruct, Path, PathArguments, PathSegment, PredicateType, QSelf, Stmt, Token, TraitBound,
-    Turbofish, Type, TypeGenerics, TypeGroup, TypeParam, TypeParamBound, TypeParen, TypePath,
-    TypeTuple, Visibility, WhereClause, WherePredicate,
+    FieldsUnnamed, GenericArgument, GenericParam, Generics, Ident, ImplGenerics, Index, ItemStruct,
+    Path, PathArguments, PathSegment, PredicateType, QSelf, Stmt, Token, TraitBound, Turbofish,
+    Type, TypeGenerics, TypeGroup, TypeParam, TypeParamBound, TypeParen, TypePath, TypeTuple,
+    Visibility, WhereClause, WherePredicate,
     parse::{Parse, ParseStream},
     parse_quote, parse_quote_spanned,
     punctuated::{Pair, Punctuated},
@@ -18,17 +18,6 @@ use syn::{
     token::{Brace, Bracket, Paren},
 };
 
-crate::options! {
-    #[options = CustomDebugOptions]
-    #[no_ident_fragment]
-    pub(crate) enum CustomDebugOption {
-        Type(type_),
-        Sim(sim),
-        MaskType(mask_type),
-        MaskSim(mask_sim),
-    }
-}
-
 crate::options! {
     #[options = ItemOptions]
     pub(crate) enum ItemOption {
@@ -39,8 +28,6 @@ crate::options! {
         NoRuntimeGenerics(no_runtime_generics),
         CmpEq(cmp_eq),
         Get(get, Expr),
-        CustomDebug(custom_debug, CustomDebugOptions),
-        CustomSimDisplay(custom_sim_display),
     }
 }
 
@@ -54,36 +41,8 @@ impl ItemOptions {
         {
             self.no_static = Some((kw::no_static(custom_bounds.span),));
         }
-        if let Some((kw, _, custom_debug)) = &mut self.custom_debug {
-            if let CustomDebugOptions {
-                type_: None,
-                sim: None,
-                mask_type: None,
-                mask_sim: None,
-            } = custom_debug
-            {
-                *custom_debug = CustomDebugOptions {
-                    type_: Some((kw::type_(kw.span),)),
-                    sim: Some((kw::sim(kw.span),)),
-                    mask_type: None,
-                    mask_sim: None,
-                };
-            }
-        }
         Ok(())
     }
-    pub(crate) fn custom_debug(&self) -> &CustomDebugOptions {
-        self.custom_debug.as_ref().map(|v| &v.2).unwrap_or(
-            const {
-                &CustomDebugOptions {
-                    type_: None,
-                    sim: None,
-                    mask_type: None,
-                    mask_sim: None,
-                }
-            },
-        )
-    }
 }
 
 pub(crate) struct WrappedInConst<'a> {
@@ -125,17 +84,10 @@ pub(crate) fn get_target(target: &Option<(kw::target, Paren, Path)>, item_ident:
     }
 }
 
-pub(crate) fn common_derives(span: Span, include_debug: bool) -> Attribute {
-    let debug = include_debug
-        .then(|| {
-            quote_spanned! {span=>
-                ::fayalite::__std::fmt::Debug
-            }
-        })
-        .into_iter();
+pub(crate) fn common_derives(span: Span) -> Attribute {
     parse_quote_spanned! {span=>
         #[::fayalite::__std::prelude::v1::derive(
-            #(#debug,)*
+            ::fayalite::__std::fmt::Debug,
             ::fayalite::__std::cmp::Eq,
             ::fayalite::__std::cmp::PartialEq,
             ::fayalite::__std::hash::Hash,
@@ -3023,7 +2975,7 @@ impl ParsedGenerics {
         let span = ident.span();
         ItemStruct {
             attrs: vec![
-                common_derives(span, true),
+                common_derives(span),
                 parse_quote_spanned! {span=>
                     #[allow(non_camel_case_types)]
                 },
@@ -4781,109 +4733,3 @@ impl ParsedVisibility {
             .map(|ord| if ord.is_lt() { self } else { other })
     }
 }
-
-pub(crate) struct CustomDebugTrait<'a> {
-    pub(crate) trait_path: &'a Path,
-    pub(crate) fn_name: &'a Ident,
-    pub(crate) this_arg: &'a FnArg,
-}
-
-#[must_use]
-pub(crate) fn create_struct_debug_impl(
-    item_struct: &ItemStruct,
-    debug_struct_name: &str,
-    custom_debug_trait: Option<CustomDebugTrait<'_>>,
-) -> TokenStream {
-    let ident = &item_struct.ident;
-    let span = ident.span();
-    let (impl_generics, type_generics, where_clause) = item_struct.generics.split_for_impl();
-    let trait_path;
-    let fn_name;
-    let this_arg;
-    let CustomDebugTrait {
-        trait_path,
-        fn_name,
-        this_arg,
-    } = match custom_debug_trait {
-        Some(v) => v,
-        None => {
-            trait_path = parse_quote_spanned! {span=>
-                ::fayalite::__std::fmt::Debug
-            };
-            fn_name = parse_quote_spanned! {span=>
-                fmt
-            };
-            this_arg = parse_quote_spanned! {span=>
-                &self
-            };
-            CustomDebugTrait {
-                trait_path: &trait_path,
-                fn_name: &fn_name,
-                this_arg: &this_arg,
-            }
-        }
-    };
-    let this_arg_name = match this_arg {
-        FnArg::Receiver(this_arg) => this_arg.self_token.to_token_stream(),
-        FnArg::Typed(this_arg) => match &*this_arg.pat {
-            syn::Pat::Ident(pat_ident) => pat_ident.ident.to_token_stream(),
-            _ => unreachable!(),
-        },
-    };
-    match &item_struct.fields {
-        Fields::Named(fields) => {
-            let field_idents = fields
-                .named
-                .iter()
-                .map(|v| v.ident.as_ref().expect("known to have field name"));
-            let field_names = field_idents.clone().map(|v| v.to_string());
-            quote_spanned! {span=>
-                #[automatically_derived]
-                impl #impl_generics #trait_path for #ident #type_generics
-                #where_clause
-                {
-                    fn #fn_name(#this_arg, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
-                        let _ = #this_arg_name;
-                        f.debug_struct(#debug_struct_name)
-                            #(.field(#field_names, &#this_arg_name.#field_idents))*
-                            .finish()
-                    }
-                }
-            }
-        }
-        Fields::Unnamed(fields) => {
-            let field_members = fields
-                .unnamed
-                .iter()
-                .enumerate()
-                .map(|(index, _)| syn::Index {
-                    index: index as _,
-                    span,
-                });
-            quote_spanned! {span=>
-                #[automatically_derived]
-                impl #impl_generics #trait_path for #ident #type_generics
-                #where_clause
-                {
-                    fn #fn_name(#this_arg, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
-                        let _ = #this_arg_name;
-                        f.debug_tuple(#debug_struct_name)
-                            #(.field(&#this_arg_name.#field_members))*
-                            .finish()
-                    }
-                }
-            }
-        }
-        Fields::Unit => quote_spanned! {ident.span()=>
-            #[automatically_derived]
-            impl #impl_generics #trait_path for #ident #type_generics
-            #where_clause
-            {
-                fn #fn_name(#this_arg, f: &mut ::fayalite::__std::fmt::Formatter<'_>) -> ::fayalite::__std::fmt::Result {
-                    let _ = #this_arg_name;
-                    f.write_str(#debug_struct_name)
-                }
-            }
-        },
-    }
-}
diff --git a/crates/fayalite-proc-macros-impl/src/lib.rs b/crates/fayalite-proc-macros-impl/src/lib.rs
index 905cb05..152053c 100644
--- a/crates/fayalite-proc-macros-impl/src/lib.rs
+++ b/crates/fayalite-proc-macros-impl/src/lib.rs
@@ -42,7 +42,6 @@ pub(crate) trait CustomToken:
 
 mod kw {
     pub(crate) use syn::token::Extern as extern_;
-    pub(crate) use syn::token::Type as type_;
 
     macro_rules! custom_keyword {
         ($kw:ident) => {
@@ -76,8 +75,6 @@ mod kw {
     custom_keyword!(cmp_eq);
     custom_keyword!(connect_inexact);
     custom_keyword!(custom_bounds);
-    custom_keyword!(custom_debug);
-    custom_keyword!(custom_sim_display);
     custom_keyword!(flip);
     custom_keyword!(get);
     custom_keyword!(hdl);
@@ -86,8 +83,6 @@ mod kw {
     custom_keyword!(input);
     custom_keyword!(instance);
     custom_keyword!(m);
-    custom_keyword!(mask_sim);
-    custom_keyword!(mask_type);
     custom_keyword!(memory);
     custom_keyword!(memory_array);
     custom_keyword!(memory_with_init);
diff --git a/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs b/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs
index 605f662..ca06c0b 100644
--- a/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs
+++ b/crates/fayalite-proc-macros-impl/src/module/transform_body/expand_match.rs
@@ -1096,9 +1096,11 @@ impl Visitor<'_> {
                 let (#(#bindings,)*) = {
                     type __MatchTy<T> = <T as ::fayalite::ty::Type>::SimValue;
                     let __match_value = #expr;
-                    // use method syntax to deduce what type to convert to
-                    let __match_value = ::fayalite::sim::value::match_sim_value::MatchSimValueHelper::new(__match_value)
-                        .__fayalite_match_sim_value();
+                    let __match_value = {
+                        use ::fayalite::sim::value::match_sim_value::*;
+                        // use method syntax to deduce the correct trait to call
+                        ::fayalite::sim::value::match_sim_value::MatchSimValueHelper::new(__match_value).__fayalite_match_sim_value()
+                    };
                     #let_token #pat #eq_token __match_value #semi_token
                     (#(#bindings_idents,)*)
                 };
@@ -1170,9 +1172,11 @@ impl Visitor<'_> {
                 {
                     type __MatchTy<T> = <T as ::fayalite::ty::Type>::SimValue;
                     let __match_value = #expr;
-                    // use method syntax to deduce what type to convert to
-                    let __match_value = ::fayalite::sim::value::match_sim_value::MatchSimValueHelper::new(__match_value)
-                        .__fayalite_match_sim_value();
+                    let __match_value = {
+                        use ::fayalite::sim::value::match_sim_value::*;
+                        // use method syntax to deduce the correct trait to call
+                        ::fayalite::sim::value::match_sim_value::MatchSimValueHelper::new(__match_value).__fayalite_match_sim_value()
+                    };
                     #match_token __match_value {
                         #(#arms)*
                     }
diff --git a/crates/fayalite/src/_docs/modules/module_bodies/hdl_let_statements/destructuring.rs b/crates/fayalite/src/_docs/modules/module_bodies/hdl_let_statements/destructuring.rs
index 065e5de..8d70d21 100644
--- a/crates/fayalite/src/_docs/modules/module_bodies/hdl_let_statements/destructuring.rs
+++ b/crates/fayalite/src/_docs/modules/module_bodies/hdl_let_statements/destructuring.rs
@@ -95,11 +95,11 @@
 //! }
 //!
 //! #[hdl]
-//! fn destructure_inner<T: Type>(v: <MyStruct<T> as Type>::SimValue) {
+//! fn destructure_to_sim_value<'a, T: Type>(v: impl ToSimValue<Type = MyStruct<T>>) {
 //!     #[hdl(sim)]
 //!     let MyStruct::<T> {
 //!         a,
-//!         mut b,
+//!         b,
 //!         c,
 //!     } = v;
 //!
@@ -107,38 +107,5 @@
 //!     let _: SimValue<UInt<8>> = a;
 //!     let _: SimValue<Bool> = b;
 //!     let _: SimValue<T> = c;
-//!     *b = false; // can modify b since mut was used
-//! }
-//!
-//! #[hdl]
-//! fn destructure_inner_ref<'a, T: Type>(v: &'a <MyStruct<T> as Type>::SimValue) {
-//!     #[hdl(sim)]
-//!     let MyStruct::<T> {
-//!         a,
-//!         b,
-//!         c,
-//!     } = v;
-//!
-//!     // that gives these types:
-//!     let _: &'a SimValue<UInt<8>> = a;
-//!     let _: &'a SimValue<Bool> = b;
-//!     let _: &'a SimValue<T> = c;
-//! }
-//!
-//! #[hdl]
-//! fn destructure_inner_mut<'a, T: Type>(v: &'a mut <MyStruct<T> as Type>::SimValue) {
-//!     #[hdl(sim)]
-//!     let MyStruct::<T> {
-//!         a,
-//!         b,
-//!         c,
-//!     } = v;
-//!
-//!     **b = true; // you can modify v by modifying b which borrows from it
-//!
-//!     // that gives these types:
-//!     let _: &'a mut SimValue<UInt<8>> = a;
-//!     let _: &'a mut SimValue<Bool> = b;
-//!     let _: &'a mut SimValue<T> = c;
 //! }
 //! ```
diff --git a/crates/fayalite/src/_docs/modules/module_bodies/hdl_match_statements.rs b/crates/fayalite/src/_docs/modules/module_bodies/hdl_match_statements.rs
index 9e2d41d..accd3d7 100644
--- a/crates/fayalite/src/_docs/modules/module_bodies/hdl_match_statements.rs
+++ b/crates/fayalite/src/_docs/modules/module_bodies/hdl_match_statements.rs
@@ -72,47 +72,15 @@
 //! }
 //!
 //! #[hdl]
-//! fn match_inner_move<T: Type>(v: <MyEnum<T> as Type>::SimValue) -> String {
+//! fn match_to_sim_value<'a, T: Type>(v: impl ToSimValue<Type = MyEnum<T>>) {
 //!     #[hdl(sim)]
 //!     match v {
-//!         MyEnum::<T>::A => String::from("got A"),
-//!         MyEnum::<T>::B(mut b) => {
+//!         MyEnum::<T>::A => println!("got A"),
+//!         MyEnum::<T>::B(b) => {
 //!             let _: SimValue<Bool> = b; // b has this type
-//!             let text = format!("got B({b})");
-//!             *b = true; // can modify b since mut was used
-//!             text
-//!         }
-//!         _ => String::from("something else"),
-//!     }
-//! }
-//!
-//! #[hdl]
-//! fn match_inner_ref<'a, T: Type>(v: &'a <MyEnum<T> as Type>::SimValue) -> u32 {
-//!     #[hdl(sim)]
-//!     match v {
-//!         MyEnum::<T>::A => 1,
-//!         MyEnum::<T>::B(b) => {
-//!             let _: &'a SimValue<Bool> = b; // b has this type
 //!             println!("got B({b})");
-//!             5
 //!         }
-//!         _ => 42,
-//!     }
-//! }
-//!
-//! #[hdl]
-//! fn match_inner_mut<'a, T: Type>(v: &'a mut <MyEnum<T> as Type>::SimValue) -> Option<&'a mut SimValue<T>> {
-//!     #[hdl(sim)]
-//!     match v {
-//!         MyEnum::<T>::A => None,
-//!         MyEnum::<T>::B(b) => {
-//!             println!("got B({b})");
-//!             **b = true; // you can modify v by modifying b which borrows from it
-//!             let _: &'a mut SimValue<Bool> = b; // b has this type
-//!             None
-//!         }
-//!         MyEnum::<T>::C(v) => Some(v), // you can return matched values
-//!         _ => None, // HDL enums can have invalid discriminants, so we need this extra match arm
+//!         _ => println!("something else"),
 //!     }
 //! }
 //! ```
diff --git a/crates/fayalite/src/array.rs b/crates/fayalite/src/array.rs
index fa754fd..6ca6809 100644
--- a/crates/fayalite/src/array.rs
+++ b/crates/fayalite/src/array.rs
@@ -13,13 +13,13 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, MatchVariantWithoutScope, OpaqueSimValueSlice, OpaqueSimValueWriter,
-        OpaqueSimValueWritten, SimValueDebug, StaticType, Type, TypeProperties, TypeWithDeref,
+        OpaqueSimValueWritten, StaticType, Type, TypeProperties, TypeWithDeref,
         serde_impls::SerdeCanonicalType,
     },
     util::ConstUsize,
 };
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error};
-use std::{borrow::Cow, fmt, iter::FusedIterator, ops::Index};
+use std::{borrow::Cow, iter::FusedIterator, ops::Index};
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub struct ArrayType<T: Type = CanonicalType, Len: Size = DynSize> {
@@ -28,8 +28,8 @@ pub struct ArrayType<T: Type = CanonicalType, Len: Size = DynSize> {
     type_properties: TypeProperties,
 }
 
-impl<T: Type, Len: Size> fmt::Debug for ArrayType<T, Len> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl<T: Type, Len: Size> std::fmt::Debug for ArrayType<T, Len> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "Array<{:?}, {}>", self.element, self.len())
     }
 }
@@ -182,15 +182,6 @@ impl<T: Type + Visit<State>, Len: Size, State: Visitor + ?Sized> Visit<State>
     }
 }
 
-impl<T: Type, Len: Size> SimValueDebug for ArrayType<T, Len> {
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        fmt::Debug::fmt(value, f)
-    }
-}
-
 impl<T: Type, Len: Size> Type for ArrayType<T, Len> {
     type BaseType = Array;
     type MaskType = ArrayType<T::MaskType, Len>;
diff --git a/crates/fayalite/src/bundle.rs b/crates/fayalite/src/bundle.rs
index 5fad35c..1471f3a 100644
--- a/crates/fayalite/src/bundle.rs
+++ b/crates/fayalite/src/bundle.rs
@@ -14,8 +14,8 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, MatchVariantWithoutScope, OpaqueSimValue, OpaqueSimValueSize,
-        OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten, SimValueDebug,
-        StaticType, Type, TypeProperties, TypeWithDeref, impl_match_variant_as_self,
+        OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten, StaticType, Type,
+        TypeProperties, TypeWithDeref, impl_match_variant_as_self,
     },
     util::HashMap,
 };
@@ -271,15 +271,6 @@ impl Type for Bundle {
     }
 }
 
-impl SimValueDebug for Bundle {
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        fmt::Debug::fmt(value, f)
-    }
-}
-
 pub trait BundleType: Type<BaseType = Bundle> {
     type Builder: Default;
     fn fields(&self) -> Interned<[BundleField]>;
@@ -480,14 +471,6 @@ macro_rules! impl_tuples {
                 #[var($var)]
             })*]
         }
-        impl<$($T: Type,)*> SimValueDebug for ($($T,)*) {
-            fn sim_value_debug(
-                value: &<Self as Type>::SimValue,
-                f: &mut fmt::Formatter<'_>,
-            ) -> fmt::Result {
-                fmt::Debug::fmt(value, f)
-            }
-        }
         impl<$($T: Type,)*> Type for ($($T,)*) {
             type BaseType = Bundle;
             type MaskType = ($($T::MaskType,)*);
@@ -790,15 +773,6 @@ impl_tuples! {
     ]
 }
 
-impl<T: ?Sized + Send + Sync + 'static> SimValueDebug for PhantomData<T> {
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        fmt::Debug::fmt(value, f)
-    }
-}
-
 impl<T: ?Sized + Send + Sync + 'static> Type for PhantomData<T> {
     type BaseType = Bundle;
     type MaskType = ();
diff --git a/crates/fayalite/src/clock.rs b/crates/fayalite/src/clock.rs
index 0e6d145..168142b 100644
--- a/crates/fayalite/src/clock.rs
+++ b/crates/fayalite/src/clock.rs
@@ -1,6 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
-
 use crate::{
     expr::{Expr, ValueType},
     hdl,
@@ -10,12 +9,10 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSize, OpaqueSimValueSlice, OpaqueSimValueWriter,
-        OpaqueSimValueWritten, SimValueDebug, StaticType, Type, TypeProperties,
-        impl_match_variant_as_self,
+        OpaqueSimValueWritten, StaticType, Type, TypeProperties, impl_match_variant_as_self,
     },
 };
 use bitvec::{bits, order::Lsb0};
-use std::fmt;
 
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Default)]
 pub struct Clock;
@@ -72,15 +69,6 @@ impl Type for Clock {
     }
 }
 
-impl SimValueDebug for Clock {
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        fmt::Debug::fmt(value, f)
-    }
-}
-
 impl Clock {
     pub fn type_properties(self) -> TypeProperties {
         Self::TYPE_PROPERTIES
diff --git a/crates/fayalite/src/enum_.rs b/crates/fayalite/src/enum_.rs
index f6af578..a04f67a 100644
--- a/crates/fayalite/src/enum_.rs
+++ b/crates/fayalite/src/enum_.rs
@@ -2,7 +2,7 @@
 // See Notices.txt for copyright information
 
 use crate::{
-    expr::{Expr, ToExpr, ValueType, ops::VariantAccess},
+    expr::{Expr, HdlPartialEq, HdlPartialEqImpl, ToExpr, ValueType, ops::VariantAccess},
     hdl,
     int::{Bool, UIntValue},
     intern::{Intern, Interned},
@@ -10,18 +10,18 @@ use crate::{
         EnumMatchVariantAndInactiveScopeImpl, EnumMatchVariantsIterImpl, Scope, connect,
         enum_match_variants_helper, incomplete_wire, wire,
     },
-    sim::value::{SimValue, ToSimValue, ToSimValueWithType},
+    sim::value::SimValue,
     source_location::SourceLocation,
     ty::{
         CanonicalType, MatchVariantAndInactiveScope, OpaqueSimValue, OpaqueSimValueSize,
-        OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten, SimValueDebug,
-        StaticType, Type, TypeProperties,
+        OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten, StaticType, Type,
+        TypeProperties,
     },
     util::HashMap,
 };
 use bitvec::{order::Lsb0, slice::BitSlice, view::BitView};
 use serde::{Deserialize, Serialize};
-use std::{convert::Infallible, fmt, iter::FusedIterator, sync::Arc};
+use std::{borrow::Cow, convert::Infallible, fmt, iter::FusedIterator, sync::Arc};
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)]
 pub struct EnumVariant {
@@ -410,15 +410,6 @@ impl Type for Enum {
     }
 }
 
-impl SimValueDebug for Enum {
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        fmt::Debug::fmt(value, f)
-    }
-}
-
 #[derive(Clone, PartialEq, Eq, Hash, Debug, Default)]
 pub struct EnumPaddingSimValue {
     bits: Option<UIntValue>,
@@ -732,12 +723,95 @@ pub fn enum_type_to_sim_builder<T: EnumType>(v: T) -> T::SimBuilder {
     v.into()
 }
 
-#[hdl(cmp_eq)]
+#[hdl]
 pub enum HdlOption<T: Type> {
     HdlNone,
     HdlSome(T),
 }
 
+impl<Lhs: Type + HdlPartialEqImpl<Rhs>, Rhs: Type> HdlPartialEqImpl<HdlOption<Rhs>>
+    for HdlOption<Lhs>
+{
+    fn cmp_value_eq(
+        lhs: Self,
+        lhs_value: Cow<'_, Self::SimValue>,
+        rhs: HdlOption<Rhs>,
+        rhs_value: Cow<'_, <HdlOption<Rhs> as Type>::SimValue>,
+    ) -> bool {
+        type SimValueMatch<T> = <T as Type>::SimValue;
+        match (&*lhs_value, &*rhs_value) {
+            (SimValueMatch::<Self>::HdlNone(_), SimValueMatch::<HdlOption<Rhs>>::HdlNone(_)) => {
+                true
+            }
+            (SimValueMatch::<Self>::HdlSome(..), SimValueMatch::<HdlOption<Rhs>>::HdlNone(_))
+            | (SimValueMatch::<Self>::HdlNone(_), SimValueMatch::<HdlOption<Rhs>>::HdlSome(..)) => {
+                false
+            }
+            (
+                SimValueMatch::<Self>::HdlSome(l, _),
+                SimValueMatch::<HdlOption<Rhs>>::HdlSome(r, _),
+            ) => HdlPartialEqImpl::cmp_value_eq(
+                lhs.HdlSome,
+                Cow::Borrowed(&**l),
+                rhs.HdlSome,
+                Cow::Borrowed(&**r),
+            ),
+        }
+    }
+
+    #[hdl]
+    fn cmp_expr_eq(lhs: Expr<Self>, rhs: Expr<HdlOption<Rhs>>) -> Expr<Bool> {
+        #[hdl]
+        let cmp_eq = wire();
+        #[hdl]
+        match lhs {
+            HdlSome(lhs) =>
+            {
+                #[hdl]
+                match rhs {
+                    HdlSome(rhs) => connect(cmp_eq, lhs.cmp_eq(rhs)),
+                    HdlNone => connect(cmp_eq, false),
+                }
+            }
+            HdlNone =>
+            {
+                #[hdl]
+                match rhs {
+                    HdlSome(_) => connect(cmp_eq, false),
+                    HdlNone => connect(cmp_eq, true),
+                }
+            }
+        }
+        cmp_eq
+    }
+
+    #[hdl]
+    fn cmp_expr_ne(lhs: Expr<Self>, rhs: Expr<HdlOption<Rhs>>) -> Expr<Bool> {
+        #[hdl]
+        let cmp_ne = wire();
+        #[hdl]
+        match lhs {
+            HdlSome(lhs) =>
+            {
+                #[hdl]
+                match rhs {
+                    HdlSome(rhs) => connect(cmp_ne, lhs.cmp_ne(rhs)),
+                    HdlNone => connect(cmp_ne, true),
+                }
+            }
+            HdlNone =>
+            {
+                #[hdl]
+                match rhs {
+                    HdlSome(_) => connect(cmp_ne, true),
+                    HdlNone => connect(cmp_ne, false),
+                }
+            }
+        }
+        cmp_ne
+    }
+}
+
 #[allow(non_snake_case)]
 pub fn HdlNone<T: StaticType>() -> Expr<HdlOption<T>> {
     HdlOption[T::TYPE].HdlNone()
@@ -749,123 +823,6 @@ pub fn HdlSome<T: Type>(value: impl ToExpr<Type = T>) -> Expr<HdlOption<T>> {
     HdlOption[value.ty()].HdlSome(value)
 }
 
-impl<T: Type> From<SimValue<HdlOption<T>>> for Option<SimValue<T>> {
-    #[hdl]
-    fn from(value: SimValue<HdlOption<T>>) -> Self {
-        #[hdl(sim)]
-        match value {
-            HdlSome(v) => Some(v),
-            HdlNone => None,
-        }
-    }
-}
-
-impl<'a, T: Type> From<&'a SimValue<HdlOption<T>>> for Option<&'a SimValue<T>> {
-    #[hdl]
-    fn from(value: &'a SimValue<HdlOption<T>>) -> Self {
-        #[hdl(sim)]
-        match value {
-            HdlSome(v) => Some(v),
-            HdlNone => None,
-        }
-    }
-}
-
-impl<'a, T: Type> From<&'a mut SimValue<HdlOption<T>>> for Option<&'a mut SimValue<T>> {
-    #[hdl]
-    fn from(value: &'a mut SimValue<HdlOption<T>>) -> Self {
-        #[hdl(sim)]
-        match value {
-            HdlSome(v) => Some(v),
-            HdlNone => None,
-        }
-    }
-}
-
-impl<T: ValueType<Type: StaticType<MaskType: StaticType>>> ValueType for Option<T> {
-    type Type = HdlOption<T::Type>;
-    type ValueCategory = T::ValueCategory;
-
-    fn ty(&self) -> Self::Type {
-        StaticType::TYPE
-    }
-}
-
-impl<T: Type, V: ToSimValueWithType<T>> ToSimValueWithType<HdlOption<T>> for Option<V> {
-    #[hdl]
-    fn to_sim_value_with_type(&self, ty: HdlOption<T>) -> SimValue<HdlOption<T>> {
-        match self {
-            Some(v) =>
-            {
-                #[hdl(sim)]
-                ty.HdlSome(v)
-            }
-            None =>
-            {
-                #[hdl(sim)]
-                ty.HdlNone()
-            }
-        }
-    }
-    #[hdl]
-    fn into_sim_value_with_type(self, ty: HdlOption<T>) -> SimValue<HdlOption<T>> {
-        match self {
-            Some(v) =>
-            {
-                #[hdl(sim)]
-                ty.HdlSome(v)
-            }
-            None =>
-            {
-                #[hdl(sim)]
-                ty.HdlNone()
-            }
-        }
-    }
-}
-
-impl<T: ToSimValue<Type: StaticType<MaskType: StaticType>>> ToSimValue for Option<T> {
-    #[hdl]
-    fn to_sim_value(&self) -> SimValue<Self::Type> {
-        match self {
-            Some(v) =>
-            {
-                #[hdl(sim)]
-                HdlSome(v)
-            }
-            None =>
-            {
-                #[hdl(sim)]
-                HdlNone()
-            }
-        }
-    }
-    #[hdl]
-    fn into_sim_value(self) -> SimValue<Self::Type> {
-        match self {
-            Some(v) =>
-            {
-                #[hdl(sim)]
-                HdlSome(v)
-            }
-            None =>
-            {
-                #[hdl(sim)]
-                HdlNone()
-            }
-        }
-    }
-}
-
-impl<T: ToExpr<Type: StaticType<MaskType: StaticType>>> ToExpr for Option<T> {
-    fn to_expr(&self) -> Expr<Self::Type> {
-        match self {
-            Some(v) => HdlSome(v),
-            None => HdlNone(),
-        }
-    }
-}
-
 impl<T: Type> HdlOption<T> {
     #[track_caller]
     pub fn try_map<R: Type, E>(
diff --git a/crates/fayalite/src/int.rs b/crates/fayalite/src/int.rs
index ff20933..c461306 100644
--- a/crates/fayalite/src/int.rs
+++ b/crates/fayalite/src/int.rs
@@ -15,8 +15,8 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, FillInDefaultedGenerics, OpaqueSimValueSize, OpaqueSimValueSlice,
-        OpaqueSimValueWriter, OpaqueSimValueWritten, SimValueDebug, SimValueDisplay, StaticType,
-        Type, TypeProperties, impl_match_variant_as_self,
+        OpaqueSimValueWriter, OpaqueSimValueWritten, StaticType, Type, TypeProperties,
+        impl_match_variant_as_self,
     },
     util::{ConstBool, ConstUsize, GenericConstBool, GenericConstUsize, interned_bit, slice_range},
 };
@@ -1019,24 +1019,6 @@ macro_rules! impl_int {
             }
         }
 
-        impl<Width: Size> SimValueDebug for $name<Width> {
-            fn sim_value_debug(
-                value: &<Self as Type>::SimValue,
-                f: &mut fmt::Formatter<'_>,
-            ) -> fmt::Result {
-                fmt::Debug::fmt(value, f)
-            }
-        }
-
-        impl<Width: Size> SimValueDisplay for $name<Width> {
-            fn sim_value_display(
-                value: &<Self as Type>::SimValue,
-                f: &mut fmt::Formatter<'_>,
-            ) -> fmt::Result {
-                fmt::Display::fmt(value, f)
-            }
-        }
-
         impl<Width: KnownSize> Default for $name<Width> {
             fn default() -> Self {
                 Self::TYPE
@@ -1917,15 +1899,6 @@ impl Type for Bool {
     }
 }
 
-impl SimValueDebug for Bool {
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        fmt::Debug::fmt(value, f)
-    }
-}
-
 impl StaticType for Bool {
     const TYPE: Self = Bool;
     const MASK_TYPE: Self::MaskType = Bool;
diff --git a/crates/fayalite/src/int/uint_in_range.rs b/crates/fayalite/src/int/uint_in_range.rs
index edf2e25..acf2fec 100644
--- a/crates/fayalite/src/int/uint_in_range.rs
+++ b/crates/fayalite/src/int/uint_in_range.rs
@@ -14,7 +14,7 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten,
-        SimValueDebug, StaticType, Type, TypeProperties, impl_match_variant_as_self,
+        StaticType, Type, TypeProperties, impl_match_variant_as_self,
     },
 };
 use bitvec::{order::Lsb0, view::BitView};
@@ -94,15 +94,6 @@ impl Type for UIntInRangeMaskType {
     }
 }
 
-impl SimValueDebug for UIntInRangeMaskType {
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        fmt::Debug::fmt(value, f)
-    }
-}
-
 impl BundleType for UIntInRangeMaskType {
     type Builder = NoBuilder;
 
@@ -348,15 +339,6 @@ macro_rules! define_uint_in_range_type {
             }
         }
 
-        impl<Start: Size, End: Size> SimValueDebug for $UIntInRangeType<Start, End> {
-            fn sim_value_debug(
-                value: &<Self as Type>::SimValue,
-                f: &mut fmt::Formatter<'_>,
-            ) -> fmt::Result {
-                fmt::Debug::fmt(value, f)
-            }
-        }
-
         impl<Start: Size, End: Size> fmt::Debug for $UIntInRangeType<Start, End> {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                 let Self { value, range } = self;
diff --git a/crates/fayalite/src/phantom_const.rs b/crates/fayalite/src/phantom_const.rs
index ba85817..fb7be6f 100644
--- a/crates/fayalite/src/phantom_const.rs
+++ b/crates/fayalite/src/phantom_const.rs
@@ -9,7 +9,7 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSlice, OpaqueSimValueWriter, OpaqueSimValueWritten,
-        SimValueDebug, StaticType, Type, TypeProperties, impl_match_variant_as_self,
+        StaticType, Type, TypeProperties, impl_match_variant_as_self,
         serde_impls::{SerdeCanonicalType, SerdePhantomConst},
     },
 };
@@ -327,15 +327,6 @@ impl<T: ?Sized + PhantomConstValue> Type for PhantomConst<T> {
     }
 }
 
-impl<T: ?Sized + PhantomConstValue> SimValueDebug for PhantomConst<T> {
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        fmt::Debug::fmt(value, f)
-    }
-}
-
 impl<T: ?Sized + PhantomConstValue> Default for PhantomConst<T>
 where
     Interned<T>: Default,
diff --git a/crates/fayalite/src/reset.rs b/crates/fayalite/src/reset.rs
index ddc3651..13273ac 100644
--- a/crates/fayalite/src/reset.rs
+++ b/crates/fayalite/src/reset.rs
@@ -1,6 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
-
 use crate::{
     clock::Clock,
     expr::{CastToImpl, Expr, ValueType},
@@ -9,13 +8,11 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSize, OpaqueSimValueSlice, OpaqueSimValueWriter,
-        OpaqueSimValueWritten, SimValueDebug, StaticType, Type, TypeProperties,
-        impl_match_variant_as_self,
+        OpaqueSimValueWritten, StaticType, Type, TypeProperties, impl_match_variant_as_self,
     },
     util::ConstUsize,
 };
 use bitvec::{bits, order::Lsb0};
-use std::fmt;
 
 mod sealed {
     pub trait ResetTypeSealed {}
@@ -103,15 +100,6 @@ macro_rules! reset_type {
             }
         }
 
-        impl SimValueDebug for $name {
-            fn sim_value_debug(
-                value: &<Self as Type>::SimValue,
-                f: &mut fmt::Formatter<'_>,
-            ) -> fmt::Result {
-                fmt::Debug::fmt(value, f)
-            }
-        }
-
         impl $name {
             pub fn type_properties(self) -> TypeProperties {
                 Self::TYPE_PROPERTIES
diff --git a/crates/fayalite/src/sim.rs b/crates/fayalite/src/sim.rs
index 4a7721b..45691ea 100644
--- a/crates/fayalite/src/sim.rs
+++ b/crates/fayalite/src/sim.rs
@@ -828,7 +828,6 @@ where
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub(crate) struct SimTrace<K, S> {
     kind: K,
-    maybe_changed: bool,
     state: S,
     last_state: S,
 }
@@ -849,14 +848,12 @@ 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()
@@ -867,14 +864,12 @@ 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()
@@ -2083,12 +2078,10 @@ 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(),
                 },
@@ -2133,16 +2126,13 @@ impl SimulationImpl {
             id,
             &SimTrace {
                 kind,
-                maybe_changed,
                 ref state,
                 ref last_state,
             },
         ) in self.traces.0.iter().enumerate()
         {
-            if ONLY_IF_CHANGED {
-                if !(maybe_changed && state != last_state) {
-                    continue;
-                }
+            if ONLY_IF_CHANGED && state == last_state {
+                continue;
             }
             let id = TraceScalarId(id);
             match kind {
@@ -2203,45 +2193,10 @@ 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_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_maybe_modified_flag(index),
-                SimTraceKind::SimOnly { index, ty: _ } => self
-                    .state
-                    .sim_only_slots
-                    .state_index_fetch_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);
             }
@@ -2291,7 +2246,6 @@ impl SimulationImpl {
                 last_state.clone_from(state);
             }
         }
-        self.state.clear_all_maybe_modified_flags();
     }
     #[track_caller]
     fn advance_time(this_ref: &Rc<RefCell<Self>>, duration: SimDuration) {
diff --git a/crates/fayalite/src/sim/compiler.rs b/crates/fayalite/src/sim/compiler.rs
index dbdbffb..e85ff0f 100644
--- a/crates/fayalite/src/sim/compiler.rs
+++ b/crates/fayalite/src/sim/compiler.rs
@@ -2234,7 +2234,6 @@ 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 e16519b..2b121b5 100644
--- a/crates/fayalite/src/sim/interpreter.rs
+++ b/crates/fayalite/src/sim/interpreter.rs
@@ -17,11 +17,12 @@ 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, Index, IndexMut},
+    ops::{ControlFlow, Deref, DerefMut, Index, IndexMut},
 };
 use vec_map::VecMap;
 
@@ -914,15 +915,6 @@ impl<K: StatePartKind> StatePart<K> {
             value: K::borrow_state(&mut self.value),
         }
     }
-    pub(crate) fn state_index_fetch_maybe_modified_flag(
-        &self,
-        part_index: StatePartIndex<K>,
-    ) -> bool {
-        K::state_index_fetch_maybe_modified_flag(&self.value, part_index)
-    }
-    pub(crate) fn clear_all_maybe_modified_flags(&mut self) {
-        K::clear_all_maybe_modified_flags(&mut self.value)
-    }
 }
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
@@ -930,38 +922,56 @@ pub(crate) struct BorrowedStatePart<'a, K: StatePartKind> {
     pub(crate) value: K::BorrowedState<'a>,
 }
 
-impl<K: StatePartKind> BorrowedStatePart<'_, K> {
+impl<
+    'a,
+    K: StatePartKind<
+        BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T> + BorrowMut<[T]>>,
+    >,
+    T,
+> BorrowedStatePart<'a, K>
+{
     pub(crate) fn get_disjoint_mut<const N: usize>(
         &mut self,
         indexes: [StatePartIndex<K>; N],
-    ) -> [&mut K::StateElement; N] {
-        K::borrowed_state_get_disjoint_mut(&mut self.value, indexes)
+    ) -> [&mut T; N] {
+        (*self.value)
+            .borrow_mut()
+            .get_disjoint_mut(indexes.map(|v| v.value as usize))
+            .expect("indexes are disjoint")
     }
 }
 
-impl<K: StatePartKind> Index<StatePartIndex<K>> for StatePart<K> {
-    type Output = K::StateElement;
+impl<K: StatePartKind<State: Deref<Target: Index<usize, Output = T>>>, T> Index<StatePartIndex<K>>
+    for StatePart<K>
+{
+    type Output = T;
     fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
-        K::state_index(&self.value, index)
+        &self.value[index.value as usize]
     }
 }
 
-impl<K: StatePartKind> IndexMut<StatePartIndex<K>> for StatePart<K> {
+impl<K: StatePartKind<State: DerefMut<Target: IndexMut<usize, Output = T>>>, T>
+    IndexMut<StatePartIndex<K>> for StatePart<K>
+{
     fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
-        K::state_index_mut(&mut self.value, index)
+        &mut self.value[index.value as usize]
     }
 }
 
-impl<K: StatePartKind> Index<StatePartIndex<K>> for BorrowedStatePart<'_, K> {
-    type Output = K::StateElement;
+impl<'a, K: StatePartKind<BorrowedState<'a>: Deref<Target: Index<usize, Output = T>>>, T>
+    Index<StatePartIndex<K>> for BorrowedStatePart<'a, K>
+{
+    type Output = T;
     fn index(&self, index: StatePartIndex<K>) -> &Self::Output {
-        K::borrowed_state_index(&self.value, index)
+        &self.value[index.value as usize]
     }
 }
 
-impl<K: StatePartKind> IndexMut<StatePartIndex<K>> for BorrowedStatePart<'_, K> {
+impl<'a, K: StatePartKind<BorrowedState<'a>: DerefMut<Target: IndexMut<usize, Output = T>>>, T>
+    IndexMut<StatePartIndex<K>> for BorrowedStatePart<'a, K>
+{
     fn index_mut(&mut self, index: StatePartIndex<K>) -> &mut Self::Output {
-        K::borrowed_state_index_mut(&mut self.value, index)
+        &mut self.value[index.value as usize]
     }
 }
 
@@ -1018,10 +1028,6 @@ macro_rules! make_state {
                     $($type_plural_field: self.$type_plural_field.borrow(),)*
                 }
             }
-            pub(crate) fn clear_all_maybe_modified_flags(&mut self) {
-                $(self.$state_plural_field.clear_all_maybe_modified_flags();)*
-                $(self.$type_plural_field.clear_all_maybe_modified_flags();)*
-            }
         }
 
         #[derive(Debug)]
diff --git a/crates/fayalite/src/sim/interpreter/parts.rs b/crates/fayalite/src/sim/interpreter/parts.rs
index 308ac44..75427c9 100644
--- a/crates/fayalite/src/sim/interpreter/parts.rs
+++ b/crates/fayalite/src/sim/interpreter/parts.rs
@@ -236,7 +236,6 @@ 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>(
@@ -248,31 +247,6 @@ 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_maybe_modified_flag(
-        state: &Self::State,
-        part_index: StatePartIndex<Self>,
-    ) -> bool;
-    fn clear_all_maybe_modified_flags(state: &mut Self::State);
-    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 {
@@ -298,7 +272,6 @@ 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()
@@ -324,89 +297,19 @@ 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_maybe_modified_flag(
-        _state: &Self::State,
-        _part_index: StatePartIndex<Self>,
-    ) -> bool {
-        true
-    }
-    fn clear_all_maybe_modified_flags(_state: &mut Self::State) {}
-    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 = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
-    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
-    type StateElement = SmallUInt;
+    type State = Box<[SmallUInt]>;
+    type BorrowedState<'a> = &'a mut [SmallUInt];
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        StateAndModified {
-            state: vec![0; layout_data.len()].into_boxed_slice(),
-            modified: vec![false; layout_data.len()].into_boxed_slice(),
-        }
+        vec![0; layout_data.len()].into_boxed_slice()
     }
     fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
-        let StateAndModified { state, modified } = state;
-        StateAndModified { state, modified }
+        state
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -427,72 +330,19 @@ 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_maybe_modified_flag(
-        state: &Self::State,
-        part_index: StatePartIndex<Self>,
-    ) -> bool {
-        state.modified[part_index.as_usize()]
-    }
-    fn clear_all_maybe_modified_flags(state: &mut Self::State) {
-        state.modified.fill(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 = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
-    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
-    type StateElement = BigInt;
+    type State = Box<[BigInt]>;
+    type BorrowedState<'a> = &'a mut [BigInt];
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        let state: Box<[_]> = layout_data.iter().map(|_| BigInt::default()).collect();
-        StateAndModified {
-            modified: vec![false; state.len()].into_boxed_slice(),
-            state,
-        }
+        layout_data.iter().map(|_| BigInt::default()).collect()
     }
     fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
-        let StateAndModified { state, modified } = state;
-        StateAndModified { state, modified }
+        state
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -511,72 +361,19 @@ 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_maybe_modified_flag(
-        state: &Self::State,
-        part_index: StatePartIndex<Self>,
-    ) -> bool {
-        state.modified[part_index.as_usize()]
-    }
-    fn clear_all_maybe_modified_flags(state: &mut Self::State) {
-        state.modified.fill(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 = StateAndModified<Box<[Self::StateElement]>, Box<[bool]>>;
-    type BorrowedState<'a> = StateAndModified<&'a mut [Self::StateElement], &'a mut [bool]>;
-    type StateElement = DynSimOnlyValue;
+    type State = Box<[DynSimOnlyValue]>;
+    type BorrowedState<'a> = &'a mut [DynSimOnlyValue];
     fn new_state(layout_data: &[Self::LayoutData]) -> Self::State {
-        let state: Box<[_]> = layout_data.iter().map(|ty| ty.default_value()).collect();
-        StateAndModified {
-            modified: vec![false; state.len()].into_boxed_slice(),
-            state,
-        }
+        layout_data.iter().map(|ty| ty.default_value()).collect()
     }
     fn borrow_state<'a>(state: &'a mut Self::State) -> Self::BorrowedState<'a> {
-        let StateAndModified { state, modified } = state;
-        StateAndModified { state, modified }
+        state
     }
     fn part_debug_data<BK: InsnsBuildingKind>(
         state_layout: &StateLayout<BK>,
@@ -595,53 +392,6 @@ 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_maybe_modified_flag(
-        state: &Self::State,
-        part_index: StatePartIndex<Self>,
-    ) -> bool {
-        state.modified[part_index.as_usize()]
-    }
-    fn clear_all_maybe_modified_flags(state: &mut Self::State) {
-        state.modified.fill(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/src/sim/value.rs b/crates/fayalite/src/sim/value.rs
index eaa3f8d..b6a4e4b 100644
--- a/crates/fayalite/src/sim/value.rs
+++ b/crates/fayalite/src/sim/value.rs
@@ -15,8 +15,7 @@ use crate::{
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValue, OpaqueSimValueSize, OpaqueSimValueSlice,
-        OpaqueSimValueWriter, SimValueDebug, StaticType, Type, TypeProperties,
-        impl_match_variant_as_self,
+        OpaqueSimValueWriter, StaticType, Type, TypeProperties, impl_match_variant_as_self,
     },
     util::{
         ConstUsize, HashMap,
@@ -552,119 +551,113 @@ impl_sim_value_cmp_as_bool!(AsyncReset);
 
 #[doc(hidden)]
 pub mod match_sim_value {
-    use crate::{sim::value::SimValue, ty::Type};
-    use std::ops::{Deref, DerefMut};
-
-    macro_rules! wrapper {
-        (
-            $(pub struct $wrapper:ident<$T:ident>($inner:ty);)*
-        ) => {
-            $(#[doc(hidden)]
-            pub struct $wrapper<$T>($inner);
-
-            impl<$T> $wrapper<$T> {
-                #[inline(always)]
-                pub fn new(value: $T) -> Self {
-                    Self(<$inner>::new(value))
-                }
-            }
-
-            impl<$T> Deref for $wrapper<$T> {
-                type Target = $inner;
-
-                #[inline(always)]
-                fn deref(&self) -> &Self::Target {
-                    &self.0
-                }
-            }
-
-            impl<$T> DerefMut for $wrapper<$T> {
-                #[inline(always)]
-                fn deref_mut(&mut self) -> &mut Self::Target {
-                    &mut self.0
-                }
-            })*
-        };
-    }
-
-    wrapper! {
-        pub struct MatchSimValueHelperCheckSimValue<T>(MatchSimValueHelperCheckMutSimValue<T>);
-        pub struct MatchSimValueHelperCheckMutSimValue<T>(MatchSimValueHelperCheckRefSimValue<T>);
-        pub struct MatchSimValueHelperCheckRefSimValue<T>(MatchSimValueHelperCheckRefRefSimValue<T>);
-        pub struct MatchSimValueHelperCheckRefRefSimValue<T>(MatchSimValueHelperCheckRefMutSimValue<T>);
-        pub struct MatchSimValueHelperCheckRefMutSimValue<T>(MatchSimValueHelperCheckMutRefSimValue<T>);
-        pub struct MatchSimValueHelperCheckMutRefSimValue<T>(MatchSimValueHelperCheckMutMutSimValue<T>);
-        pub struct MatchSimValueHelperCheckMutMutSimValue<T>(MatchSimValueHelperIdentity<T>);
-    }
-
-    impl<T: Type> MatchSimValueHelperCheckSimValue<SimValue<T>> {
-        #[inline(always)]
-        pub fn __fayalite_match_sim_value(&mut self) -> T::SimValue {
-            SimValue::into_value(self.take())
-        }
-    }
-
-    impl<'a, T: Type> MatchSimValueHelperCheckMutSimValue<&'a mut SimValue<T>> {
-        #[inline(always)]
-        pub fn __fayalite_match_sim_value(&mut self) -> &'a mut T::SimValue {
-            self.take()
-        }
-    }
-
-    impl<'a, T: Type> MatchSimValueHelperCheckRefSimValue<&'a SimValue<T>> {
-        #[inline(always)]
-        pub fn __fayalite_match_sim_value(&mut self) -> &'a T::SimValue {
-            self.take()
-        }
-    }
-
-    impl<'a, 'b, T: Type> MatchSimValueHelperCheckRefRefSimValue<&'a &'b SimValue<T>> {
-        #[inline(always)]
-        pub fn __fayalite_match_sim_value(&mut self) -> &'b T::SimValue {
-            self.take()
-        }
-    }
-
-    impl<'a, 'b, T: Type> MatchSimValueHelperCheckRefMutSimValue<&'a &'b mut SimValue<T>> {
-        #[inline(always)]
-        pub fn __fayalite_match_sim_value(&mut self) -> &'a T::SimValue {
-            self.take()
-        }
-    }
-
-    impl<'a, 'b, T: Type> MatchSimValueHelperCheckMutRefSimValue<&'a mut &'b SimValue<T>> {
-        #[inline(always)]
-        pub fn __fayalite_match_sim_value(&mut self) -> &'b T::SimValue {
-            self.take()
-        }
-    }
-
-    impl<'a, 'b, T: Type> MatchSimValueHelperCheckMutMutSimValue<&'a mut &'b mut SimValue<T>> {
-        #[inline(always)]
-        pub fn __fayalite_match_sim_value(&mut self) -> &'a mut T::SimValue {
-            self.take()
-        }
-    }
+    use crate::{
+        sim::value::{SimValue, ToSimValue},
+        ty::Type,
+    };
 
     #[doc(hidden)]
-    pub struct MatchSimValueHelperIdentity<T>(Option<T>);
+    pub struct MatchSimValueHelper<T>(Option<T>);
 
-    impl<T> MatchSimValueHelperIdentity<T> {
-        fn new(v: T) -> Self {
+    impl<T> MatchSimValueHelper<T> {
+        pub fn new(v: T) -> Self {
             Self(Some(v))
         }
-        #[inline(always)]
-        fn take(&mut self) -> T {
-            self.0.take().expect("known to be Some")
+    }
+
+    #[doc(hidden)]
+    pub trait MatchSimValue {
+        type MatchValue;
+
+        /// use `self` so it comes first in the method resolution order
+        fn __fayalite_match_sim_value(self) -> Self::MatchValue
+        where
+            Self: Sized;
+    }
+
+    impl<T: Type> MatchSimValue for MatchSimValueHelper<SimValue<T>> {
+        type MatchValue = T::SimValue;
+
+        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
+            SimValue::into_value(self.0.expect("should be Some"))
         }
-        #[inline(always)]
-        pub fn __fayalite_match_sim_value(&mut self) -> T {
-            self.take()
+    }
+
+    impl<'a, T: Type> MatchSimValue for MatchSimValueHelper<&'a SimValue<T>> {
+        type MatchValue = &'a T::SimValue;
+
+        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
+            SimValue::value(self.0.expect("should be Some"))
+        }
+    }
+
+    impl<'a, T: Type> MatchSimValue for MatchSimValueHelper<&'a mut SimValue<T>> {
+        type MatchValue = &'a mut T::SimValue;
+
+        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
+            SimValue::value_mut(self.0.expect("should be Some"))
+        }
+    }
+
+    impl<'a, T> MatchSimValue for MatchSimValueHelper<&'_ &'a T>
+    where
+        MatchSimValueHelper<&'a T>: MatchSimValue,
+    {
+        type MatchValue = <MatchSimValueHelper<&'a T> as MatchSimValue>::MatchValue;
+
+        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
+            MatchSimValue::__fayalite_match_sim_value(MatchSimValueHelper(self.0.map(|v| *v)))
+        }
+    }
+
+    impl<'a, T> MatchSimValue for MatchSimValueHelper<&'_ mut &'a T>
+    where
+        MatchSimValueHelper<&'a T>: MatchSimValue,
+    {
+        type MatchValue = <MatchSimValueHelper<&'a T> as MatchSimValue>::MatchValue;
+
+        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
+            MatchSimValue::__fayalite_match_sim_value(MatchSimValueHelper(self.0.map(|v| *v)))
+        }
+    }
+
+    impl<'a, T> MatchSimValue for MatchSimValueHelper<&'a &'_ mut T>
+    where
+        MatchSimValueHelper<&'a T>: MatchSimValue,
+    {
+        type MatchValue = <MatchSimValueHelper<&'a T> as MatchSimValue>::MatchValue;
+
+        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
+            MatchSimValue::__fayalite_match_sim_value(MatchSimValueHelper(self.0.map(|v| &**v)))
+        }
+    }
+
+    impl<'a, T> MatchSimValue for MatchSimValueHelper<&'a mut &'_ mut T>
+    where
+        MatchSimValueHelper<&'a mut T>: MatchSimValue,
+    {
+        type MatchValue = <MatchSimValueHelper<&'a mut T> as MatchSimValue>::MatchValue;
+
+        fn __fayalite_match_sim_value(self) -> Self::MatchValue {
+            MatchSimValue::__fayalite_match_sim_value(MatchSimValueHelper(self.0.map(|v| &mut **v)))
         }
     }
 
     #[doc(hidden)]
-    pub type MatchSimValueHelper<T> = MatchSimValueHelperCheckSimValue<T>;
+    pub trait MatchSimValueFallback {
+        type MatchValue;
+
+        /// use `&mut self` so it comes later in the method resolution order than MatchSimValue
+        fn __fayalite_match_sim_value(&mut self) -> Self::MatchValue;
+    }
+
+    impl<T: ToSimValue> MatchSimValueFallback for MatchSimValueHelper<T> {
+        type MatchValue = <T::Type as Type>::SimValue;
+
+        fn __fayalite_match_sim_value(&mut self) -> Self::MatchValue {
+            SimValue::into_value(self.0.take().expect("should be Some").into_sim_value())
+        }
+    }
 }
 
 pub trait ToSimValue: ToSimValueWithType<<Self as ValueType>::Type> + ValueType {
@@ -1401,15 +1394,6 @@ impl Type for DynSimOnly {
     }
 }
 
-impl SimValueDebug for DynSimOnly {
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        fmt::Debug::fmt(value, f)
-    }
-}
-
 impl<T: SimOnlyValueTrait> Type for SimOnly<T> {
     type BaseType = DynSimOnly;
     type MaskType = Bool;
@@ -1475,15 +1459,6 @@ impl<T: SimOnlyValueTrait> Type for SimOnly<T> {
     }
 }
 
-impl<T: SimOnlyValueTrait> SimValueDebug for SimOnly<T> {
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        fmt::Debug::fmt(value, f)
-    }
-}
-
 impl<T: SimOnlyValueTrait> StaticType for SimOnly<T> {
     const TYPE: Self = Self::new();
 
diff --git a/crates/fayalite/src/ty.rs b/crates/fayalite/src/ty.rs
index ed0ba03..76c0955 100644
--- a/crates/fayalite/src/ty.rs
+++ b/crates/fayalite/src/ty.rs
@@ -367,15 +367,7 @@ impl<D: Type> TypeOrDefault<D> for crate::__ {
 }
 
 pub trait Type:
-    Copy
-    + Hash
-    + Eq
-    + fmt::Debug
-    + Send
-    + Sync
-    + 'static
-    + FillInDefaultedGenerics<Type = Self>
-    + SimValueDebug
+    Copy + Hash + Eq + fmt::Debug + Send + Sync + 'static + FillInDefaultedGenerics<Type = Self>
 {
     type BaseType: BaseType;
     type MaskType: Type<MaskType = Self::MaskType>;
@@ -410,16 +402,6 @@ pub trait Type:
     ) -> OpaqueSimValueWritten<'w>;
 }
 
-pub trait SimValueDebug {
-    fn sim_value_debug(value: &<Self as Type>::SimValue, f: &mut fmt::Formatter<'_>) -> fmt::Result
-    where
-        Self: Type;
-}
-
-pub trait SimValueDisplay: Type {
-    fn sim_value_display(value: &Self::SimValue, f: &mut fmt::Formatter<'_>) -> fmt::Result;
-}
-
 pub trait BaseType:
     Type<
         BaseType = Self,
@@ -508,15 +490,6 @@ impl Type for CanonicalType {
     }
 }
 
-impl SimValueDebug for CanonicalType {
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        fmt::Debug::fmt(value, f)
-    }
-}
-
 #[derive(Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize, Default)]
 #[non_exhaustive]
 pub struct OpaqueSimValueSizeRange {
diff --git a/crates/fayalite/tests/hdl_types_fmt.rs b/crates/fayalite/tests/hdl_types_fmt.rs
deleted file mode 100644
index 382f64d..0000000
--- a/crates/fayalite/tests/hdl_types_fmt.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// See Notices.txt for copyright information
-use fayalite::{prelude::*, ty::SimValueDebug};
-use std::fmt;
-
-#[hdl(outline_generated)]
-struct MyStruct0<T, S: Size> {
-    v: T,
-    a: ArrayType<UInt<8>, S>,
-}
-
-#[hdl]
-#[test]
-fn check_my_struct0() {
-    let ty = MyStruct0[UInt[8]][3];
-    assert_eq!(
-        format!("{ty:?}"),
-        "MyStruct0 { v: UInt<8>, a: Array<UInt<8>, 3> }",
-    );
-    assert_eq!(
-        format!("{:?}", ty.mask_type()),
-        "MaskType<MyStruct0> { v: Bool, a: Array<Bool, 3> }",
-    );
-    let v = #[hdl(sim)]
-    MyStruct0::<_, _> {
-        v: 0x23u8,
-        a: [1u8, 2, 3],
-    };
-    assert_eq!(
-        format!("{v:?}"),
-        "MyStruct0 { v: 0x23_u8, a: [0x1_u8, 0x2_u8, 0x3_u8] }",
-    );
-}
-
-#[hdl(outline_generated, custom_debug())]
-struct MyStruct1<T, S: Size> {
-    v: T,
-    a: ArrayType<UInt<8>, S>,
-}
-
-impl<T: Type, S: Size> fmt::Debug for MyStruct1<T, S> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { v, a } = self;
-        f.debug_struct("Custom<MyStruct1>")
-            .field("v", v)
-            .field("a", a)
-            .finish()
-    }
-}
-
-impl<T: Type, S: Size> SimValueDebug for MyStruct1<T, S> {
-    #[hdl]
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        #[hdl(sim)]
-        let Self { v, a } = value;
-        f.debug_struct("Custom<MyStruct1>")
-            .field("v", &v)
-            .field("a", &a)
-            .finish()
-    }
-}
-
-#[hdl]
-#[test]
-fn check_my_struct1() {
-    let ty = MyStruct1[UInt[8]][3];
-    assert_eq!(
-        format!("{ty:?}"),
-        "Custom<MyStruct1> { v: UInt<8>, a: Array<UInt<8>, 3> }",
-    );
-    assert_eq!(
-        format!("{:?}", ty.mask_type()),
-        "MaskType<MyStruct1> { v: Bool, a: Array<Bool, 3> }",
-    );
-    let v = #[hdl(sim)]
-    MyStruct1::<_, _> {
-        v: 0x23u8,
-        a: [1u8, 2, 3],
-    };
-    assert_eq!(
-        format!("{v:?}"),
-        "Custom<MyStruct1> { v: 0x23_u8, a: [0x1_u8, 0x2_u8, 0x3_u8] }",
-    );
-}
-
-#[hdl(outline_generated)]
-enum MyEnum0<T, S: Size> {
-    Unit,
-    V(T),
-    A(ArrayType<UInt<8>, S>),
-}
-
-#[hdl]
-#[test]
-fn check_my_enum0() {
-    let ty = MyEnum0[UInt[8]][3];
-    assert_eq!(
-        format!("{ty:?}"),
-        "MyEnum0 { Unit: (), V: UInt<8>, A: Array<UInt<8>, 3> }",
-    );
-    let v = #[hdl(sim)]
-    ty.Unit();
-    assert_eq!(format!("{v:?}"), "Unit");
-    let v = #[hdl(sim)]
-    ty.V(0x23u8);
-    assert_eq!(format!("{v:?}"), "V(0x23_u8)");
-    let v = #[hdl(sim)]
-    ty.A([1u8, 2, 3]);
-    assert_eq!(format!("{v:?}"), "A([0x1_u8, 0x2_u8, 0x3_u8])");
-}
-
-#[hdl(outline_generated, custom_debug())]
-enum MyEnum1<T, S: Size> {
-    Unit,
-    V(T),
-    A(ArrayType<UInt<8>, S>),
-}
-
-impl<T: Type, S: Size> fmt::Debug for MyEnum1<T, S> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { Unit, V, A } = self;
-        f.debug_struct("Custom<MyEnum1>")
-            .field("Unit", Unit)
-            .field("V", V)
-            .field("A", A)
-            .finish()
-    }
-}
-
-impl<T: Type, S: Size> SimValueDebug for MyEnum1<T, S> {
-    #[hdl]
-    fn sim_value_debug(
-        value: &<Self as Type>::SimValue,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        type SimValueT<T> = <T as Type>::SimValue;
-        match value {
-            SimValueT::<Self>::Unit(_) => f.write_str("MyEnum1::Unit"),
-            SimValueT::<Self>::V(v, _) => f.debug_tuple("MyEnum1::V").field(v).finish(),
-            SimValueT::<Self>::A(a, _) => f.debug_tuple("MyEnum1::A").field(a).finish(),
-            SimValueT::<Self>::Unknown(_) => f.write_str("MyEnum1::Unknown"),
-        }
-    }
-}
-
-#[hdl]
-#[test]
-fn check_my_enum1() {
-    let ty = MyEnum1[UInt[8]][3];
-    assert_eq!(
-        format!("{ty:?}"),
-        "Custom<MyEnum1> { Unit: (), V: UInt<8>, A: Array<UInt<8>, 3> }",
-    );
-    let v = #[hdl(sim)]
-    ty.Unit();
-    assert_eq!(format!("{v:?}"), "MyEnum1::Unit");
-    let v = #[hdl(sim)]
-    ty.V(0x23u8);
-    assert_eq!(format!("{v:?}"), "MyEnum1::V(0x23_u8)");
-    let v = #[hdl(sim)]
-    ty.A([1u8, 2, 3]);
-    assert_eq!(format!("{v:?}"), "MyEnum1::A([0x1_u8, 0x2_u8, 0x3_u8])");
-}
diff --git a/crates/fayalite/tests/module.rs b/crates/fayalite/tests/module.rs
index 9dc0107..2761cba 100644
--- a/crates/fayalite/tests/module.rs
+++ b/crates/fayalite/tests/module.rs
@@ -13,7 +13,7 @@ use fayalite::{
 };
 use serde_json::json;
 
-#[hdl(outline_generated, cmp_eq)]
+#[hdl(outline_generated)]
 pub enum TestEnum {
     A,
     B(UInt<8>),
@@ -679,366 +679,6 @@ circuit check_enum_literals:
     };
 }
 
-#[hdl_module(outline_generated)]
-pub fn check_enum_cmp_eq() {
-    #[hdl]
-    let lhs: TestEnum = m.input();
-    #[hdl]
-    let rhs: TestEnum = m.input();
-    #[hdl]
-    let eq: Bool = m.output();
-    connect(eq, lhs.cmp_eq(rhs));
-}
-
-#[test]
-fn test_enum_cmp_eq() {
-    let _n = SourceLocation::normalize_files_for_tests();
-    let m = check_enum_cmp_eq();
-    dbg!(m);
-    #[rustfmt::skip] // work around https://github.com/rust-lang/rustfmt/issues/6161
-    assert_export_firrtl! {
-        m =>
-        options: ExportOptions {
-            simplify_enums: None,
-            ..ExportOptions::default()
-        },
-        "/test/check_enum_cmp_eq.fir": r"FIRRTL version 3.2.0
-circuit check_enum_cmp_eq:
-    type Ty0 = {|A, B: UInt<8>, C: UInt<1>[3]|}
-    module check_enum_cmp_eq: @[module-XXXXXXXXXX.rs 1:1]
-        input lhs: Ty0 @[module-XXXXXXXXXX.rs 2:1]
-        input rhs: Ty0 @[module-XXXXXXXXXX.rs 3:1]
-        output eq: UInt<1> @[module-XXXXXXXXXX.rs 4:1]
-        wire TestEnum_cmp_eq: UInt<1> @[module-XXXXXXXXXX.rs 5:1]
-        connect TestEnum_cmp_eq, UInt<1>(0h0) @[module-XXXXXXXXXX.rs 5:1]
-        match lhs: @[module-XXXXXXXXXX.rs 5:1]
-            A:
-                match rhs: @[module-XXXXXXXXXX.rs 5:1]
-                    A:
-                        connect TestEnum_cmp_eq, UInt<1>(0h1) @[module-XXXXXXXXXX.rs 5:1]
-                    B(_match_arm_value):
-                        skip
-                    C(_match_arm_value_1):
-                        skip
-            B(_match_arm_value_2):
-                match rhs: @[module-XXXXXXXXXX.rs 5:1]
-                    A:
-                        skip
-                    B(_match_arm_value_3):
-                        connect TestEnum_cmp_eq, eq(_match_arm_value_2, _match_arm_value_3) @[module-XXXXXXXXXX.rs 5:1]
-                    C(_match_arm_value_4):
-                        skip
-            C(_match_arm_value_5):
-                match rhs: @[module-XXXXXXXXXX.rs 5:1]
-                    A:
-                        skip
-                    B(_match_arm_value_6):
-                        skip
-                    C(_match_arm_value_7):
-                        wire _array_literal_expr: UInt<1>[3]
-                        connect _array_literal_expr[0], eq(_match_arm_value_5[0], _match_arm_value_7[0])
-                        connect _array_literal_expr[1], eq(_match_arm_value_5[1], _match_arm_value_7[1])
-                        connect _array_literal_expr[2], eq(_match_arm_value_5[2], _match_arm_value_7[2])
-                        wire _cast_array_to_bits_expr: UInt<1>[3]
-                        connect _cast_array_to_bits_expr[0], _array_literal_expr[0]
-                        connect _cast_array_to_bits_expr[1], _array_literal_expr[1]
-                        connect _cast_array_to_bits_expr[2], _array_literal_expr[2]
-                        wire _cast_to_bits_expr: UInt<3>
-                        connect _cast_to_bits_expr, cat(_cast_array_to_bits_expr[2], cat(_cast_array_to_bits_expr[1], _cast_array_to_bits_expr[0]))
-                        connect TestEnum_cmp_eq, andr(_cast_to_bits_expr) @[module-XXXXXXXXXX.rs 5:1]
-        connect eq, TestEnum_cmp_eq @[module-XXXXXXXXXX.rs 6:1]
-",
-    };
-    #[rustfmt::skip] // work around https://github.com/rust-lang/rustfmt/issues/6161
-    assert_export_firrtl! {
-        m =>
-        options: ExportOptions {
-            simplify_enums: Some(SimplifyEnumsKind::SimplifyToEnumsWithNoBody),
-            ..ExportOptions::default()
-        },
-        "/test/check_enum_cmp_eq.fir": r"FIRRTL version 3.2.0
-circuit check_enum_cmp_eq:
-    type Ty0 = {|A, B, C|}
-    type Ty1 = {tag: Ty0, body: UInt<8>}
-    module check_enum_cmp_eq: @[module-XXXXXXXXXX.rs 1:1]
-        input lhs: Ty1 @[module-XXXXXXXXXX.rs 2:1]
-        input rhs: Ty1 @[module-XXXXXXXXXX.rs 3:1]
-        output eq: UInt<1> @[module-XXXXXXXXXX.rs 4:1]
-        wire TestEnum_cmp_eq: UInt<1> @[module-XXXXXXXXXX.rs 5:1]
-        connect TestEnum_cmp_eq, UInt<1>(0h0) @[module-XXXXXXXXXX.rs 5:1]
-        match lhs.tag: @[module-XXXXXXXXXX.rs 5:1]
-            A:
-                match rhs.tag: @[module-XXXXXXXXXX.rs 5:1]
-                    A:
-                        connect TestEnum_cmp_eq, UInt<1>(0h1) @[module-XXXXXXXXXX.rs 5:1]
-                    B:
-                        skip
-                    C:
-                        skip
-            B:
-                match rhs.tag: @[module-XXXXXXXXXX.rs 5:1]
-                    A:
-                        skip
-                    B:
-                        connect TestEnum_cmp_eq, eq(bits(lhs.body, 7, 0), bits(rhs.body, 7, 0)) @[module-XXXXXXXXXX.rs 5:1]
-                    C:
-                        skip
-            C:
-                match rhs.tag: @[module-XXXXXXXXXX.rs 5:1]
-                    A:
-                        skip
-                    B:
-                        skip
-                    C:
-                        wire _array_literal_expr: UInt<1>[3]
-                        wire _cast_bits_to_array_expr: UInt<1>[3]
-                        wire _cast_bits_to_array_expr_flattened: UInt<1>[3]
-                        connect _cast_bits_to_array_expr_flattened[0], bits(bits(lhs.body, 2, 0), 0, 0)
-                        connect _cast_bits_to_array_expr[0], _cast_bits_to_array_expr_flattened[0]
-                        connect _cast_bits_to_array_expr_flattened[1], bits(bits(lhs.body, 2, 0), 1, 1)
-                        connect _cast_bits_to_array_expr[1], _cast_bits_to_array_expr_flattened[1]
-                        connect _cast_bits_to_array_expr_flattened[2], bits(bits(lhs.body, 2, 0), 2, 2)
-                        connect _cast_bits_to_array_expr[2], _cast_bits_to_array_expr_flattened[2]
-                        wire _cast_bits_to_array_expr_1: UInt<1>[3]
-                        wire _cast_bits_to_array_expr_flattened_1: UInt<1>[3]
-                        connect _cast_bits_to_array_expr_flattened_1[0], bits(bits(rhs.body, 2, 0), 0, 0)
-                        connect _cast_bits_to_array_expr_1[0], _cast_bits_to_array_expr_flattened_1[0]
-                        connect _cast_bits_to_array_expr_flattened_1[1], bits(bits(rhs.body, 2, 0), 1, 1)
-                        connect _cast_bits_to_array_expr_1[1], _cast_bits_to_array_expr_flattened_1[1]
-                        connect _cast_bits_to_array_expr_flattened_1[2], bits(bits(rhs.body, 2, 0), 2, 2)
-                        connect _cast_bits_to_array_expr_1[2], _cast_bits_to_array_expr_flattened_1[2]
-                        connect _array_literal_expr[0], eq(_cast_bits_to_array_expr[0], _cast_bits_to_array_expr_1[0])
-                        wire _cast_bits_to_array_expr_2: UInt<1>[3]
-                        wire _cast_bits_to_array_expr_flattened_2: UInt<1>[3]
-                        connect _cast_bits_to_array_expr_flattened_2[0], bits(bits(lhs.body, 2, 0), 0, 0)
-                        connect _cast_bits_to_array_expr_2[0], _cast_bits_to_array_expr_flattened_2[0]
-                        connect _cast_bits_to_array_expr_flattened_2[1], bits(bits(lhs.body, 2, 0), 1, 1)
-                        connect _cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_flattened_2[1]
-                        connect _cast_bits_to_array_expr_flattened_2[2], bits(bits(lhs.body, 2, 0), 2, 2)
-                        connect _cast_bits_to_array_expr_2[2], _cast_bits_to_array_expr_flattened_2[2]
-                        wire _cast_bits_to_array_expr_3: UInt<1>[3]
-                        wire _cast_bits_to_array_expr_flattened_3: UInt<1>[3]
-                        connect _cast_bits_to_array_expr_flattened_3[0], bits(bits(rhs.body, 2, 0), 0, 0)
-                        connect _cast_bits_to_array_expr_3[0], _cast_bits_to_array_expr_flattened_3[0]
-                        connect _cast_bits_to_array_expr_flattened_3[1], bits(bits(rhs.body, 2, 0), 1, 1)
-                        connect _cast_bits_to_array_expr_3[1], _cast_bits_to_array_expr_flattened_3[1]
-                        connect _cast_bits_to_array_expr_flattened_3[2], bits(bits(rhs.body, 2, 0), 2, 2)
-                        connect _cast_bits_to_array_expr_3[2], _cast_bits_to_array_expr_flattened_3[2]
-                        connect _array_literal_expr[1], eq(_cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_3[1])
-                        wire _cast_bits_to_array_expr_4: UInt<1>[3]
-                        wire _cast_bits_to_array_expr_flattened_4: UInt<1>[3]
-                        connect _cast_bits_to_array_expr_flattened_4[0], bits(bits(lhs.body, 2, 0), 0, 0)
-                        connect _cast_bits_to_array_expr_4[0], _cast_bits_to_array_expr_flattened_4[0]
-                        connect _cast_bits_to_array_expr_flattened_4[1], bits(bits(lhs.body, 2, 0), 1, 1)
-                        connect _cast_bits_to_array_expr_4[1], _cast_bits_to_array_expr_flattened_4[1]
-                        connect _cast_bits_to_array_expr_flattened_4[2], bits(bits(lhs.body, 2, 0), 2, 2)
-                        connect _cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_flattened_4[2]
-                        wire _cast_bits_to_array_expr_5: UInt<1>[3]
-                        wire _cast_bits_to_array_expr_flattened_5: UInt<1>[3]
-                        connect _cast_bits_to_array_expr_flattened_5[0], bits(bits(rhs.body, 2, 0), 0, 0)
-                        connect _cast_bits_to_array_expr_5[0], _cast_bits_to_array_expr_flattened_5[0]
-                        connect _cast_bits_to_array_expr_flattened_5[1], bits(bits(rhs.body, 2, 0), 1, 1)
-                        connect _cast_bits_to_array_expr_5[1], _cast_bits_to_array_expr_flattened_5[1]
-                        connect _cast_bits_to_array_expr_flattened_5[2], bits(bits(rhs.body, 2, 0), 2, 2)
-                        connect _cast_bits_to_array_expr_5[2], _cast_bits_to_array_expr_flattened_5[2]
-                        connect _array_literal_expr[2], eq(_cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_5[2])
-                        wire _cast_array_to_bits_expr: UInt<1>[3]
-                        connect _cast_array_to_bits_expr[0], _array_literal_expr[0]
-                        connect _cast_array_to_bits_expr[1], _array_literal_expr[1]
-                        connect _cast_array_to_bits_expr[2], _array_literal_expr[2]
-                        wire _cast_to_bits_expr: UInt<3>
-                        connect _cast_to_bits_expr, cat(_cast_array_to_bits_expr[2], cat(_cast_array_to_bits_expr[1], _cast_array_to_bits_expr[0]))
-                        connect TestEnum_cmp_eq, andr(_cast_to_bits_expr) @[module-XXXXXXXXXX.rs 5:1]
-        connect eq, TestEnum_cmp_eq @[module-XXXXXXXXXX.rs 6:1]
-",
-    };
-    #[rustfmt::skip] // work around https://github.com/rust-lang/rustfmt/issues/6161
-    assert_export_firrtl! {
-        m =>
-        options: ExportOptions {
-            simplify_enums: Some(SimplifyEnumsKind::ReplaceWithBundleOfUInts),
-            ..ExportOptions::default()
-        },
-        "/test/check_enum_cmp_eq.fir": r"FIRRTL version 3.2.0
-circuit check_enum_cmp_eq:
-    type Ty0 = {tag: UInt<2>, body: UInt<8>}
-    module check_enum_cmp_eq: @[module-XXXXXXXXXX.rs 1:1]
-        input lhs: Ty0 @[module-XXXXXXXXXX.rs 2:1]
-        input rhs: Ty0 @[module-XXXXXXXXXX.rs 3:1]
-        output eq: UInt<1> @[module-XXXXXXXXXX.rs 4:1]
-        wire TestEnum_cmp_eq: UInt<1> @[module-XXXXXXXXXX.rs 5:1]
-        connect TestEnum_cmp_eq, UInt<1>(0h0) @[module-XXXXXXXXXX.rs 5:1]
-        when eq(lhs.tag, UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
-            when eq(rhs.tag, UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
-                connect TestEnum_cmp_eq, UInt<1>(0h1) @[module-XXXXXXXXXX.rs 5:1]
-            else when eq(rhs.tag, UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
-                skip
-        else when eq(lhs.tag, UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
-            when eq(rhs.tag, UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
-                skip
-            else when eq(rhs.tag, UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
-                connect TestEnum_cmp_eq, eq(bits(lhs.body, 7, 0), bits(rhs.body, 7, 0)) @[module-XXXXXXXXXX.rs 5:1]
-        else when eq(rhs.tag, UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
-            skip
-        else when eq(rhs.tag, UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
-            skip
-        else:
-            wire _array_literal_expr: UInt<1>[3]
-            wire _cast_bits_to_array_expr: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened[0], bits(bits(lhs.body, 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr[0], _cast_bits_to_array_expr_flattened[0]
-            connect _cast_bits_to_array_expr_flattened[1], bits(bits(lhs.body, 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr[1], _cast_bits_to_array_expr_flattened[1]
-            connect _cast_bits_to_array_expr_flattened[2], bits(bits(lhs.body, 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr[2], _cast_bits_to_array_expr_flattened[2]
-            wire _cast_bits_to_array_expr_1: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened_1: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened_1[0], bits(bits(rhs.body, 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr_1[0], _cast_bits_to_array_expr_flattened_1[0]
-            connect _cast_bits_to_array_expr_flattened_1[1], bits(bits(rhs.body, 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr_1[1], _cast_bits_to_array_expr_flattened_1[1]
-            connect _cast_bits_to_array_expr_flattened_1[2], bits(bits(rhs.body, 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr_1[2], _cast_bits_to_array_expr_flattened_1[2]
-            connect _array_literal_expr[0], eq(_cast_bits_to_array_expr[0], _cast_bits_to_array_expr_1[0])
-            wire _cast_bits_to_array_expr_2: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened_2: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened_2[0], bits(bits(lhs.body, 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr_2[0], _cast_bits_to_array_expr_flattened_2[0]
-            connect _cast_bits_to_array_expr_flattened_2[1], bits(bits(lhs.body, 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_flattened_2[1]
-            connect _cast_bits_to_array_expr_flattened_2[2], bits(bits(lhs.body, 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr_2[2], _cast_bits_to_array_expr_flattened_2[2]
-            wire _cast_bits_to_array_expr_3: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened_3: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened_3[0], bits(bits(rhs.body, 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr_3[0], _cast_bits_to_array_expr_flattened_3[0]
-            connect _cast_bits_to_array_expr_flattened_3[1], bits(bits(rhs.body, 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr_3[1], _cast_bits_to_array_expr_flattened_3[1]
-            connect _cast_bits_to_array_expr_flattened_3[2], bits(bits(rhs.body, 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr_3[2], _cast_bits_to_array_expr_flattened_3[2]
-            connect _array_literal_expr[1], eq(_cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_3[1])
-            wire _cast_bits_to_array_expr_4: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened_4: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened_4[0], bits(bits(lhs.body, 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr_4[0], _cast_bits_to_array_expr_flattened_4[0]
-            connect _cast_bits_to_array_expr_flattened_4[1], bits(bits(lhs.body, 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr_4[1], _cast_bits_to_array_expr_flattened_4[1]
-            connect _cast_bits_to_array_expr_flattened_4[2], bits(bits(lhs.body, 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_flattened_4[2]
-            wire _cast_bits_to_array_expr_5: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened_5: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened_5[0], bits(bits(rhs.body, 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr_5[0], _cast_bits_to_array_expr_flattened_5[0]
-            connect _cast_bits_to_array_expr_flattened_5[1], bits(bits(rhs.body, 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr_5[1], _cast_bits_to_array_expr_flattened_5[1]
-            connect _cast_bits_to_array_expr_flattened_5[2], bits(bits(rhs.body, 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr_5[2], _cast_bits_to_array_expr_flattened_5[2]
-            connect _array_literal_expr[2], eq(_cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_5[2])
-            wire _cast_array_to_bits_expr: UInt<1>[3]
-            connect _cast_array_to_bits_expr[0], _array_literal_expr[0]
-            connect _cast_array_to_bits_expr[1], _array_literal_expr[1]
-            connect _cast_array_to_bits_expr[2], _array_literal_expr[2]
-            wire _cast_to_bits_expr: UInt<3>
-            connect _cast_to_bits_expr, cat(_cast_array_to_bits_expr[2], cat(_cast_array_to_bits_expr[1], _cast_array_to_bits_expr[0]))
-            connect TestEnum_cmp_eq, andr(_cast_to_bits_expr) @[module-XXXXXXXXXX.rs 5:1]
-        connect eq, TestEnum_cmp_eq @[module-XXXXXXXXXX.rs 6:1]
-",
-    };
-    #[rustfmt::skip] // work around https://github.com/rust-lang/rustfmt/issues/6161
-    assert_export_firrtl! {
-        m =>
-        options: ExportOptions {
-            simplify_enums: Some(SimplifyEnumsKind::ReplaceWithUInt),
-            ..ExportOptions::default()
-        },
-        "/test/check_enum_cmp_eq.fir": r"FIRRTL version 3.2.0
-circuit check_enum_cmp_eq:
-    module check_enum_cmp_eq: @[module-XXXXXXXXXX.rs 1:1]
-        input lhs: UInt<10> @[module-XXXXXXXXXX.rs 2:1]
-        input rhs: UInt<10> @[module-XXXXXXXXXX.rs 3:1]
-        output eq: UInt<1> @[module-XXXXXXXXXX.rs 4:1]
-        wire TestEnum_cmp_eq: UInt<1> @[module-XXXXXXXXXX.rs 5:1]
-        connect TestEnum_cmp_eq, UInt<1>(0h0) @[module-XXXXXXXXXX.rs 5:1]
-        when eq(bits(lhs, 1, 0), UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
-            when eq(bits(rhs, 1, 0), UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
-                connect TestEnum_cmp_eq, UInt<1>(0h1) @[module-XXXXXXXXXX.rs 5:1]
-            else when eq(bits(rhs, 1, 0), UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
-                skip
-        else when eq(bits(lhs, 1, 0), UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
-            when eq(bits(rhs, 1, 0), UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
-                skip
-            else when eq(bits(rhs, 1, 0), UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
-                connect TestEnum_cmp_eq, eq(bits(bits(lhs, 9, 2), 7, 0), bits(bits(rhs, 9, 2), 7, 0)) @[module-XXXXXXXXXX.rs 5:1]
-        else when eq(bits(rhs, 1, 0), UInt<2>(0h0)): @[module-XXXXXXXXXX.rs 5:1]
-            skip
-        else when eq(bits(rhs, 1, 0), UInt<2>(0h1)): @[module-XXXXXXXXXX.rs 5:1]
-            skip
-        else:
-            wire _array_literal_expr: UInt<1>[3]
-            wire _cast_bits_to_array_expr: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened[0], bits(bits(bits(lhs, 9, 2), 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr[0], _cast_bits_to_array_expr_flattened[0]
-            connect _cast_bits_to_array_expr_flattened[1], bits(bits(bits(lhs, 9, 2), 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr[1], _cast_bits_to_array_expr_flattened[1]
-            connect _cast_bits_to_array_expr_flattened[2], bits(bits(bits(lhs, 9, 2), 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr[2], _cast_bits_to_array_expr_flattened[2]
-            wire _cast_bits_to_array_expr_1: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened_1: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened_1[0], bits(bits(bits(rhs, 9, 2), 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr_1[0], _cast_bits_to_array_expr_flattened_1[0]
-            connect _cast_bits_to_array_expr_flattened_1[1], bits(bits(bits(rhs, 9, 2), 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr_1[1], _cast_bits_to_array_expr_flattened_1[1]
-            connect _cast_bits_to_array_expr_flattened_1[2], bits(bits(bits(rhs, 9, 2), 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr_1[2], _cast_bits_to_array_expr_flattened_1[2]
-            connect _array_literal_expr[0], eq(_cast_bits_to_array_expr[0], _cast_bits_to_array_expr_1[0])
-            wire _cast_bits_to_array_expr_2: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened_2: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened_2[0], bits(bits(bits(lhs, 9, 2), 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr_2[0], _cast_bits_to_array_expr_flattened_2[0]
-            connect _cast_bits_to_array_expr_flattened_2[1], bits(bits(bits(lhs, 9, 2), 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_flattened_2[1]
-            connect _cast_bits_to_array_expr_flattened_2[2], bits(bits(bits(lhs, 9, 2), 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr_2[2], _cast_bits_to_array_expr_flattened_2[2]
-            wire _cast_bits_to_array_expr_3: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened_3: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened_3[0], bits(bits(bits(rhs, 9, 2), 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr_3[0], _cast_bits_to_array_expr_flattened_3[0]
-            connect _cast_bits_to_array_expr_flattened_3[1], bits(bits(bits(rhs, 9, 2), 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr_3[1], _cast_bits_to_array_expr_flattened_3[1]
-            connect _cast_bits_to_array_expr_flattened_3[2], bits(bits(bits(rhs, 9, 2), 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr_3[2], _cast_bits_to_array_expr_flattened_3[2]
-            connect _array_literal_expr[1], eq(_cast_bits_to_array_expr_2[1], _cast_bits_to_array_expr_3[1])
-            wire _cast_bits_to_array_expr_4: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened_4: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened_4[0], bits(bits(bits(lhs, 9, 2), 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr_4[0], _cast_bits_to_array_expr_flattened_4[0]
-            connect _cast_bits_to_array_expr_flattened_4[1], bits(bits(bits(lhs, 9, 2), 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr_4[1], _cast_bits_to_array_expr_flattened_4[1]
-            connect _cast_bits_to_array_expr_flattened_4[2], bits(bits(bits(lhs, 9, 2), 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_flattened_4[2]
-            wire _cast_bits_to_array_expr_5: UInt<1>[3]
-            wire _cast_bits_to_array_expr_flattened_5: UInt<1>[3]
-            connect _cast_bits_to_array_expr_flattened_5[0], bits(bits(bits(rhs, 9, 2), 2, 0), 0, 0)
-            connect _cast_bits_to_array_expr_5[0], _cast_bits_to_array_expr_flattened_5[0]
-            connect _cast_bits_to_array_expr_flattened_5[1], bits(bits(bits(rhs, 9, 2), 2, 0), 1, 1)
-            connect _cast_bits_to_array_expr_5[1], _cast_bits_to_array_expr_flattened_5[1]
-            connect _cast_bits_to_array_expr_flattened_5[2], bits(bits(bits(rhs, 9, 2), 2, 0), 2, 2)
-            connect _cast_bits_to_array_expr_5[2], _cast_bits_to_array_expr_flattened_5[2]
-            connect _array_literal_expr[2], eq(_cast_bits_to_array_expr_4[2], _cast_bits_to_array_expr_5[2])
-            wire _cast_array_to_bits_expr: UInt<1>[3]
-            connect _cast_array_to_bits_expr[0], _array_literal_expr[0]
-            connect _cast_array_to_bits_expr[1], _array_literal_expr[1]
-            connect _cast_array_to_bits_expr[2], _array_literal_expr[2]
-            wire _cast_to_bits_expr: UInt<3>
-            connect _cast_to_bits_expr, cat(_cast_array_to_bits_expr[2], cat(_cast_array_to_bits_expr[1], _cast_array_to_bits_expr[0]))
-            connect TestEnum_cmp_eq, andr(_cast_to_bits_expr) @[module-XXXXXXXXXX.rs 5:1]
-        connect eq, TestEnum_cmp_eq @[module-XXXXXXXXXX.rs 6:1]
-",
-    };
-}
-
 #[hdl_module(outline_generated)]
 pub fn check_struct_enum_match() {
     #[hdl]
diff --git a/crates/fayalite/tests/sim.rs b/crates/fayalite/tests/sim.rs
index 53f7d9d..e57c064 100644
--- a/crates/fayalite/tests/sim.rs
+++ b/crates/fayalite/tests/sim.rs
@@ -550,150 +550,6 @@ fn test_enums() {
     }
 }
 
-#[hdl]
-pub enum EnumWithSimpleBody {
-    A(UInt<8>),
-    B(UInt<8>),
-    C(UInt<8>),
-}
-
-#[hdl_module(outline_generated)]
-pub fn enum_with_simple_body() {
-    #[hdl]
-    let which_in: UInt<8> = m.input();
-    #[hdl]
-    let data_in: UInt<8> = m.input();
-    #[hdl]
-    let which_out: UInt<8> = m.output();
-    #[hdl]
-    let data_out: UInt<8> = m.output();
-    #[hdl]
-    let enum_out: EnumWithSimpleBody = m.output();
-
-    #[hdl]
-    if which_in.cmp_eq(0u8) {
-        connect(enum_out, EnumWithSimpleBody.A(data_in));
-    } else if which_in.cmp_eq(1u8) {
-        connect(enum_out, EnumWithSimpleBody.B(data_in));
-    } else {
-        connect(enum_out, EnumWithSimpleBody.C(data_in));
-    }
-
-    #[hdl]
-    match enum_out {
-        EnumWithSimpleBody::A(v) => {
-            connect(which_out, 0u8);
-            connect(data_out, v);
-        }
-        EnumWithSimpleBody::B(v) => {
-            connect(which_out, 1u8);
-            connect(data_out, v);
-        }
-        EnumWithSimpleBody::C(v) => {
-            connect(which_out, 2u8);
-            connect(data_out, v);
-        }
-    }
-}
-
-#[hdl]
-#[test]
-fn test_enum_with_simple_body() {
-    let _n = SourceLocation::normalize_files_for_tests();
-    let mut sim = Simulation::new(enum_with_simple_body());
-    let mut writer = RcWriter::default();
-    sim.add_trace_writer(VcdWriterDecls::new(writer.clone()));
-    for which in 0u8..=2 {
-        for data in (0..u8::MAX).step_by(45) {
-            sim.write(sim.io().which_in, which);
-            sim.write(sim.io().data_in, data);
-            sim.advance_time(SimDuration::from_micros(1));
-            assert_eq!(sim.read(sim.io().which_out).as_int(), which);
-            assert_eq!(sim.read(sim.io().data_out).as_int(), data);
-        }
-    }
-    sim.flush_traces().unwrap();
-    let vcd = String::from_utf8(writer.take()).unwrap();
-    println!("####### VCD:\n{vcd}\n#######");
-    #[derive(Debug)]
-    struct WireState<'a> {
-        name: &'a str,
-        space_then_id: Option<&'a str>,
-        value: Option<&'a str>,
-    }
-    impl<'a> WireState<'a> {
-        fn new(name: &'a str) -> Self {
-            Self {
-                name,
-                space_then_id: None,
-                value: None,
-            }
-        }
-    }
-    let mut variant_wires = [
-        WireState::new("A"),
-        WireState::new("B"),
-        WireState::new("C"),
-    ];
-    // check that output .vcd has the proper values for all variants' wires
-    for (is_last, line) in vcd.lines().map(|line| (false, line)).chain([(true, "")]) {
-        if let Some(line) = line.strip_prefix("$var wire 8")
-            && let Some(line) = line.strip_suffix(" $end")
-            && let Some((space_then_id, state)) = variant_wires
-                .iter_mut()
-                .find_map(|state| Some((line.strip_suffix(state.name)?.strip_suffix(" ")?, state)))
-        {
-            assert_eq!(space_then_id.chars().next(), Some(' '));
-            assert!(
-                space_then_id
-                    .chars()
-                    .skip(1)
-                    .all(|ch| matches!(ch, '!'..='~'))
-            );
-            assert_eq!(state.space_then_id.replace(space_then_id), None);
-        } else if line.starts_with("#") || is_last {
-            let Some(expected_value) = variant_wires[0].value else {
-                panic!(
-                    "variant {} hasn't been initialized before a timestamp or EOF: {variant_wires:#?}\n\
-                    line={line:?}",
-                    variant_wires[0].name,
-                );
-            };
-            for state in &variant_wires {
-                assert_eq!(
-                    state.value,
-                    Some(expected_value),
-                    "at a timestamp or EOF: variant value for {} doesn't match expected value.\n\
-                    {variant_wires:#?}\nline={line:?}",
-                    state.name,
-                );
-            }
-        } else if line.starts_with("b") {
-            for state in &mut variant_wires {
-                let Some(space_then_id) = state.space_then_id else {
-                    let name = state.name;
-                    panic!(
-                        "variant {name} hasn't had an id assigned yet: {variant_wires:#?}\n\
-                        line={line:?}",
-                    );
-                };
-                if let Some(value) = line.strip_suffix(space_then_id) {
-                    state.value = Some(value);
-                    break;
-                }
-            }
-        }
-    }
-    if vcd != include_str!("sim/expected/enum_with_simple_body.vcd") {
-        panic!();
-    }
-    let sim_debug = format!("{sim:#?}");
-    println!("#######\n{sim_debug}\n#######");
-    if sim_debug != include_str!("sim/expected/enum_with_simple_body.txt") {
-        panic!();
-    }
-}
-
 #[hdl_module(outline_generated)]
 pub fn memories() {
     #[hdl]
diff --git a/crates/fayalite/tests/sim/expected/array_rw.txt b/crates/fayalite/tests/sim/expected/array_rw.txt
index 271ec3c..27b040d 100644
--- a/crates/fayalite/tests/sim/expected/array_rw.txt
+++ b/crates/fayalite/tests/sim/expected/array_rw.txt
@@ -1218,7 +1218,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1228,7 +1227,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(1),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x7f,
             last_state: 0x7f,
         },
@@ -1238,7 +1236,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x3f,
             last_state: 0x3f,
         },
@@ -1248,7 +1245,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1258,7 +1254,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x0f,
             last_state: 0x0f,
         },
@@ -1268,7 +1263,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x07,
             last_state: 0x07,
         },
@@ -1278,7 +1272,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x03,
             last_state: 0x03,
         },
@@ -1288,7 +1281,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(7),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x01,
             last_state: 0x01,
         },
@@ -1298,7 +1290,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1308,7 +1299,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x80,
             last_state: 0x80,
         },
@@ -1318,7 +1308,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1328,7 +1317,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1338,7 +1326,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(12),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xf0,
             last_state: 0xf0,
         },
@@ -1348,7 +1335,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(13),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xf8,
             last_state: 0xf8,
         },
@@ -1358,7 +1344,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xfc,
             last_state: 0xfc,
         },
@@ -1368,7 +1353,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xfe,
             last_state: 0xfe,
         },
@@ -1378,7 +1362,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1388,7 +1371,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x7f,
             last_state: 0x7f,
         },
@@ -1398,7 +1380,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x3f,
             last_state: 0x3f,
         },
@@ -1408,7 +1389,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(19),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1418,7 +1398,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x0f,
             last_state: 0x0f,
         },
@@ -1428,7 +1407,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(21),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x07,
             last_state: 0x07,
         },
@@ -1438,7 +1416,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x03,
             last_state: 0x03,
         },
@@ -1448,7 +1425,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(23),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x01,
             last_state: 0x01,
         },
@@ -1458,7 +1434,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(24),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1468,7 +1443,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x80,
             last_state: 0x80,
         },
@@ -1478,7 +1452,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(26),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1488,7 +1461,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(27),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1498,7 +1470,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(28),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xf0,
             last_state: 0xf0,
         },
@@ -1508,7 +1479,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(29),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xf8,
             last_state: 0xf8,
         },
@@ -1518,7 +1488,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(30),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xfc,
             last_state: 0xfc,
         },
@@ -1528,7 +1497,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(31),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xfe,
             last_state: 0xe1,
         },
@@ -1538,7 +1506,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(32),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1548,7 +1515,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(33),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1558,7 +1524,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(34),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x10,
             last_state: 0x0f,
         },
@@ -1568,7 +1533,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(35),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0xe1,
         },
@@ -1577,7 +1541,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1587,7 +1550,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(37),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xff,
             last_state: 0xff,
         },
@@ -1597,7 +1559,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(38),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x7f,
             last_state: 0x7f,
         },
@@ -1607,7 +1568,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(39),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x3f,
             last_state: 0x3f,
         },
@@ -1617,7 +1577,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(40),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1627,7 +1586,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(41),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x0f,
             last_state: 0x0f,
         },
@@ -1637,7 +1595,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x07,
             last_state: 0x07,
         },
@@ -1647,7 +1604,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(43),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x03,
             last_state: 0x03,
         },
@@ -1657,7 +1613,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(44),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x01,
             last_state: 0x01,
         },
@@ -1667,7 +1622,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(45),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1677,7 +1631,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(46),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x80,
             last_state: 0x80,
         },
@@ -1687,7 +1640,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(47),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1697,7 +1649,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(48),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1707,7 +1658,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(49),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xf0,
             last_state: 0xf0,
         },
@@ -1717,7 +1667,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(50),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xf8,
             last_state: 0xf8,
         },
@@ -1727,7 +1676,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(51),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xfc,
             last_state: 0xfc,
         },
@@ -1737,7 +1685,6 @@ 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 74c03a4..d470792 100644
--- a/crates/fayalite/tests/sim/expected/conditional_assignment_last.txt
+++ b/crates/fayalite/tests/sim/expected/conditional_assignment_last.txt
@@ -155,7 +155,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -164,7 +163,6 @@ 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 8193fc5..56ea4ad 100644
--- a/crates/fayalite/tests/sim/expected/connect_const.txt
+++ b/crates/fayalite/tests/sim/expected/connect_const.txt
@@ -124,7 +124,6 @@ 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 5a64923..6b5814a 100644
--- a/crates/fayalite/tests/sim/expected/connect_const_reset.txt
+++ b/crates/fayalite/tests/sim/expected/connect_const_reset.txt
@@ -175,7 +175,6 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -184,7 +183,6 @@ 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 20d27ac..2bdd665 100644
--- a/crates/fayalite/tests/sim/expected/counter_async.txt
+++ b/crates/fayalite/tests/sim/expected/counter_async.txt
@@ -332,7 +332,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -341,7 +340,6 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -351,7 +349,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },
@@ -361,7 +358,6 @@ 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 baa08e7..87c2098 100644
--- a/crates/fayalite/tests/sim/expected/counter_sync.txt
+++ b/crates/fayalite/tests/sim/expected/counter_sync.txt
@@ -313,7 +313,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -322,7 +321,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -332,7 +330,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x3,
             last_state: 0x2,
         },
@@ -342,7 +339,6 @@ 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 76338e8..64bbbe6 100644
--- a/crates/fayalite/tests/sim/expected/duplicate_names.txt
+++ b/crates/fayalite/tests/sim/expected/duplicate_names.txt
@@ -137,7 +137,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x05,
             last_state: 0x05,
         },
@@ -147,7 +146,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x06,
             last_state: 0x06,
         },
diff --git a/crates/fayalite/tests/sim/expected/enum_with_simple_body.txt b/crates/fayalite/tests/sim/expected/enum_with_simple_body.txt
deleted file mode 100644
index 6b5af1c..0000000
--- a/crates/fayalite/tests/sim/expected/enum_with_simple_body.txt
+++ /dev/null
@@ -1,749 +0,0 @@
-Simulation {
-    state: State {
-        insns: Insns {
-            state_layout: StateLayout {
-                ty: TypeLayout {
-                    small_slots: StatePartLayout<SmallSlots> {
-                        len: 1,
-                        debug_data: [
-                            SlotDebugData {
-                                name: "",
-                                ty: Enum {
-                                    A,
-                                    B,
-                                    C,
-                                },
-                            },
-                        ],
-                        ..
-                    },
-                    big_slots: StatePartLayout<BigSlots> {
-                        len: 33,
-                        debug_data: [
-                            SlotDebugData {
-                                name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_in",
-                                ty: UInt<8>,
-                            },
-                            SlotDebugData {
-                                name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_in",
-                                ty: UInt<8>,
-                            },
-                            SlotDebugData {
-                                name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_out",
-                                ty: UInt<8>,
-                            },
-                            SlotDebugData {
-                                name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_out",
-                                ty: UInt<8>,
-                            },
-                            SlotDebugData {
-                                name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out",
-                                ty: Enum {
-                                    A(UInt<8>),
-                                    B(UInt<8>),
-                                    C(UInt<8>),
-                                },
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<10>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<8>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<8>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: Bool,
-                            },
-                            SlotDebugData {
-                                name: ".0",
-                                ty: UInt<2>,
-                            },
-                            SlotDebugData {
-                                name: ".1",
-                                ty: UInt<8>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<2>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<10>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<10>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<10>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: Enum {
-                                    A(UInt<8>),
-                                    B(UInt<8>),
-                                    C(UInt<8>),
-                                },
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<8>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: Bool,
-                            },
-                            SlotDebugData {
-                                name: ".0",
-                                ty: UInt<2>,
-                            },
-                            SlotDebugData {
-                                name: ".1",
-                                ty: UInt<8>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<2>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<10>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<10>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<10>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: Enum {
-                                    A(UInt<8>),
-                                    B(UInt<8>),
-                                    C(UInt<8>),
-                                },
-                            },
-                            SlotDebugData {
-                                name: ".0",
-                                ty: UInt<2>,
-                            },
-                            SlotDebugData {
-                                name: ".1",
-                                ty: UInt<8>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<2>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<10>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<10>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<10>,
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: Enum {
-                                    A(UInt<8>),
-                                    B(UInt<8>),
-                                    C(UInt<8>),
-                                },
-                            },
-                            SlotDebugData {
-                                name: "",
-                                ty: UInt<8>,
-                            },
-                        ],
-                        ..
-                    },
-                    sim_only_slots: StatePartLayout<SimOnlySlots> {
-                        len: 0,
-                        debug_data: [],
-                        layout_data: [],
-                        ..
-                    },
-                },
-                memories: StatePartLayout<Memories> {
-                    len: 0,
-                    debug_data: [],
-                    layout_data: [],
-                    ..
-                },
-            },
-            insns: [
-                // at: module-XXXXXXXXXX.rs:1:1
-                0: Const {
-                    dest: StatePartIndex<BigSlots>(32), // (0x2) SlotDebugData { name: "", ty: UInt<8> },
-                    value: 0x2,
-                },
-                1: Const {
-                    dest: StatePartIndex<BigSlots>(27), // (0x2) SlotDebugData { name: "", ty: UInt<2> },
-                    value: 0x2,
-                },
-                2: Copy {
-                    dest: StatePartIndex<BigSlots>(25), // (0x2) SlotDebugData { name: ".0", ty: UInt<2> },
-                    src: StatePartIndex<BigSlots>(27), // (0x2) SlotDebugData { name: "", ty: UInt<2> },
-                },
-                3: Copy {
-                    dest: StatePartIndex<BigSlots>(26), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
-                    src: StatePartIndex<BigSlots>(1), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_in", ty: UInt<8> },
-                },
-                4: Shl {
-                    dest: StatePartIndex<BigSlots>(28), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
-                    lhs: StatePartIndex<BigSlots>(26), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
-                    rhs: 2,
-                },
-                5: Or {
-                    dest: StatePartIndex<BigSlots>(29), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
-                    lhs: StatePartIndex<BigSlots>(25), // (0x2) SlotDebugData { name: ".0", ty: UInt<2> },
-                    rhs: StatePartIndex<BigSlots>(28), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
-                },
-                6: CastToUInt {
-                    dest: StatePartIndex<BigSlots>(30), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
-                    src: StatePartIndex<BigSlots>(29), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
-                    dest_width: 10,
-                },
-                7: Copy {
-                    dest: StatePartIndex<BigSlots>(31), // (0x386) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
-                    src: StatePartIndex<BigSlots>(30), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
-                },
-                8: Const {
-                    dest: StatePartIndex<BigSlots>(20), // (0x1) SlotDebugData { name: "", ty: UInt<2> },
-                    value: 0x1,
-                },
-                9: Copy {
-                    dest: StatePartIndex<BigSlots>(18), // (0x1) SlotDebugData { name: ".0", ty: UInt<2> },
-                    src: StatePartIndex<BigSlots>(20), // (0x1) SlotDebugData { name: "", ty: UInt<2> },
-                },
-                10: Copy {
-                    dest: StatePartIndex<BigSlots>(19), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
-                    src: StatePartIndex<BigSlots>(1), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_in", ty: UInt<8> },
-                },
-                11: Shl {
-                    dest: StatePartIndex<BigSlots>(21), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
-                    lhs: StatePartIndex<BigSlots>(19), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
-                    rhs: 2,
-                },
-                12: Or {
-                    dest: StatePartIndex<BigSlots>(22), // (0x385) SlotDebugData { name: "", ty: UInt<10> },
-                    lhs: StatePartIndex<BigSlots>(18), // (0x1) SlotDebugData { name: ".0", ty: UInt<2> },
-                    rhs: StatePartIndex<BigSlots>(21), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
-                },
-                13: CastToUInt {
-                    dest: StatePartIndex<BigSlots>(23), // (0x385) SlotDebugData { name: "", ty: UInt<10> },
-                    src: StatePartIndex<BigSlots>(22), // (0x385) SlotDebugData { name: "", ty: UInt<10> },
-                    dest_width: 10,
-                },
-                14: Copy {
-                    dest: StatePartIndex<BigSlots>(24), // (0x385) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
-                    src: StatePartIndex<BigSlots>(23), // (0x385) SlotDebugData { name: "", ty: UInt<10> },
-                },
-                15: Const {
-                    dest: StatePartIndex<BigSlots>(16), // (0x1) SlotDebugData { name: "", ty: UInt<8> },
-                    value: 0x1,
-                },
-                16: CmpEq {
-                    dest: StatePartIndex<BigSlots>(17), // (0x0) SlotDebugData { name: "", ty: Bool },
-                    lhs: StatePartIndex<BigSlots>(0), // (0x2) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_in", ty: UInt<8> },
-                    rhs: StatePartIndex<BigSlots>(16), // (0x1) SlotDebugData { name: "", ty: UInt<8> },
-                },
-                17: Const {
-                    dest: StatePartIndex<BigSlots>(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> },
-                    value: 0x0,
-                },
-                18: Copy {
-                    dest: StatePartIndex<BigSlots>(9), // (0x0) SlotDebugData { name: ".0", ty: UInt<2> },
-                    src: StatePartIndex<BigSlots>(11), // (0x0) SlotDebugData { name: "", ty: UInt<2> },
-                },
-                19: Copy {
-                    dest: StatePartIndex<BigSlots>(10), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
-                    src: StatePartIndex<BigSlots>(1), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_in", ty: UInt<8> },
-                },
-                20: Shl {
-                    dest: StatePartIndex<BigSlots>(12), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
-                    lhs: StatePartIndex<BigSlots>(10), // (0xe1) SlotDebugData { name: ".1", ty: UInt<8> },
-                    rhs: 2,
-                },
-                21: Or {
-                    dest: StatePartIndex<BigSlots>(13), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
-                    lhs: StatePartIndex<BigSlots>(9), // (0x0) SlotDebugData { name: ".0", ty: UInt<2> },
-                    rhs: StatePartIndex<BigSlots>(12), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
-                },
-                22: CastToUInt {
-                    dest: StatePartIndex<BigSlots>(14), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
-                    src: StatePartIndex<BigSlots>(13), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
-                    dest_width: 10,
-                },
-                23: Copy {
-                    dest: StatePartIndex<BigSlots>(15), // (0x384) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
-                    src: StatePartIndex<BigSlots>(14), // (0x384) SlotDebugData { name: "", ty: UInt<10> },
-                },
-                24: Const {
-                    dest: StatePartIndex<BigSlots>(7), // (0x0) SlotDebugData { name: "", ty: UInt<8> },
-                    value: 0x0,
-                },
-                25: CmpEq {
-                    dest: StatePartIndex<BigSlots>(8), // (0x0) SlotDebugData { name: "", ty: Bool },
-                    lhs: StatePartIndex<BigSlots>(0), // (0x2) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_in", ty: UInt<8> },
-                    rhs: StatePartIndex<BigSlots>(7), // (0x0) SlotDebugData { name: "", ty: UInt<8> },
-                },
-                // at: module-XXXXXXXXXX.rs:7:1
-                26: BranchIfZero {
-                    target: 28,
-                    value: StatePartIndex<BigSlots>(8), // (0x0) SlotDebugData { name: "", ty: Bool },
-                },
-                // at: module-XXXXXXXXXX.rs:8:1
-                27: Copy {
-                    dest: StatePartIndex<BigSlots>(4), // (0x386) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
-                    src: StatePartIndex<BigSlots>(15), // (0x384) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
-                },
-                // at: module-XXXXXXXXXX.rs:7:1
-                28: BranchIfNonZero {
-                    target: 33,
-                    value: StatePartIndex<BigSlots>(8), // (0x0) SlotDebugData { name: "", ty: Bool },
-                },
-                // at: module-XXXXXXXXXX.rs:9:1
-                29: BranchIfZero {
-                    target: 31,
-                    value: StatePartIndex<BigSlots>(17), // (0x0) SlotDebugData { name: "", ty: Bool },
-                },
-                // at: module-XXXXXXXXXX.rs:10:1
-                30: Copy {
-                    dest: StatePartIndex<BigSlots>(4), // (0x386) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
-                    src: StatePartIndex<BigSlots>(24), // (0x385) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
-                },
-                // at: module-XXXXXXXXXX.rs:9:1
-                31: BranchIfNonZero {
-                    target: 33,
-                    value: StatePartIndex<BigSlots>(17), // (0x0) SlotDebugData { name: "", ty: Bool },
-                },
-                // at: module-XXXXXXXXXX.rs:11:1
-                32: Copy {
-                    dest: StatePartIndex<BigSlots>(4), // (0x386) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
-                    src: StatePartIndex<BigSlots>(31), // (0x386) SlotDebugData { name: "", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
-                },
-                // at: module-XXXXXXXXXX.rs:1:1
-                33: Copy {
-                    dest: StatePartIndex<BigSlots>(5), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
-                    src: StatePartIndex<BigSlots>(4), // (0x386) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
-                },
-                34: SliceInt {
-                    dest: StatePartIndex<BigSlots>(6), // (0xe1) SlotDebugData { name: "", ty: UInt<8> },
-                    src: StatePartIndex<BigSlots>(5), // (0x386) SlotDebugData { name: "", ty: UInt<10> },
-                    start: 2,
-                    len: 8,
-                },
-                // at: module-XXXXXXXXXX.rs:6:1
-                35: AndBigWithSmallImmediate {
-                    dest: StatePartIndex<SmallSlots>(0), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} },
-                    lhs: StatePartIndex<BigSlots>(4), // (0x386) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::enum_out", ty: Enum {A(UInt<8>), B(UInt<8>), C(UInt<8>)} },
-                    rhs: 0x3,
-                },
-                // at: module-XXXXXXXXXX.rs:12:1
-                36: BranchIfSmallNeImmediate {
-                    target: 39,
-                    lhs: StatePartIndex<SmallSlots>(0), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} },
-                    rhs: 0x0,
-                },
-                // at: module-XXXXXXXXXX.rs:13:1
-                37: Copy {
-                    dest: StatePartIndex<BigSlots>(2), // (0x2) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_out", ty: UInt<8> },
-                    src: StatePartIndex<BigSlots>(7), // (0x0) SlotDebugData { name: "", ty: UInt<8> },
-                },
-                // at: module-XXXXXXXXXX.rs:14:1
-                38: Copy {
-                    dest: StatePartIndex<BigSlots>(3), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_out", ty: UInt<8> },
-                    src: StatePartIndex<BigSlots>(6), // (0xe1) SlotDebugData { name: "", ty: UInt<8> },
-                },
-                // at: module-XXXXXXXXXX.rs:12:1
-                39: BranchIfSmallNeImmediate {
-                    target: 42,
-                    lhs: StatePartIndex<SmallSlots>(0), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} },
-                    rhs: 0x1,
-                },
-                // at: module-XXXXXXXXXX.rs:15:1
-                40: Copy {
-                    dest: StatePartIndex<BigSlots>(2), // (0x2) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_out", ty: UInt<8> },
-                    src: StatePartIndex<BigSlots>(16), // (0x1) SlotDebugData { name: "", ty: UInt<8> },
-                },
-                // at: module-XXXXXXXXXX.rs:16:1
-                41: Copy {
-                    dest: StatePartIndex<BigSlots>(3), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_out", ty: UInt<8> },
-                    src: StatePartIndex<BigSlots>(6), // (0xe1) SlotDebugData { name: "", ty: UInt<8> },
-                },
-                // at: module-XXXXXXXXXX.rs:12:1
-                42: BranchIfSmallNeImmediate {
-                    target: 45,
-                    lhs: StatePartIndex<SmallSlots>(0), // (0x2 2) SlotDebugData { name: "", ty: Enum {A, B, C} },
-                    rhs: 0x2,
-                },
-                // at: module-XXXXXXXXXX.rs:17:1
-                43: Copy {
-                    dest: StatePartIndex<BigSlots>(2), // (0x2) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::which_out", ty: UInt<8> },
-                    src: StatePartIndex<BigSlots>(32), // (0x2) SlotDebugData { name: "", ty: UInt<8> },
-                },
-                // at: module-XXXXXXXXXX.rs:18:1
-                44: Copy {
-                    dest: StatePartIndex<BigSlots>(3), // (0xe1) SlotDebugData { name: "InstantiatedModule(enum_with_simple_body: enum_with_simple_body).enum_with_simple_body::data_out", ty: UInt<8> },
-                    src: StatePartIndex<BigSlots>(6), // (0xe1) SlotDebugData { name: "", ty: UInt<8> },
-                },
-                // at: module-XXXXXXXXXX.rs:1:1
-                45: Return,
-            ],
-            ..
-        },
-        pc: 45,
-        memory_write_log: [],
-        memories: StatePart {
-            value: [],
-        },
-        small_slots: StatePart {
-            value: [
-                2,
-            ],
-        },
-        big_slots: StatePart {
-            value: [
-                2,
-                225,
-                2 (modified),
-                225 (modified),
-                902,
-                902,
-                225,
-                0,
-                0,
-                0,
-                225,
-                0,
-                900,
-                900,
-                900,
-                900,
-                1,
-                0,
-                1,
-                225,
-                1,
-                900,
-                901,
-                901,
-                901,
-                2,
-                225,
-                2,
-                900,
-                902,
-                902,
-                902,
-                2,
-            ],
-        },
-        sim_only_slots: StatePart {
-            value: [],
-        },
-    },
-    io: Instance {
-        name: <simulator>::enum_with_simple_body,
-        instantiated: Module {
-            name: enum_with_simple_body,
-            ..
-        },
-    },
-    main_module: SimulationModuleState {
-        base_targets: [
-            Instance {
-                name: <simulator>::enum_with_simple_body,
-                instantiated: Module {
-                    name: enum_with_simple_body,
-                    ..
-                },
-            }.which_in,
-            Instance {
-                name: <simulator>::enum_with_simple_body,
-                instantiated: Module {
-                    name: enum_with_simple_body,
-                    ..
-                },
-            }.data_in,
-            Instance {
-                name: <simulator>::enum_with_simple_body,
-                instantiated: Module {
-                    name: enum_with_simple_body,
-                    ..
-                },
-            }.which_out,
-            Instance {
-                name: <simulator>::enum_with_simple_body,
-                instantiated: Module {
-                    name: enum_with_simple_body,
-                    ..
-                },
-            }.data_out,
-            Instance {
-                name: <simulator>::enum_with_simple_body,
-                instantiated: Module {
-                    name: enum_with_simple_body,
-                    ..
-                },
-            }.enum_out,
-        ],
-        uninitialized_ios: {},
-        io_targets: {
-            Instance {
-                name: <simulator>::enum_with_simple_body,
-                instantiated: Module {
-                    name: enum_with_simple_body,
-                    ..
-                },
-            }.data_in,
-            Instance {
-                name: <simulator>::enum_with_simple_body,
-                instantiated: Module {
-                    name: enum_with_simple_body,
-                    ..
-                },
-            }.data_out,
-            Instance {
-                name: <simulator>::enum_with_simple_body,
-                instantiated: Module {
-                    name: enum_with_simple_body,
-                    ..
-                },
-            }.enum_out,
-            Instance {
-                name: <simulator>::enum_with_simple_body,
-                instantiated: Module {
-                    name: enum_with_simple_body,
-                    ..
-                },
-            }.which_in,
-            Instance {
-                name: <simulator>::enum_with_simple_body,
-                instantiated: Module {
-                    name: enum_with_simple_body,
-                    ..
-                },
-            }.which_out,
-        },
-        did_initial_settle: true,
-        clocks_for_past: {},
-    },
-    extern_modules: [],
-    trace_decls: TraceModule {
-        name: "enum_with_simple_body",
-        children: [
-            TraceModuleIO {
-                name: "which_in",
-                child: TraceUInt {
-                    location: TraceScalarId(0),
-                    name: "which_in",
-                    ty: UInt<8>,
-                    flow: Source,
-                },
-                ty: UInt<8>,
-                flow: Source,
-            },
-            TraceModuleIO {
-                name: "data_in",
-                child: TraceUInt {
-                    location: TraceScalarId(1),
-                    name: "data_in",
-                    ty: UInt<8>,
-                    flow: Source,
-                },
-                ty: UInt<8>,
-                flow: Source,
-            },
-            TraceModuleIO {
-                name: "which_out",
-                child: TraceUInt {
-                    location: TraceScalarId(2),
-                    name: "which_out",
-                    ty: UInt<8>,
-                    flow: Sink,
-                },
-                ty: UInt<8>,
-                flow: Sink,
-            },
-            TraceModuleIO {
-                name: "data_out",
-                child: TraceUInt {
-                    location: TraceScalarId(3),
-                    name: "data_out",
-                    ty: UInt<8>,
-                    flow: Sink,
-                },
-                ty: UInt<8>,
-                flow: Sink,
-            },
-            TraceModuleIO {
-                name: "enum_out",
-                child: TraceEnumWithFields {
-                    name: "enum_out",
-                    discriminant: TraceEnumDiscriminant {
-                        location: TraceScalarId(4),
-                        name: "$tag",
-                        ty: Enum {
-                            A(UInt<8>),
-                            B(UInt<8>),
-                            C(UInt<8>),
-                        },
-                        flow: Sink,
-                    },
-                    non_empty_fields: [
-                        TraceUInt {
-                            location: TraceScalarId(5),
-                            name: "A",
-                            ty: UInt<8>,
-                            flow: Source,
-                        },
-                        TraceUInt {
-                            location: TraceScalarId(6),
-                            name: "B",
-                            ty: UInt<8>,
-                            flow: Source,
-                        },
-                        TraceUInt {
-                            location: TraceScalarId(7),
-                            name: "C",
-                            ty: UInt<8>,
-                            flow: Source,
-                        },
-                    ],
-                    ty: Enum {
-                        A(UInt<8>),
-                        B(UInt<8>),
-                        C(UInt<8>),
-                    },
-                    flow: Sink,
-                },
-                ty: Enum {
-                    A(UInt<8>),
-                    B(UInt<8>),
-                    C(UInt<8>),
-                },
-                flow: Sink,
-            },
-        ],
-    },
-    traces: [
-        SimTrace {
-            id: TraceScalarId(0),
-            kind: BigUInt {
-                index: StatePartIndex<BigSlots>(0),
-                ty: UInt<8>,
-            },
-            maybe_changed: true,
-            state: 0x02,
-            last_state: 0x02,
-        },
-        SimTrace {
-            id: TraceScalarId(1),
-            kind: BigUInt {
-                index: StatePartIndex<BigSlots>(1),
-                ty: UInt<8>,
-            },
-            maybe_changed: true,
-            state: 0xe1,
-            last_state: 0xb4,
-        },
-        SimTrace {
-            id: TraceScalarId(2),
-            kind: BigUInt {
-                index: StatePartIndex<BigSlots>(2),
-                ty: UInt<8>,
-            },
-            maybe_changed: true,
-            state: 0x02,
-            last_state: 0x02,
-        },
-        SimTrace {
-            id: TraceScalarId(3),
-            kind: BigUInt {
-                index: StatePartIndex<BigSlots>(3),
-                ty: UInt<8>,
-            },
-            maybe_changed: true,
-            state: 0xe1,
-            last_state: 0xb4,
-        },
-        SimTrace {
-            id: TraceScalarId(4),
-            kind: EnumDiscriminant {
-                index: StatePartIndex<SmallSlots>(0),
-                ty: Enum {
-                    A(UInt<8>),
-                    B(UInt<8>),
-                    C(UInt<8>),
-                },
-            },
-            maybe_changed: true,
-            state: 0x2,
-            last_state: 0x2,
-        },
-        SimTrace {
-            id: TraceScalarId(5),
-            kind: BigUInt {
-                index: StatePartIndex<BigSlots>(6),
-                ty: UInt<8>,
-            },
-            maybe_changed: true,
-            state: 0xe1,
-            last_state: 0xb4,
-        },
-        SimTrace {
-            id: TraceScalarId(6),
-            kind: BigUInt {
-                index: StatePartIndex<BigSlots>(6),
-                ty: UInt<8>,
-            },
-            maybe_changed: true,
-            state: 0xe1,
-            last_state: 0xb4,
-        },
-        SimTrace {
-            id: TraceScalarId(7),
-            kind: BigUInt {
-                index: StatePartIndex<BigSlots>(6),
-                ty: UInt<8>,
-            },
-            maybe_changed: true,
-            state: 0xe1,
-            last_state: 0xb4,
-        },
-    ],
-    trace_memories: {},
-    trace_writers: [
-        Running(
-            VcdWriter {
-                finished_init: true,
-                timescale: 1 ps,
-                ..
-            },
-        ),
-    ],
-    clocks_triggered: [],
-    event_queue: EventQueue(EventQueueData {
-        instant: 18 μs,
-        events: {},
-    }),
-    waiting_sensitivity_sets_by_address: {},
-    waiting_sensitivity_sets_by_compiled_value: {},
-    ..
-}
\ No newline at end of file
diff --git a/crates/fayalite/tests/sim/expected/enum_with_simple_body.vcd b/crates/fayalite/tests/sim/expected/enum_with_simple_body.vcd
deleted file mode 100644
index dfe0dc1..0000000
--- a/crates/fayalite/tests/sim/expected/enum_with_simple_body.vcd
+++ /dev/null
@@ -1,133 +0,0 @@
-$timescale 1 ps $end
-$scope module enum_with_simple_body $end
-$var wire 8 J&-ne which_in $end
-$var wire 8 \7mo/ data_in $end
-$var wire 8 ,`>ir which_out $end
-$var wire 8 0_gMP data_out $end
-$scope struct enum_out $end
-$var string 1 kFH/w \$tag $end
-$var wire 8 |EI_= A $end
-$var wire 8 !pRd4 B $end
-$var wire 8 &RAbd C $end
-$upscope $end
-$upscope $end
-$enddefinitions $end
-$dumpvars
-b0 J&-ne
-b0 \7mo/
-b0 ,`>ir
-b0 0_gMP
-sA\x20(0) kFH/w
-b0 |EI_=
-b0 !pRd4
-b0 &RAbd
-$end
-#1000000
-b101101 \7mo/
-b101101 0_gMP
-b101101 |EI_=
-b101101 !pRd4
-b101101 &RAbd
-#2000000
-b1011010 \7mo/
-b1011010 0_gMP
-b1011010 |EI_=
-b1011010 !pRd4
-b1011010 &RAbd
-#3000000
-b10000111 \7mo/
-b10000111 0_gMP
-b10000111 |EI_=
-b10000111 !pRd4
-b10000111 &RAbd
-#4000000
-b10110100 \7mo/
-b10110100 0_gMP
-b10110100 |EI_=
-b10110100 !pRd4
-b10110100 &RAbd
-#5000000
-b11100001 \7mo/
-b11100001 0_gMP
-b11100001 |EI_=
-b11100001 !pRd4
-b11100001 &RAbd
-#6000000
-b1 J&-ne
-b0 \7mo/
-b1 ,`>ir
-b0 0_gMP
-sB\x20(1) kFH/w
-b0 |EI_=
-b0 !pRd4
-b0 &RAbd
-#7000000
-b101101 \7mo/
-b101101 0_gMP
-b101101 |EI_=
-b101101 !pRd4
-b101101 &RAbd
-#8000000
-b1011010 \7mo/
-b1011010 0_gMP
-b1011010 |EI_=
-b1011010 !pRd4
-b1011010 &RAbd
-#9000000
-b10000111 \7mo/
-b10000111 0_gMP
-b10000111 |EI_=
-b10000111 !pRd4
-b10000111 &RAbd
-#10000000
-b10110100 \7mo/
-b10110100 0_gMP
-b10110100 |EI_=
-b10110100 !pRd4
-b10110100 &RAbd
-#11000000
-b11100001 \7mo/
-b11100001 0_gMP
-b11100001 |EI_=
-b11100001 !pRd4
-b11100001 &RAbd
-#12000000
-b10 J&-ne
-b0 \7mo/
-b10 ,`>ir
-b0 0_gMP
-sC\x20(2) kFH/w
-b0 |EI_=
-b0 !pRd4
-b0 &RAbd
-#13000000
-b101101 \7mo/
-b101101 0_gMP
-b101101 |EI_=
-b101101 !pRd4
-b101101 &RAbd
-#14000000
-b1011010 \7mo/
-b1011010 0_gMP
-b1011010 |EI_=
-b1011010 !pRd4
-b1011010 &RAbd
-#15000000
-b10000111 \7mo/
-b10000111 0_gMP
-b10000111 |EI_=
-b10000111 !pRd4
-b10000111 &RAbd
-#16000000
-b10110100 \7mo/
-b10110100 0_gMP
-b10110100 |EI_=
-b10110100 !pRd4
-b10110100 &RAbd
-#17000000
-b11100001 \7mo/
-b11100001 0_gMP
-b11100001 |EI_=
-b11100001 !pRd4
-b11100001 &RAbd
-#18000000
diff --git a/crates/fayalite/tests/sim/expected/enums.txt b/crates/fayalite/tests/sim/expected/enums.txt
index d2da2d9..a3a52cb 100644
--- a/crates/fayalite/tests/sim/expected/enums.txt
+++ b/crates/fayalite/tests/sim/expected/enums.txt
@@ -1746,7 +1746,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -1755,7 +1754,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1764,7 +1762,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1774,7 +1771,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<2>,
             },
-            maybe_changed: false,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1784,7 +1780,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<4>,
             },
-            maybe_changed: false,
             state: 0xf,
             last_state: 0xf,
         },
@@ -1794,7 +1789,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1804,7 +1798,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -1817,7 +1810,6 @@ Simulation {
                     HdlSome(Bundle {0: UInt<1>, 1: Bool}),
                 },
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1827,7 +1819,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1836,7 +1827,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(9),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1849,7 +1839,6 @@ Simulation {
                     HdlSome(Bundle {0: UInt<1>, 1: Bool}),
                 },
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1859,7 +1848,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1868,7 +1856,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1882,7 +1869,6 @@ Simulation {
                     C(Bundle {a: Array<UInt<1>, 2>, b: SInt<2>}),
                 },
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1892,7 +1878,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(27),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1901,7 +1886,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(28),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1911,7 +1895,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(34),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1921,7 +1904,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(35),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1931,7 +1913,6 @@ 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 48a3af5..f49106f 100644
--- a/crates/fayalite/tests/sim/expected/extern_module.txt
+++ b/crates/fayalite/tests/sim/expected/extern_module.txt
@@ -221,7 +221,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -230,7 +229,6 @@ 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 d488666..365830f 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 (modified),
+                1,
                 101,
             ],
         },
@@ -280,7 +280,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -289,7 +288,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -299,7 +297,6 @@ 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 c5d1341..6a43497 100644
--- a/crates/fayalite/tests/sim/expected/last_connect.txt
+++ b/crates/fayalite/tests/sim/expected/last_connect.txt
@@ -433,7 +433,7 @@ Simulation {
                 1,
                 1,
                 1,
-                7 (modified),
+                7,
                 7,
                 3,
                 0,
@@ -614,7 +614,6 @@ Simulation {
                     HdlSome(Array<Bool, 4>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -623,7 +622,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -632,7 +630,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -641,7 +638,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -650,7 +646,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -663,7 +658,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -673,7 +667,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x03,
             last_state: 0x02,
         },
@@ -683,7 +676,6 @@ 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 0d1a6db..c521d72 100644
--- a/crates/fayalite/tests/sim/expected/many_memories.txt
+++ b/crates/fayalite/tests/sim/expected/many_memories.txt
@@ -5545,7 +5545,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5554,7 +5553,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5563,7 +5561,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5572,7 +5569,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5582,7 +5578,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5591,7 +5586,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(5),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5600,7 +5594,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(6),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5609,7 +5602,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5619,7 +5611,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5628,7 +5619,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(9),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5637,7 +5627,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(10),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5646,7 +5635,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(11),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5656,7 +5644,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(12),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5665,7 +5652,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5674,7 +5660,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(14),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5683,7 +5668,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(15),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5693,7 +5677,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5702,7 +5685,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5711,7 +5693,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(18),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5720,7 +5701,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5730,7 +5710,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5739,7 +5718,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(21),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5748,7 +5726,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(22),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5757,7 +5734,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(23),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5767,7 +5743,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(24),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5776,7 +5751,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(25),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5785,7 +5759,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(26),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5794,7 +5767,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5804,7 +5776,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(28),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -5813,7 +5784,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(29),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5822,7 +5792,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5831,7 +5800,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5841,7 +5809,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(32),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5850,7 +5817,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5859,7 +5825,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5868,7 +5833,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(35),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5877,7 +5841,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5887,7 +5850,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(37),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5896,7 +5858,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(38),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5905,7 +5866,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5914,7 +5874,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(40),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5923,7 +5882,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(41),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5933,7 +5891,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5942,7 +5899,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(43),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5951,7 +5907,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(44),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -5960,7 +5915,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(45),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5969,7 +5923,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(46),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -5979,7 +5932,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(47),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5988,7 +5940,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(48),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -5997,7 +5948,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(49),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6006,7 +5956,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(50),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6015,7 +5964,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(51),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6025,7 +5973,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(52),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6034,7 +5981,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(53),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6043,7 +5989,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(54),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6052,7 +5997,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(55),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6061,7 +6005,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(56),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6071,7 +6014,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(57),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6080,7 +6022,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(58),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6089,7 +6030,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(59),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6098,7 +6038,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(60),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6107,7 +6046,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(61),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6117,7 +6055,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(62),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6126,7 +6063,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(63),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6135,7 +6071,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(64),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6144,7 +6079,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(65),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6153,7 +6087,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(66),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6163,7 +6096,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(67),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6172,7 +6104,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(68),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6181,7 +6112,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(69),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6190,7 +6120,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(70),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6199,7 +6128,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(71),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6209,7 +6137,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(72),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6218,7 +6145,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(73),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6227,7 +6153,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(74),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6236,7 +6161,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(75),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6246,7 +6170,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(76),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6255,7 +6178,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(77),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6264,7 +6186,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(78),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6273,7 +6194,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(79),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6282,7 +6202,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(80),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6292,7 +6211,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(83),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6301,7 +6219,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(84),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6310,7 +6227,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(85),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6319,7 +6235,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(86),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6329,7 +6244,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(87),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6338,7 +6252,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(88),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6347,7 +6260,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(89),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6356,7 +6268,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(90),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6365,7 +6276,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(91),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6375,7 +6285,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(94),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6384,7 +6293,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(95),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6393,7 +6301,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(96),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6402,7 +6309,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(97),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6412,7 +6318,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(98),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6421,7 +6326,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(99),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6430,7 +6334,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(100),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6439,7 +6342,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(101),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6448,7 +6350,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(102),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6458,7 +6359,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(105),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6467,7 +6367,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(106),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6476,7 +6375,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(107),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6485,7 +6383,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(108),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6495,7 +6392,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(109),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6504,7 +6400,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(110),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6513,7 +6408,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(111),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6522,7 +6416,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(112),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6531,7 +6424,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(113),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6541,7 +6433,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(116),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6550,7 +6441,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(117),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6559,7 +6449,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(118),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6568,7 +6457,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(119),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6578,7 +6466,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(120),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6587,7 +6474,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(121),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6596,7 +6482,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(122),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6605,7 +6490,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(123),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6614,7 +6498,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(124),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6624,7 +6507,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(127),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6633,7 +6515,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(128),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6642,7 +6523,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(129),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6651,7 +6531,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(130),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6661,7 +6540,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(131),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6670,7 +6548,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(132),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6679,7 +6556,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(133),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6688,7 +6564,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(134),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6697,7 +6572,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(135),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6707,7 +6581,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(138),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6716,7 +6589,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(139),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6725,7 +6597,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(140),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6734,7 +6605,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(141),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6744,7 +6614,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(142),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6753,7 +6622,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(143),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6762,7 +6630,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(144),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6771,7 +6638,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(145),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6780,7 +6646,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(146),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6790,7 +6655,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(149),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xf,
         },
@@ -6799,7 +6663,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(150),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -6808,7 +6671,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(151),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6817,7 +6679,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(152),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6827,7 +6688,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(153),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6836,7 +6696,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(154),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6845,7 +6704,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(155),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -6854,7 +6712,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(156),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -6863,7 +6720,6 @@ 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 c96da4f..0358bb3 100644
--- a/crates/fayalite/tests/sim/expected/memories.txt
+++ b/crates/fayalite/tests/sim/expected/memories.txt
@@ -1168,7 +1168,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1177,7 +1176,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1186,7 +1184,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1196,7 +1193,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xb0,
             last_state: 0xb0,
         },
@@ -1206,7 +1202,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: SInt<8>,
             },
-            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1216,7 +1211,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1225,7 +1219,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1234,7 +1227,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1244,7 +1236,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xd0,
             last_state: 0xd0,
         },
@@ -1254,7 +1245,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: SInt<8>,
             },
-            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1263,7 +1253,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(10),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1272,7 +1261,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(11),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1282,7 +1270,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(12),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1291,7 +1278,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1300,7 +1286,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(14),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1310,7 +1295,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xb0,
             last_state: 0xb0,
         },
@@ -1320,7 +1304,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: SInt<8>,
             },
-            maybe_changed: true,
             state: 0xc0,
             last_state: 0xc0,
         },
@@ -1330,7 +1313,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1339,7 +1321,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(18),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1348,7 +1329,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1358,7 +1338,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0xd0,
             last_state: 0xd0,
         },
@@ -1368,7 +1347,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(21),
                 ty: SInt<8>,
             },
-            maybe_changed: true,
             state: 0xe0,
             last_state: 0xe0,
         },
@@ -1377,7 +1355,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(22),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1386,7 +1363,6 @@ 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 1f78fcf..b4041ba 100644
--- a/crates/fayalite/tests/sim/expected/memories2.txt
+++ b/crates/fayalite/tests/sim/expected/memories2.txt
@@ -943,7 +943,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<3>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -952,7 +951,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -961,7 +959,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -971,7 +968,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -980,7 +976,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -990,7 +985,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<2>,
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -999,7 +993,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1009,7 +1002,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(7),
                 ty: UInt<3>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1018,7 +1010,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(8),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1027,7 +1018,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(9),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1040,7 +1030,6 @@ Simulation {
                     HdlSome(Bool),
                 },
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1049,7 +1038,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1058,7 +1046,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(11),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1071,7 +1058,6 @@ Simulation {
                     HdlSome(Bool),
                 },
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1080,7 +1066,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1089,7 +1074,6 @@ 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 75720a8..2213912 100644
--- a/crates/fayalite/tests/sim/expected/memories3.txt
+++ b/crates/fayalite/tests/sim/expected/memories3.txt
@@ -2391,7 +2391,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<3>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2400,7 +2399,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2409,7 +2407,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2419,7 +2416,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2429,7 +2425,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2439,7 +2434,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2449,7 +2443,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2459,7 +2452,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(7),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2469,7 +2461,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2479,7 +2470,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2489,7 +2479,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2499,7 +2488,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<3>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2508,7 +2496,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2517,7 +2504,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2527,7 +2513,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2537,7 +2522,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2547,7 +2531,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(16),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2557,7 +2540,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(17),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2567,7 +2549,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2577,7 +2558,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(19),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2587,7 +2567,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(20),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2597,7 +2576,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(21),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2606,7 +2584,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(22),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2615,7 +2592,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(23),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2624,7 +2600,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(24),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2633,7 +2608,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(25),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2642,7 +2616,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(26),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2651,7 +2624,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2660,7 +2632,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(28),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2669,7 +2640,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(29),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2679,7 +2649,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(30),
                 ty: UInt<3>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2688,7 +2657,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2697,7 +2665,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2707,7 +2674,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(33),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2717,7 +2683,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(34),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2727,7 +2692,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(35),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2737,7 +2701,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(36),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2747,7 +2710,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(37),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2757,7 +2719,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(38),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2767,7 +2728,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(39),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2777,7 +2737,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(40),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2787,7 +2746,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(57),
                 ty: UInt<3>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2796,7 +2754,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(58),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2805,7 +2762,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(59),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -2815,7 +2771,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(60),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2825,7 +2780,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(61),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2835,7 +2789,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(62),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2845,7 +2798,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(63),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2855,7 +2807,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(64),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2865,7 +2816,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(65),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2875,7 +2825,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(66),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2885,7 +2834,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(67),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x00,
             last_state: 0x00,
         },
@@ -2894,7 +2842,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(68),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2903,7 +2850,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(69),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2912,7 +2858,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(70),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2921,7 +2866,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(71),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2930,7 +2874,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(72),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2939,7 +2882,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(73),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2948,7 +2890,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(74),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2957,7 +2898,6 @@ 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 a1de89a..3f7a55e 100644
--- a/crates/fayalite/tests/sim/expected/mod1.txt
+++ b/crates/fayalite/tests/sim/expected/mod1.txt
@@ -445,7 +445,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xa,
             last_state: 0x3,
         },
@@ -455,7 +454,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(1),
                 ty: SInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x3,
         },
@@ -465,7 +463,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: SInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -475,7 +472,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xe,
         },
@@ -485,7 +481,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(8),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xa,
             last_state: 0x3,
         },
@@ -495,7 +490,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: SInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x3,
         },
@@ -505,7 +499,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: SInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -515,7 +508,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xf,
             last_state: 0xe,
         },
@@ -525,7 +517,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<4>,
             },
-            maybe_changed: true,
             state: 0xa,
             last_state: 0x3,
         },
@@ -535,7 +526,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: SInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x3,
         },
@@ -545,7 +535,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(6),
                 ty: SInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -555,7 +544,6 @@ 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 c9adae4..94072ac 100644
--- a/crates/fayalite/tests/sim/expected/phantom_const.txt
+++ b/crates/fayalite/tests/sim/expected/phantom_const.txt
@@ -373,7 +373,6 @@ Simulation {
                     ["a","b"],
                 ),
             },
-            maybe_changed: true,
             state: PhantomConst,
             last_state: PhantomConst,
         },
@@ -384,7 +383,6 @@ Simulation {
                     ["a","b"],
                 ),
             },
-            maybe_changed: true,
             state: PhantomConst,
             last_state: PhantomConst,
         },
@@ -394,7 +392,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(0),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -403,7 +400,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -412,7 +408,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -423,7 +418,6 @@ 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 e349bbd..570c08d 100644
--- a/crates/fayalite/tests/sim/expected/queue_1_false_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_1_false_false.txt
@@ -1722,7 +1722,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1731,7 +1730,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1744,7 +1742,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1754,7 +1751,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1763,7 +1759,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1776,7 +1771,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1786,7 +1780,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1795,7 +1788,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1805,7 +1797,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1815,7 +1806,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1824,7 +1814,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1833,7 +1822,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1843,7 +1831,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1853,7 +1840,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1862,7 +1848,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1871,7 +1856,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1881,7 +1865,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -1890,7 +1873,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1900,7 +1882,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1910,7 +1891,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1919,7 +1899,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1928,7 +1907,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1937,7 +1915,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1946,7 +1923,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1955,7 +1931,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1964,7 +1939,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1973,7 +1947,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1982,7 +1955,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1992,7 +1964,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x19,
             last_state: 0x19,
         },
@@ -2002,7 +1973,6 @@ 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 3a31636..5bff275 100644
--- a/crates/fayalite/tests/sim/expected/queue_1_false_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_1_false_true.txt
@@ -1701,7 +1701,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1710,7 +1709,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1723,7 +1721,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1733,7 +1730,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1742,7 +1738,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1755,7 +1750,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1765,7 +1759,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1774,7 +1767,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1784,7 +1776,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1794,7 +1785,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1803,7 +1793,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1812,7 +1801,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1822,7 +1810,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1832,7 +1819,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1841,7 +1827,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1850,7 +1835,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1860,7 +1844,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1869,7 +1852,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1879,7 +1861,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1889,7 +1870,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1898,7 +1878,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1907,7 +1886,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1916,7 +1894,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1925,7 +1902,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1934,7 +1910,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1943,7 +1918,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1952,7 +1926,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1961,7 +1934,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1971,7 +1943,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1981,7 +1952,6 @@ 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 9dd3851..d9771dc 100644
--- a/crates/fayalite/tests/sim/expected/queue_1_true_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_1_true_false.txt
@@ -1732,7 +1732,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1741,7 +1740,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1754,7 +1752,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1764,7 +1761,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1773,7 +1769,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1786,7 +1781,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1796,7 +1790,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1805,7 +1798,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1815,7 +1807,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1825,7 +1816,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1834,7 +1824,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1843,7 +1832,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1853,7 +1841,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1863,7 +1850,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1872,7 +1858,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1881,7 +1866,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1891,7 +1875,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -1900,7 +1883,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1910,7 +1892,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1920,7 +1901,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1929,7 +1909,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1938,7 +1917,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1947,7 +1925,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1956,7 +1933,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1965,7 +1941,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1974,7 +1949,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1983,7 +1957,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1992,7 +1965,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2002,7 +1974,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x1f,
             last_state: 0x1f,
         },
@@ -2012,7 +1983,6 @@ 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 5762f24..0e16d2d 100644
--- a/crates/fayalite/tests/sim/expected/queue_1_true_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_1_true_true.txt
@@ -1711,7 +1711,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1720,7 +1719,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1733,7 +1731,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1743,7 +1740,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1752,7 +1748,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1765,7 +1760,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1775,7 +1769,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1784,7 +1777,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1794,7 +1786,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1804,7 +1795,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1813,7 +1803,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1822,7 +1811,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1832,7 +1820,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1842,7 +1829,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1851,7 +1837,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1860,7 +1845,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1870,7 +1854,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1879,7 +1862,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1889,7 +1871,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1899,7 +1880,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<0>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1908,7 +1888,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1917,7 +1896,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1926,7 +1904,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1935,7 +1912,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1944,7 +1920,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1953,7 +1928,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1962,7 +1936,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1971,7 +1944,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1981,7 +1953,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1991,7 +1962,6 @@ 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 c2cb51a..23b0a7b 100644
--- a/crates/fayalite/tests/sim/expected/queue_2_false_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_2_false_false.txt
@@ -1740,7 +1740,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1749,7 +1748,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1762,7 +1760,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1772,7 +1769,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1781,7 +1777,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1794,7 +1789,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1804,7 +1798,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1813,7 +1806,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1823,7 +1815,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1833,7 +1824,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1842,7 +1832,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1851,7 +1840,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1861,7 +1849,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1871,7 +1858,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1880,7 +1866,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1889,7 +1874,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1899,7 +1883,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -1908,7 +1891,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1918,7 +1900,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1928,7 +1909,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1937,7 +1917,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1946,7 +1925,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1955,7 +1933,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1964,7 +1941,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1973,7 +1949,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1982,7 +1957,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1991,7 +1965,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2000,7 +1973,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2010,7 +1982,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x23,
             last_state: 0x23,
         },
@@ -2020,7 +1991,6 @@ 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 f229451..a057fa7 100644
--- a/crates/fayalite/tests/sim/expected/queue_2_false_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_2_false_true.txt
@@ -1719,7 +1719,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1728,7 +1727,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1741,7 +1739,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1751,7 +1748,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1760,7 +1756,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1773,7 +1768,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1783,7 +1777,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1792,7 +1785,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1802,7 +1794,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1812,7 +1803,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1821,7 +1811,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1830,7 +1819,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1840,7 +1828,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1850,7 +1837,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1859,7 +1845,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1868,7 +1853,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1878,7 +1862,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1887,7 +1870,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1897,7 +1879,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1907,7 +1888,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1916,7 +1896,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1925,7 +1904,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1934,7 +1912,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1943,7 +1920,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1952,7 +1928,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1961,7 +1936,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1970,7 +1944,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1979,7 +1952,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1989,7 +1961,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1999,7 +1970,6 @@ 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 e137316..1f6d8ec 100644
--- a/crates/fayalite/tests/sim/expected/queue_2_true_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_2_true_false.txt
@@ -1750,7 +1750,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1759,7 +1758,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1772,7 +1770,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1782,7 +1779,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1791,7 +1787,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1804,7 +1799,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1814,7 +1808,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1823,7 +1816,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1833,7 +1825,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1843,7 +1834,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1852,7 +1842,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1861,7 +1850,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1871,7 +1859,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x26,
             last_state: 0x26,
         },
@@ -1881,7 +1868,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1890,7 +1876,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1899,7 +1884,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1909,7 +1893,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1918,7 +1901,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1928,7 +1910,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1938,7 +1919,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1947,7 +1927,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1956,7 +1935,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1965,7 +1943,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1974,7 +1951,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1983,7 +1959,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1992,7 +1967,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2001,7 +1975,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2010,7 +1983,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2020,7 +1992,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -2030,7 +2001,6 @@ 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 5203027..25b08a1 100644
--- a/crates/fayalite/tests/sim/expected/queue_2_true_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_2_true_true.txt
@@ -1729,7 +1729,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1738,7 +1737,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1751,7 +1749,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1761,7 +1758,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1770,7 +1766,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1783,7 +1778,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1793,7 +1787,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1802,7 +1795,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1812,7 +1804,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1822,7 +1813,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1831,7 +1821,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1840,7 +1829,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1850,7 +1838,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1860,7 +1847,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1869,7 +1855,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1878,7 +1863,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1888,7 +1872,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1897,7 +1880,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1907,7 +1889,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1917,7 +1898,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<1>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1926,7 +1906,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1935,7 +1914,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1944,7 +1922,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1953,7 +1930,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1962,7 +1938,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1971,7 +1946,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1980,7 +1954,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1989,7 +1962,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1999,7 +1971,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -2009,7 +1980,6 @@ 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 f5641ce..6f65006 100644
--- a/crates/fayalite/tests/sim/expected/queue_3_false_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_3_false_false.txt
@@ -1759,7 +1759,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1768,7 +1767,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1781,7 +1779,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1791,7 +1788,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x28,
             last_state: 0x28,
         },
@@ -1800,7 +1796,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1813,7 +1808,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1823,7 +1817,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1832,7 +1825,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1842,7 +1834,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1852,7 +1843,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1861,7 +1851,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1870,7 +1859,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1880,7 +1868,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x27,
             last_state: 0x27,
         },
@@ -1890,7 +1877,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1899,7 +1885,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1908,7 +1893,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1918,7 +1902,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x28,
             last_state: 0x28,
         },
@@ -1927,7 +1910,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1937,7 +1919,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1947,7 +1928,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1956,7 +1936,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1965,7 +1944,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1974,7 +1952,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1983,7 +1960,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1992,7 +1968,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2001,7 +1976,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2010,7 +1984,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2019,7 +1992,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2029,7 +2001,6 @@ 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 cde5489..4cffcd6 100644
--- a/crates/fayalite/tests/sim/expected/queue_3_false_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_3_false_true.txt
@@ -1738,7 +1738,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1747,7 +1746,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1760,7 +1758,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1770,7 +1767,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1779,7 +1775,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1792,7 +1787,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1802,7 +1796,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1811,7 +1804,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1821,7 +1813,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1831,7 +1822,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1840,7 +1830,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1849,7 +1838,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1859,7 +1847,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1869,7 +1856,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1878,7 +1864,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1887,7 +1872,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1897,7 +1881,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2a,
             last_state: 0x2a,
         },
@@ -1906,7 +1889,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1916,7 +1898,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1926,7 +1907,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1935,7 +1915,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1944,7 +1923,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1953,7 +1931,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1962,7 +1939,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1971,7 +1947,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1980,7 +1955,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1989,7 +1963,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1998,7 +1971,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2008,7 +1980,6 @@ 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 d943150..03d3aba 100644
--- a/crates/fayalite/tests/sim/expected/queue_3_true_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_3_true_false.txt
@@ -1769,7 +1769,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1778,7 +1777,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1791,7 +1789,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1801,7 +1798,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1810,7 +1806,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1823,7 +1818,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1833,7 +1827,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1842,7 +1835,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1852,7 +1844,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1862,7 +1853,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1871,7 +1861,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1880,7 +1869,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1890,7 +1878,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1900,7 +1887,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1909,7 +1895,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1918,7 +1903,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1928,7 +1912,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1937,7 +1920,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1947,7 +1929,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1957,7 +1938,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1966,7 +1946,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1975,7 +1954,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1984,7 +1962,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1993,7 +1970,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2002,7 +1978,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2011,7 +1986,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2020,7 +1994,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2029,7 +2002,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2039,7 +2011,6 @@ 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 4a0f664..a663e23 100644
--- a/crates/fayalite/tests/sim/expected/queue_3_true_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_3_true_true.txt
@@ -1748,7 +1748,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1757,7 +1756,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1770,7 +1768,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1780,7 +1777,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1789,7 +1785,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1802,7 +1797,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1812,7 +1806,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1821,7 +1814,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1831,7 +1823,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1841,7 +1832,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1850,7 +1840,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1859,7 +1848,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1869,7 +1857,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1879,7 +1866,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1888,7 +1874,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1897,7 +1882,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1907,7 +1891,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1916,7 +1899,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1926,7 +1908,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1936,7 +1917,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x2,
             last_state: 0x2,
         },
@@ -1945,7 +1925,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1954,7 +1933,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1963,7 +1941,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1972,7 +1949,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1981,7 +1957,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1990,7 +1965,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1999,7 +1973,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2008,7 +1981,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2018,7 +1990,6 @@ 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 4e0a067..445d9d0 100644
--- a/crates/fayalite/tests/sim/expected/queue_4_false_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_4_false_false.txt
@@ -1748,7 +1748,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1757,7 +1756,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1770,7 +1768,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1780,7 +1777,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1789,7 +1785,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1802,7 +1797,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1812,7 +1806,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1821,7 +1814,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1831,7 +1823,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
-            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1841,7 +1832,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1850,7 +1840,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1859,7 +1848,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1869,7 +1857,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1879,7 +1866,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1888,7 +1874,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1897,7 +1882,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1907,7 +1891,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1916,7 +1899,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1926,7 +1908,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1936,7 +1917,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1945,7 +1925,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1954,7 +1933,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1963,7 +1941,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1972,7 +1949,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1981,7 +1957,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1990,7 +1965,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1999,7 +1973,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2008,7 +1981,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2018,7 +1990,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -2028,7 +1999,6 @@ 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 a374f44..5e7ada2 100644
--- a/crates/fayalite/tests/sim/expected/queue_4_false_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_4_false_true.txt
@@ -1727,7 +1727,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1736,7 +1735,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1749,7 +1747,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1759,7 +1756,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1768,7 +1764,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1781,7 +1776,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1791,7 +1785,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1800,7 +1793,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1810,7 +1802,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
-            maybe_changed: true,
             state: 0x3,
             last_state: 0x3,
         },
@@ -1820,7 +1811,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1829,7 +1819,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1838,7 +1827,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1848,7 +1836,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1858,7 +1845,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1867,7 +1853,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1876,7 +1861,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1886,7 +1870,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -1895,7 +1878,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1905,7 +1887,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1915,7 +1896,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1924,7 +1904,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1933,7 +1912,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1942,7 +1920,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1951,7 +1928,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1960,7 +1936,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1969,7 +1944,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1978,7 +1952,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1987,7 +1960,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1997,7 +1969,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2b,
             last_state: 0x2b,
         },
@@ -2007,7 +1978,6 @@ 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 7d20f26..2701c1d 100644
--- a/crates/fayalite/tests/sim/expected/queue_4_true_false.txt
+++ b/crates/fayalite/tests/sim/expected/queue_4_true_false.txt
@@ -1758,7 +1758,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1767,7 +1766,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1780,7 +1778,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1790,7 +1787,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1799,7 +1795,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1812,7 +1807,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1822,7 +1816,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1831,7 +1824,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1841,7 +1833,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
-            maybe_changed: true,
             state: 0x4,
             last_state: 0x4,
         },
@@ -1851,7 +1842,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1860,7 +1850,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1869,7 +1858,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1879,7 +1867,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1889,7 +1876,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1898,7 +1884,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1907,7 +1892,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1917,7 +1901,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1926,7 +1909,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1936,7 +1918,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1946,7 +1927,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1955,7 +1935,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1964,7 +1943,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1973,7 +1951,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1982,7 +1959,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1991,7 +1967,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2000,7 +1975,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2009,7 +1983,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -2018,7 +1991,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2028,7 +2000,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -2038,7 +2009,6 @@ 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 a0ee509..a52069d 100644
--- a/crates/fayalite/tests/sim/expected/queue_4_true_true.txt
+++ b/crates/fayalite/tests/sim/expected/queue_4_true_true.txt
@@ -1737,7 +1737,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1746,7 +1745,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1759,7 +1757,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1769,7 +1766,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1778,7 +1774,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1791,7 +1786,6 @@ Simulation {
                     HdlSome(UInt<8>),
                 },
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1801,7 +1795,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1810,7 +1803,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1820,7 +1812,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<3>,
             },
-            maybe_changed: true,
             state: 0x4,
             last_state: 0x4,
         },
@@ -1830,7 +1821,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(11),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1839,7 +1829,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1848,7 +1837,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1858,7 +1846,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(14),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x29,
             last_state: 0x29,
         },
@@ -1868,7 +1855,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(15),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1877,7 +1863,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(16),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1886,7 +1871,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(17),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -1896,7 +1880,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(18),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -1905,7 +1888,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(19),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1915,7 +1897,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(22),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1925,7 +1906,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(25),
                 ty: UInt<2>,
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1934,7 +1914,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(27),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1943,7 +1922,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(30),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1952,7 +1930,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1961,7 +1938,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1970,7 +1946,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1979,7 +1954,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1988,7 +1962,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1997,7 +1970,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(39),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -2007,7 +1979,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(42),
                 ty: UInt<8>,
             },
-            maybe_changed: true,
             state: 0x2c,
             last_state: 0x2c,
         },
@@ -2017,7 +1988,6 @@ 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 6562d4d..1fb5fee 100644
--- a/crates/fayalite/tests/sim/expected/ripple_counter.txt
+++ b/crates/fayalite/tests/sim/expected/ripple_counter.txt
@@ -687,7 +687,7 @@ Simulation {
                 1,
                 0,
                 0,
-                0 (modified),
+                0,
                 0,
                 0,
                 0,
@@ -698,7 +698,7 @@ Simulation {
                 1,
                 0,
                 0,
-                0 (modified),
+                0,
                 0,
                 0,
                 0,
@@ -709,7 +709,7 @@ Simulation {
                 1,
                 0,
                 0,
-                0 (modified),
+                0,
                 0,
                 0,
             ],
@@ -1284,7 +1284,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1294,7 +1293,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(1),
                 ty: UInt<6>,
             },
-            maybe_changed: false,
             state: 0x00,
             last_state: 0x00,
         },
@@ -1303,7 +1301,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1312,7 +1309,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1321,7 +1317,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1330,7 +1325,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(5),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1339,7 +1333,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1348,7 +1341,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1357,7 +1349,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(24),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1366,7 +1357,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(33),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1375,7 +1365,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(34),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1384,7 +1373,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(31),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1393,7 +1381,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(32),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1402,7 +1389,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(36),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1411,7 +1397,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(44),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1420,7 +1405,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(45),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1429,7 +1413,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(42),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1438,7 +1421,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(43),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1447,7 +1429,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(47),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1456,7 +1437,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(55),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1465,7 +1445,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(56),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1474,7 +1453,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(53),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1483,7 +1461,6 @@ 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 1eaa378..2e1b176 100644
--- a/crates/fayalite/tests/sim/expected/shift_register.txt
+++ b/crates/fayalite/tests/sim/expected/shift_register.txt
@@ -458,7 +458,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x0,
         },
@@ -467,7 +466,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -476,7 +474,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -485,7 +482,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -494,7 +490,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(4),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -503,7 +498,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -512,7 +506,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(9),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -521,7 +514,6 @@ 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 c66e77e..df9c092 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,
-                49 (modified),
-                50 (modified),
-                50 (modified),
+                0,
+                49,
+                50,
+                50,
             ],
         },
         sim_only_slots: StatePart {
@@ -356,7 +356,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -365,7 +364,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -374,7 +372,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -384,7 +381,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -394,7 +390,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -404,7 +399,6 @@ 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 ae88960..917dd5d 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,
-                49 (modified),
-                50 (modified),
-                50 (modified),
+                0,
+                49,
+                50,
+                50,
             ],
         },
         sim_only_slots: StatePart {
@@ -356,7 +356,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -365,7 +364,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -374,7 +372,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -384,7 +381,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -394,7 +390,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -404,7 +399,6 @@ 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 2ae2fbe..827f3cc 100644
--- a/crates/fayalite/tests/sim/expected/sim_only_connects.txt
+++ b/crates/fayalite/tests/sim/expected/sim_only_connects.txt
@@ -392,7 +392,7 @@ Simulation {
                 0,
                 1,
                 0,
-                1 (modified),
+                1,
                 0,
                 0,
                 0,
@@ -400,7 +400,7 @@ Simulation {
                 0,
                 1,
                 0,
-                1 (modified),
+                1,
                 0,
             ],
         },
@@ -1252,7 +1252,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1261,7 +1260,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1271,7 +1269,6 @@ 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",
             },
@@ -1285,7 +1282,6 @@ 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",
             },
@@ -1299,7 +1295,6 @@ 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",
@@ -1317,7 +1312,6 @@ 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",
@@ -1334,7 +1328,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(4),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1343,7 +1336,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(5),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1353,7 +1345,6 @@ 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",
             },
@@ -1367,7 +1358,6 @@ 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",
@@ -1384,7 +1374,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1393,7 +1382,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(3),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1403,7 +1391,6 @@ 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",
             },
@@ -1417,7 +1404,6 @@ 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",
@@ -1435,7 +1421,6 @@ 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",
             },
@@ -1448,7 +1433,6 @@ Simulation {
             kind: BigBool {
                 index: StatePartIndex<BigSlots>(6),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1457,7 +1441,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(12),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1466,7 +1449,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(13),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1476,7 +1458,6 @@ 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",
@@ -1494,7 +1475,6 @@ 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",
@@ -1511,7 +1491,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(10),
             },
-            maybe_changed: true,
             state: 0x1,
             last_state: 0x1,
         },
@@ -1520,7 +1499,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(11),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -1530,7 +1508,6 @@ 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",
@@ -1548,7 +1525,6 @@ 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 f771434..6df4571 100644
--- a/crates/fayalite/tests/sim/expected/sim_read_past.txt
+++ b/crates/fayalite/tests/sim/expected/sim_read_past.txt
@@ -530,18 +530,18 @@ Simulation {
         },
         big_slots: StatePart {
             value: [
-                0 (modified),
                 0,
                 0,
-                49 (modified),
-                50 (modified),
-                50 (modified),
-                0 (modified),
-                1 (modified),
-                0 (modified),
-                49 (modified),
-                49 (modified),
-                50 (modified),
+                0,
+                49,
+                50,
+                50,
+                0,
+                1,
+                0,
+                49,
+                49,
+                50,
                 1,
                 0,
                 0,
@@ -9500,7 +9500,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9509,7 +9508,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9518,7 +9516,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(2),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x1,
         },
@@ -9528,7 +9525,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(3),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9538,7 +9534,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(4),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -9548,7 +9543,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(5),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x32,
             last_state: 0x32,
         },
@@ -9557,7 +9551,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(6),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9566,7 +9559,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(7),
             },
-            maybe_changed: false,
             state: 0x1,
             last_state: 0x1,
         },
@@ -9575,7 +9567,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(8),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -9585,7 +9576,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(9),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9595,7 +9585,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(10),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x31,
             last_state: 0x31,
         },
@@ -9605,7 +9594,6 @@ 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 5584b73..3fea928 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 (modified),
-                0 (modified),
+                0,
+                0,
                 3,
             ],
         },
@@ -310,7 +310,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -319,7 +318,6 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -329,7 +327,6 @@ 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 f03c25a..2283ce5 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 (modified),
-                0 (modified),
+                0,
+                0,
                 3,
             ],
         },
@@ -310,7 +310,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -319,7 +318,6 @@ Simulation {
             kind: BigAsyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -329,7 +327,6 @@ 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 c93d6c1..c77046f 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 (modified),
+                0,
                 0,
                 3,
             ],
@@ -310,7 +310,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -319,7 +318,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -329,7 +327,6 @@ 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 f13af84..e1c565a 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 (modified),
+                0,
                 0,
                 3,
             ],
@@ -310,7 +310,6 @@ Simulation {
             kind: BigClock {
                 index: StatePartIndex<BigSlots>(0),
             },
-            maybe_changed: true,
             state: 0x0,
             last_state: 0x0,
         },
@@ -319,7 +318,6 @@ Simulation {
             kind: BigSyncReset {
                 index: StatePartIndex<BigSlots>(1),
             },
-            maybe_changed: false,
             state: 0x0,
             last_state: 0x0,
         },
@@ -329,7 +327,6 @@ Simulation {
                 index: StatePartIndex<BigSlots>(2),
                 ty: UInt<8>,
             },
-            maybe_changed: false,
             state: 0x03,
             last_state: 0x03,
         },
diff --git a/crates/fayalite/tests/ui/simvalue_is_not_internable.stderr b/crates/fayalite/tests/ui/simvalue_is_not_internable.stderr
index 44aff3f..6c78637 100644
--- a/crates/fayalite/tests/ui/simvalue_is_not_internable.stderr
+++ b/crates/fayalite/tests/ui/simvalue_is_not_internable.stderr
@@ -75,12 +75,12 @@ note: required because it appears within the type `Vec<DynSimOnlyValue>`
 note: required because it appears within the type `OpaqueSimValue`
     --> src/ty.rs
      |
- 761 | pub struct OpaqueSimValue {
+ 734 | pub struct OpaqueSimValue {
      |            ^^^^^^^^^^^^^^
 note: required because it appears within the type `value::SimValueInner<()>`
     --> src/sim/value.rs
      |
-  52 | struct SimValueInner<T: Type> {
+  51 | struct SimValueInner<T: Type> {
      |        ^^^^^^^^^^^^^
 note: required because it appears within the type `UnsafeCell<value::SimValueInner<()>>`
     --> $RUST/core/src/cell.rs
@@ -95,7 +95,7 @@ note: required because it appears within the type `util::alternating_cell::Alter
 note: required because it appears within the type `fayalite::prelude::SimValue<()>`
     --> src/sim/value.rs
      |
- 161 | pub struct SimValue<T: Type> {
+ 160 | pub struct SimValue<T: Type> {
      |            ^^^^^^^^
 note: required by a bound in `fayalite::intern::Interned`
     --> src/intern.rs
@@ -214,12 +214,12 @@ note: required because it appears within the type `Vec<DynSimOnlyValue>`
 note: required because it appears within the type `OpaqueSimValue`
     --> src/ty.rs
      |
- 761 | pub struct OpaqueSimValue {
+ 734 | pub struct OpaqueSimValue {
      |            ^^^^^^^^^^^^^^
 note: required because it appears within the type `value::SimValueInner<()>`
     --> src/sim/value.rs
      |
-  52 | struct SimValueInner<T: Type> {
+  51 | struct SimValueInner<T: Type> {
      |        ^^^^^^^^^^^^^
 note: required because it appears within the type `UnsafeCell<value::SimValueInner<()>>`
     --> $RUST/core/src/cell.rs
@@ -234,7 +234,7 @@ note: required because it appears within the type `util::alternating_cell::Alter
 note: required because it appears within the type `fayalite::prelude::SimValue<()>`
     --> src/sim/value.rs
      |
- 161 | pub struct SimValue<T: Type> {
+ 160 | pub struct SimValue<T: Type> {
      |            ^^^^^^^^
 note: required by a bound in `intern_sized`
     --> src/intern.rs
@@ -326,12 +326,12 @@ note: required because it appears within the type `Vec<DynSimOnlyValue>`
 note: required because it appears within the type `OpaqueSimValue`
     --> src/ty.rs
      |
- 761 | pub struct OpaqueSimValue {
+ 734 | pub struct OpaqueSimValue {
      |            ^^^^^^^^^^^^^^
 note: required because it appears within the type `value::SimValueInner<()>`
     --> src/sim/value.rs
      |
-  52 | struct SimValueInner<T: Type> {
+  51 | struct SimValueInner<T: Type> {
      |        ^^^^^^^^^^^^^
 note: required because it appears within the type `UnsafeCell<value::SimValueInner<()>>`
     --> $RUST/core/src/cell.rs
@@ -346,7 +346,7 @@ note: required because it appears within the type `util::alternating_cell::Alter
 note: required because it appears within the type `fayalite::prelude::SimValue<()>`
     --> src/sim/value.rs
      |
- 161 | pub struct SimValue<T: Type> {
+ 160 | pub struct SimValue<T: Type> {
      |            ^^^^^^^^
 note: required by a bound in `fayalite::intern::Interned`
     --> src/intern.rs