diff --git a/Cargo.lock b/Cargo.lock
index ad43a3c..90538a8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -305,7 +305,7 @@ checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
 [[package]]
 name = "fayalite"
 version = "0.3.0"
-source = "git+https://git.libre-chip.org/libre-chip/fayalite.git?branch=master#fbe4585578a043829bfb4d5af087fc7f4bf010b8"
+source = "git+https://git.libre-chip.org/libre-chip/fayalite.git?branch=master#9e803223d0f08c3398182cbabbff28cda7853b0f"
 dependencies = [
  "base64",
  "bitvec",
@@ -332,7 +332,7 @@ dependencies = [
 [[package]]
 name = "fayalite-proc-macros"
 version = "0.3.0"
-source = "git+https://git.libre-chip.org/libre-chip/fayalite.git?branch=master#fbe4585578a043829bfb4d5af087fc7f4bf010b8"
+source = "git+https://git.libre-chip.org/libre-chip/fayalite.git?branch=master#9e803223d0f08c3398182cbabbff28cda7853b0f"
 dependencies = [
  "fayalite-proc-macros-impl",
 ]
@@ -340,7 +340,7 @@ dependencies = [
 [[package]]
 name = "fayalite-proc-macros-impl"
 version = "0.3.0"
-source = "git+https://git.libre-chip.org/libre-chip/fayalite.git?branch=master#fbe4585578a043829bfb4d5af087fc7f4bf010b8"
+source = "git+https://git.libre-chip.org/libre-chip/fayalite.git?branch=master#9e803223d0f08c3398182cbabbff28cda7853b0f"
 dependencies = [
  "base16ct",
  "num-bigint",
@@ -355,7 +355,7 @@ dependencies = [
 [[package]]
 name = "fayalite-visit-gen"
 version = "0.3.0"
-source = "git+https://git.libre-chip.org/libre-chip/fayalite.git?branch=master#fbe4585578a043829bfb4d5af087fc7f4bf010b8"
+source = "git+https://git.libre-chip.org/libre-chip/fayalite.git?branch=master#9e803223d0f08c3398182cbabbff28cda7853b0f"
 dependencies = [
  "indexmap",
  "prettyplease",
diff --git a/crates/cpu/src/config.rs b/crates/cpu/src/config.rs
index cf2fd08..acbec47 100644
--- a/crates/cpu/src/config.rs
+++ b/crates/cpu/src/config.rs
@@ -160,18 +160,3 @@ pub type CpuConfigLog2FetchWidthInBytes<C: PhantomConstGet<CpuConfig>> = DynSize
 
 #[hdl(get(|c| c.fetch_width_in_bytes()))]
 pub type CpuConfigFetchWidthInBytes<C: PhantomConstGet<CpuConfig>> = DynSize;
-
-#[hdl(get(|c| c.rob_size.get()))]
-pub type CpuConfigRobSize<C: PhantomConstGet<CpuConfig>> = DynSize;
-
-pub trait PhantomConstCpuConfig:
-    PhantomConstGet<CpuConfig>
-    + Into<PhantomConst<CpuConfig>>
-    + From<PhantomConst<CpuConfig>>
-    + Type
-    + ToSimValue<Type = Self>
-    + ToExpr<Type = Self>
-{
-}
-
-impl PhantomConstCpuConfig for PhantomConst<CpuConfig> {}
diff --git a/crates/cpu/src/next_pc.rs b/crates/cpu/src/next_pc.rs
index e76fa6a..97d2f33 100644
--- a/crates/cpu/src/next_pc.rs
+++ b/crates/cpu/src/next_pc.rs
@@ -12,10 +12,7 @@
 #![doc = simple_mermaid::mermaid!("next_pc/next_pc.mermaid")]
 
 use crate::{
-    config::{
-        CpuConfig, CpuConfigFetchWidth, CpuConfigMaxFetchesInFlight, CpuConfigRobSize,
-        PhantomConstCpuConfig, TwiceCpuConfigFetchWidth,
-    },
+    config::{CpuConfig, CpuConfigFetchWidth, CpuConfigMaxFetchesInFlight},
     util::array_vec::ArrayVec,
 };
 use fayalite::{
@@ -115,7 +112,7 @@ pub struct RetireToNextPcInterfacePerInsn<C: PhantomConstGet<CpuConfig>> {
     pub config: C,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for RetireToNextPcInterfacePerInsn<C> {
+impl SimValueDefault for RetireToNextPcInterfacePerInsn<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -159,7 +156,7 @@ pub struct DecodeToPostDecodeInterfaceInner<C: PhantomConstGet<CpuConfig>> {
     pub config: C,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for DecodeToPostDecodeInterfaceInner<C> {
+impl SimValueDefault for DecodeToPostDecodeInterfaceInner<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self { insns, config } = self;
@@ -184,9 +181,6 @@ pub struct PostDecodeOutputInterface<C: PhantomConstGet<CpuConfig>> {
     pub config: C,
 }
 
-const BRANCH_PREDICTOR_LOG2_SIZE: usize = 8;
-const BRANCH_PREDICTOR_SIZE: usize = 1 << BRANCH_PREDICTOR_LOG2_SIZE;
-
 #[hdl]
 struct TrainBranchPredictor {
     branch_predictor_index: UIntInRange<0, { BRANCH_PREDICTOR_SIZE }>,
@@ -204,231 +198,38 @@ struct Cancel<C: PhantomConstGet<CpuConfig>> {
 }
 
 /// the output of [`Stage::run`].
-/// when cancelling operations, the returned [`StageRunOutput.cancel`] should be the state after
-/// running all operations returned in [`StageRunOutput.output`].
+/// when cancelling operations, the returned [`StageOutput.cancel`] should be the state after
+/// running all operations returned in [`StageOutput.output`].
 #[hdl(no_static)]
-struct StageRunOutput<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig, S: Type + Stage<C>> {
-    outputs: ArrayVec<StageOutput<C, S>, StageMaxOutputsPerStep<C, S>>,
+struct StageOutput<Output, MaxOutputCount: Size, C: PhantomConstGet<CpuConfig>> {
+    outputs: ArrayVec<Output, MaxOutputCount>,
     /// when set to [`HdlSome`], [`Stage::cancel`] is called on all previous stages
     cancel: HdlOption<Cancel<C>>,
 }
 
-trait Stages<C: PhantomConstCpuConfig>: Type {
-    fn visit_sim_value_ref<V: StagesVisitSimValueRef<C>>(this: &SimValue<Self>, visitor: &mut V);
-}
-
-impl<C: PhantomConstCpuConfig> Stages<C> for () {
-    #[hdl]
-    fn visit_sim_value_ref<V: StagesVisitSimValueRef<C>>(this: &SimValue<Self>, _visitor: &mut V) {
-        #[hdl(sim)]
-        let () = this;
-    }
-}
-
-impl<C: PhantomConstCpuConfig, S1: Stage<C>> Stages<C> for (S1,) {
-    #[hdl]
-    fn visit_sim_value_ref<V: StagesVisitSimValueRef<C>>(this: &SimValue<Self>, visitor: &mut V) {
-        #[hdl(sim)]
-        let (s1,) = this;
-        visitor.visit(s1);
-    }
-}
-
-impl<C: PhantomConstCpuConfig, S1: Stage<C>, S2: Stage<C>> Stages<C> for (S1, S2) {
-    #[hdl]
-    fn visit_sim_value_ref<V: StagesVisitSimValueRef<C>>(this: &SimValue<Self>, visitor: &mut V) {
-        #[hdl(sim)]
-        let (s1, s2) = this;
-        visitor.visit(s1);
-        visitor.visit(s2);
-    }
-}
-
-trait StagesVisitSimValueRef<C: PhantomConstCpuConfig> {
-    fn visit<S: Stage<C>>(&mut self, stage: &SimValue<S>);
-}
-
-trait Stage<C: PhantomConstCpuConfig>: Type + SimValueDefault + ResetSteps {
-    type InputStages: Stages<C>;
-    type Input: Type + SimValueDefault;
+trait Stage: Type + SimValueDefault + ResetSteps {
     type Inputs: Type;
     type Output: Type;
-    type ToExternalPipeInputInterface: Type;
-    type FromExternalPipeOutputInterface: Type;
-    type FromExternalPipeOutputItem: Type;
-    type MaxOutputsPerStep: Size;
-    type ToExternalPipeInputInputLen: Size;
-    type InputQueueSize: Size;
-    type OutputQueueSize: Size;
+    type MaxOutputCount: Size;
 
-    fn input_ty(config: C) -> Self::Input;
-    fn inputs_ty(config: C) -> Self::Inputs;
-    fn output_ty(config: C) -> Self::Output;
-    fn to_external_pipe_input_interface_ty(config: C) -> Self::ToExternalPipeInputInterface;
-    fn from_external_pipe_output_interface_ty(config: C) -> Self::FromExternalPipeOutputInterface;
-    fn from_external_pipe_output_item_ty(config: C) -> Self::FromExternalPipeOutputItem;
-
-    fn max_outputs_per_step(config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType;
-    fn to_external_pipe_input_input_len(
-        config: C,
-    ) -> <Self::ToExternalPipeInputInputLen as Size>::SizeType;
-    fn input_queue_size(config: C) -> <Self::InputQueueSize as Size>::SizeType;
-    fn output_queue_size(config: C) -> <Self::OutputQueueSize as Size>::SizeType;
-
-    fn cancel_in_progress_for_stage_mut(
-        cancel: &mut SimValue<CancelInProgress<C>>,
-    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>>;
-
-    /// see [`StageRunOutput`] for docs on output
+    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output;
+    fn max_output_count(
+        config: PhantomConst<CpuConfig>,
+    ) -> <Self::MaxOutputCount as Size>::SizeType;
+    fn stage_output_ty(
+        config: PhantomConst<CpuConfig>,
+    ) -> StageOutput<Self::Output, Self::MaxOutputCount, PhantomConst<CpuConfig>> {
+        StageOutput[Self::output_ty(config)][Self::max_output_count(config)][config]
+    }
+    /// see [`StageOutput`] for docs on output
     fn run(
         state: &mut SimValue<Self>,
         inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageRunOutput<C, Self>>;
+    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputCount, PhantomConst<CpuConfig>>>;
     /// changes state to match `cancel`
-    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<C>>);
+    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>);
 }
 
-macro_rules! hdl_type_alias_with_generics {
-    (
-        #[without_generics = $WithoutGenerics:ident, $OneGeneric:ident]
-        #[ty = $ty:expr]
-        $vis:vis type $Type:ident<$C:ident: $PhantomConstCpuConfig:ident, $Arg:ident: $Trait:ident<$TraitC:ident>> = $Target:ty;
-    ) => {
-        $vis type $Type<$C, $Arg> = <$Target as fayalite::phantom_const::ReturnSelfUnchanged<$C>>::Type;
-
-        $vis struct $WithoutGenerics {}
-
-        #[allow(non_upper_case_globals)]
-        $vis const $Type: $WithoutGenerics = $WithoutGenerics {};
-
-        const _: () = {
-            #[derive(Clone, PartialEq, Eq, Hash, Debug)]
-            $vis struct $OneGeneric<$C: $PhantomConstCpuConfig>($C);
-
-            impl<$C: $PhantomConstCpuConfig> std::ops::Index<$C> for $WithoutGenerics {
-                type Output = $OneGeneric<$C>;
-
-                fn index(&self, config: $C) -> &Self::Output {
-                    fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($OneGeneric(config)))
-                }
-            }
-
-            impl<$C: $PhantomConstCpuConfig, $Arg: $Trait<$TraitC>> std::ops::Index<$Arg> for $OneGeneric<$C> {
-                type Output = $Type<$C, $Arg>;
-
-                fn index(&self, arg: $Arg) -> &Self::Output {
-                    fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($ty(self.0, arg)))
-                }
-            }
-        };
-    };
-    (
-        #[without_generics = $WithoutGenerics:ident, $OneGeneric:ident]
-        #[size = $size:expr]
-        $vis:vis type $Type:ident<$C:ident: $PhantomConstCpuConfig:ident, $Arg:ident: $Trait:ident<$TraitC:ident>> = $Target:ty;
-    ) => {
-        $vis type $Type<$C, $Arg> = <$Target as fayalite::phantom_const::ReturnSelfUnchanged<$C>>::Type;
-
-        $vis struct $WithoutGenerics {}
-
-        #[allow(non_upper_case_globals)]
-        $vis const $Type: $WithoutGenerics = $WithoutGenerics {};
-
-        const _: () = {
-            #[derive(Clone, PartialEq, Eq, Hash, Debug)]
-            $vis struct $OneGeneric<$C: $PhantomConstCpuConfig>($C);
-
-            impl<$C: $PhantomConstCpuConfig> std::ops::Index<$C> for $WithoutGenerics {
-                type Output = $OneGeneric<$C>;
-
-                fn index(&self, config: $C) -> &Self::Output {
-                    fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($OneGeneric(config)))
-                }
-            }
-
-            impl<$C: $PhantomConstCpuConfig, $Arg: $Trait<$TraitC>> std::ops::Index<$Arg> for $OneGeneric<$C> {
-                type Output = <$Type<$C, $Arg> as Size>::SizeType;
-
-                fn index(&self, arg: $Arg) -> &Self::Output {
-                    fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($size(self.0, arg)))
-                }
-            }
-        };
-    };
-}
-
-hdl_type_alias_with_generics! {
-    #[without_generics = StageInputWithoutGenerics, StageInputWithStage]
-    #[ty = |config: C, _stage| T::input_ty(config)]
-    type StageInput<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::Input;
-}
-
-hdl_type_alias_with_generics! {
-    #[without_generics = StageInputsWithoutGenerics, StageInputsWithStage]
-    #[ty = |config: C, _stage| T::inputs_ty(config)]
-    type StageInputs<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::Inputs;
-}
-
-hdl_type_alias_with_generics! {
-    #[without_generics = StageOutputWithoutGenerics, StageOutputWithStage]
-    #[ty = |config: C, _stage| T::output_ty(config)]
-    type StageOutput<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::Output;
-}
-
-hdl_type_alias_with_generics! {
-    #[without_generics = StageToExternalPipeInputInterfaceWithoutGenerics, StageToExternalPipeInputInterfaceWithStage]
-    #[ty = |config: C, _stage| T::to_external_pipe_input_interface_ty(config)]
-    type StageToExternalPipeInputInterface<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::ToExternalPipeInputInterface;
-}
-
-hdl_type_alias_with_generics! {
-    #[without_generics = StageFromExternalPipeOutputInterfaceWithoutGenerics, StageFromExternalPipeOutputInterfaceWithStage]
-    #[ty = |config: C, _stage| T::from_external_pipe_output_interface_ty(config)]
-    type StageFromExternalPipeOutputInterface<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::FromExternalPipeOutputInterface;
-}
-
-hdl_type_alias_with_generics! {
-    #[without_generics = StageMaxOutputsPerStepWithoutGenerics, StageMaxOutputsPerStepWithStage]
-    #[size = |config: C, _stage| T::max_outputs_per_step(config)]
-    type StageMaxOutputsPerStep<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::MaxOutputsPerStep;
-}
-
-hdl_type_alias_with_generics! {
-    #[without_generics = StageInputQueueSizeWithoutGenerics, StageInputQueueSizeWithStage]
-    #[size = |config: C, _stage| T::input_queue_size(config)]
-    type StageInputQueueSize<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::InputQueueSize;
-}
-
-hdl_type_alias_with_generics! {
-    #[without_generics = StageToExternalPipeInputInputLenWithoutGenerics, StageToExternalPipeInputInputLenWithStage]
-    #[size = |config: C, _stage| T::to_external_pipe_input_input_len(config)]
-    type StageToExternalPipeInputInputLen<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::ToExternalPipeInputInputLen;
-}
-
-hdl_type_alias_with_generics! {
-    #[without_generics = StageOutputQueueSizeWithoutGenerics, StageOutputQueueSizeWithStage]
-    #[size = |config: C, _stage| T::output_queue_size(config)]
-    type StageOutputQueueSize<C: PhantomConstCpuConfig, T: Stage<C>> = <T as Stage<C>>::OutputQueueSize;
-}
-
-#[hdl]
-type StageToExternalPipeInputInput<
-    C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig,
-    S: Type + Stage<C>,
-> = ArrayVec<StageInput<C, S>, StageToExternalPipeInputInputLen<C, S>>;
-
-#[hdl]
-type StageToExternalPipeInputCancel<
-    C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig,
-    S: Type + Stage<C>,
-> = UIntInRangeInclusiveType<ConstUsize<0>, StageInputQueueSize<C, S>>;
-
-#[hdl]
-type StageToExternalPipeInputInput<
-    C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig,
-    S: Type + Stage<C>,
-> = ArrayVec<StageInput<C, S>, StageToExternalPipeInputInputLen<C, S>>;
-
 #[hdl(no_static)]
 struct NextPcStageOutput<C: PhantomConstGet<CpuConfig>> {
     start_pc: UInt<64>,
@@ -442,7 +243,7 @@ struct NextPcStageOutput<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcStageOutput<C> {
+impl SimValueDefault for NextPcStageOutput<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -467,7 +268,7 @@ impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcStageOutput<C> {
 }
 
 #[hdl(no_static)]
-struct NextPcStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
+struct NextPcStageState<C: PhantomConstGet<CpuConfig>> {
     call_stack: CallStack,
     branch_target_buffer: BranchTargetBuffer,
     next_pc: UInt<64>,
@@ -475,7 +276,7 @@ struct NextPcStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
     config: C,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcStageState<C> {
+impl SimValueDefault for NextPcStageState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -498,7 +299,7 @@ impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcStageState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> ResetSteps for NextPcStageState<C> {
+impl ResetSteps for NextPcStageState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -517,60 +318,26 @@ impl<C: PhantomConstCpuConfig> ResetSteps for NextPcStageState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> Stage<C> for NextPcStageState<C> {
-    type Input = ();
+impl Stage for NextPcStageState<PhantomConst<CpuConfig>> {
     type Inputs = ();
-    type Output = NextPcStageOutput<C>;
-    type ToExternalPipeInputInterface = ();
-    type FromExternalPipeOutputInterface = ();
-    type MaxOutputsPerStep = ConstUsize<1>;
-    type InputQueueSize = ConstUsize<1>;
-    type OutputQueueSize = ConstUsize<1>;
+    type Output = NextPcStageOutput<PhantomConst<CpuConfig>>;
+    type MaxOutputCount = ConstUsize<1>;
 
-    fn input_ty(_config: C) -> Self::Input {
-        ()
-    }
-
-    fn inputs_ty(_config: C) -> Self::Inputs {
-        ()
-    }
-
-    fn output_ty(config: C) -> Self::Output {
+    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
         NextPcStageOutput[config]
     }
 
-    fn to_external_pipe_input_interface_ty(_config: C) -> Self::ToExternalPipeInputInterface {
-        ()
-    }
-
-    fn from_external_pipe_output_interface_ty(_config: C) -> Self::FromExternalPipeOutputInterface {
-        ()
-    }
-
-    fn max_outputs_per_step(_config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    fn max_output_count(
+        _config: PhantomConst<CpuConfig>,
+    ) -> <Self::MaxOutputCount as Size>::SizeType {
         ConstUsize
     }
 
-    fn input_queue_size(_config: C) -> <Self::InputQueueSize as Size>::SizeType {
-        ConstUsize
-    }
-
-    fn output_queue_size(_config: C) -> <Self::OutputQueueSize as Size>::SizeType {
-        ConstUsize
-    }
-
-    fn cancel_in_progress_for_stage_mut(
-        cancel: &mut SimValue<CancelInProgress<C>>,
-    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>> {
-        &mut cancel.next_pc
-    }
-
     #[hdl]
     fn run(
         state: &mut SimValue<Self>,
         _inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageRunOutput<C, Self>> {
-        let this_ty = state.ty();
+    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputCount, PhantomConst<CpuConfig>>> {
         let config = state.config.ty();
         let start_call_stack = state.call_stack.clone();
         let fetch_block_id = state.next_fetch_block_id.as_int();
@@ -649,17 +416,15 @@ impl<C: PhantomConstCpuConfig> Stage<C> for NextPcStageState<C> {
             config,
         };
         #[hdl(sim)]
-        StageRunOutput::<_, _> {
-            outputs: StageRunOutput[config][this_ty]
-                .outputs
-                .new_full_sim([output]),
+        StageOutput::<_, _, _> {
+            outputs: Self::stage_output_ty(config).outputs.new_full_sim([output]),
             cancel: #[hdl(sim)]
             (HdlOption[Cancel[config]]).HdlNone(),
         }
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<C>>) {
+    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
         #[hdl(sim)]
         let Self {
             call_stack,
@@ -739,7 +504,7 @@ struct BrPredStageOutput<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for BrPredStageOutput<C> {
+impl SimValueDefault for BrPredStageOutput<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -753,7 +518,7 @@ impl<C: PhantomConstCpuConfig> SimValueDefault for BrPredStageOutput<C> {
 }
 
 #[hdl(no_static)]
-struct BrPredStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
+struct BrPredStageState<C: PhantomConstGet<CpuConfig>> {
     branch_history: UInt<6>,
     branch_predictor: Array<BranchPredictionState, { BRANCH_PREDICTOR_SIZE }>,
     config: C,
@@ -764,7 +529,7 @@ fn step_branch_history(branch_history: &mut SimValue<UInt<6>>, taken: bool) {
         ((&**branch_history << 1) | taken.cast_to_static::<UInt<1>>()).cast_to_static::<UInt<6>>();
 }
 
-impl<C: PhantomConstCpuConfig> BrPredStageState<C> {
+impl BrPredStageState<PhantomConst<CpuConfig>> {
     fn branch_predictor_index(this: &SimValue<Self>, branch_pc: u64) -> usize {
         let mut t = this.branch_history.cast_to_static::<UInt<64>>().as_int();
         t ^= t.rotate_left(5) & !branch_pc.rotate_right(3);
@@ -778,7 +543,7 @@ impl<C: PhantomConstCpuConfig> BrPredStageState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for BrPredStageState<C> {
+impl SimValueDefault for BrPredStageState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -799,7 +564,7 @@ impl<C: PhantomConstCpuConfig> SimValueDefault for BrPredStageState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> ResetSteps for BrPredStageState<C> {
+impl ResetSteps for BrPredStageState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -813,60 +578,26 @@ impl<C: PhantomConstCpuConfig> ResetSteps for BrPredStageState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> Stage<C> for BrPredStageState<C> {
-    type Input = NextPcStageOutput<C>;
-    type Inputs = NextPcStageOutput<C>;
-    type Output = BrPredStageOutput<C>;
-    type ToExternalPipeInputInterface = ();
-    type FromExternalPipeOutputInterface = ();
-    type MaxOutputsPerStep = ConstUsize<1>;
-    type InputQueueSize = ConstUsize<1>;
-    type OutputQueueSize = CpuConfigMaxFetchesInFlight<C>;
+impl Stage for BrPredStageState<PhantomConst<CpuConfig>> {
+    type Inputs = NextPcStageOutput<PhantomConst<CpuConfig>>;
+    type Output = BrPredStageOutput<PhantomConst<CpuConfig>>;
+    type MaxOutputCount = ConstUsize<1>;
 
-    fn input_ty(config: C) -> Self::Input {
-        NextPcStageOutput[config]
-    }
-
-    fn inputs_ty(config: C) -> Self::Inputs {
-        NextPcStageOutput[config]
-    }
-
-    fn output_ty(config: C) -> Self::Output {
+    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
         BrPredStageOutput[config]
     }
 
-    fn to_external_pipe_input_interface_ty(_config: C) -> Self::ToExternalPipeInputInterface {
-        ()
-    }
-
-    fn from_external_pipe_output_interface_ty(_config: C) -> Self::FromExternalPipeOutputInterface {
-        ()
-    }
-
-    fn max_outputs_per_step(_config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    fn max_output_count(
+        _config: PhantomConst<CpuConfig>,
+    ) -> <Self::MaxOutputCount as Size>::SizeType {
         ConstUsize
     }
 
-    fn input_queue_size(_config: C) -> <Self::InputQueueSize as Size>::SizeType {
-        ConstUsize
-    }
-
-    fn output_queue_size(config: C) -> <Self::OutputQueueSize as Size>::SizeType {
-        CpuConfigMaxFetchesInFlight[config]
-    }
-
-    fn cancel_in_progress_for_stage_mut(
-        cancel: &mut SimValue<CancelInProgress<C>>,
-    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>> {
-        &mut cancel.br_pred
-    }
-
     #[hdl]
     fn run(
         state: &mut SimValue<Self>,
         inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageRunOutput<C, Self>> {
-        let this_ty = state.ty();
+    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputCount, PhantomConst<CpuConfig>>> {
         let config = state.config.ty();
         #[hdl(sim)]
         let NextPcStageOutput::<_> {
@@ -911,9 +642,9 @@ impl<C: PhantomConstCpuConfig> Stage<C> for BrPredStageState<C> {
                     let btb_entry_index = &btb_entry.0;
                     let mut btb_entry = btb_entry.1.clone();
                     btb_entry.addr_kind = opposite_addr_kind;
-                    let StageRunOutput { outputs, cancel } = StageRunOutput[config][this_ty];
+                    let StageOutput { outputs, cancel } = Self::stage_output_ty(config);
                     let retval = #[hdl(sim)]
-                    StageRunOutput::<_, _> {
+                    StageOutput::<_, _, _> {
                         outputs: outputs.sim_value_default(),
                         cancel: #[hdl(sim)]
                         cancel.HdlSome(
@@ -944,17 +675,15 @@ impl<C: PhantomConstCpuConfig> Stage<C> for BrPredStageState<C> {
             config,
         };
         #[hdl(sim)]
-        StageRunOutput::<_, _> {
-            outputs: StageRunOutput[config][this_ty]
-                .outputs
-                .new_full_sim([output]),
+        StageOutput::<_, _, _> {
+            outputs: Self::stage_output_ty(config).outputs.new_full_sim([output]),
             cancel: #[hdl(sim)]
             (HdlOption[Cancel[config]]).HdlNone(),
         }
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<C>>) {
+    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
         #[hdl(sim)]
         let Cancel::<_> {
             call_stack: _,
@@ -968,7 +697,7 @@ impl<C: PhantomConstCpuConfig> Stage<C> for BrPredStageState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> BrPredStageState<C> {
+impl BrPredStageState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn train_branch_predictor(
         this: &mut SimValue<Self>,
@@ -991,11 +720,11 @@ impl<C: PhantomConstCpuConfig> BrPredStageState<C> {
 }
 
 #[hdl(no_static)]
-struct FetchDecodeStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
+struct FetchDecodeStageState<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for FetchDecodeStageState<C> {
+impl SimValueDefault for FetchDecodeStageState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -1005,7 +734,7 @@ impl<C: PhantomConstCpuConfig> SimValueDefault for FetchDecodeStageState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> ResetSteps for FetchDecodeStageState<C> {
+impl ResetSteps for FetchDecodeStageState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, _step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -1020,7 +749,7 @@ struct FetchDecodeStageOutput<C: PhantomConstGet<CpuConfig>> {
     decode_output: DecodeToPostDecodeInterfaceInner<C>,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for FetchDecodeStageOutput<C> {
+impl SimValueDefault for FetchDecodeStageOutput<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -1035,66 +764,32 @@ impl<C: PhantomConstCpuConfig> SimValueDefault for FetchDecodeStageOutput<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> Stage<C> for FetchDecodeStageState<C> {
-    type Input = NextPcStageOutput<C>;
-    type Inputs = FetchDecodeStageOutput<C>;
-    type Output = FetchDecodeStageOutput<C>;
-    type ToExternalPipeInputInterface = NextPcToFetchInterface<C>;
-    type FromExternalPipeOutputInterface = DecodeToPostDecodeInterface<C>;
-    type MaxOutputsPerStep = ConstUsize<1>;
-    type InputQueueSize = CpuConfigMaxFetchesInFlight<C>;
-    type OutputQueueSize = ConstUsize<1>;
+impl Stage for FetchDecodeStageState<PhantomConst<CpuConfig>> {
+    type Inputs = FetchDecodeStageOutput<PhantomConst<CpuConfig>>;
+    type Output = FetchDecodeStageOutput<PhantomConst<CpuConfig>>;
+    type MaxOutputCount = ConstUsize<1>;
 
-    fn input_ty(config: C) -> Self::Input {
-        NextPcStageOutput[config]
-    }
-
-    fn inputs_ty(config: C) -> Self::Inputs {
+    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
         FetchDecodeStageOutput[config]
     }
 
-    fn output_ty(config: C) -> Self::Output {
-        FetchDecodeStageOutput[config]
-    }
-
-    fn to_external_pipe_input_interface_ty(config: C) -> Self::ToExternalPipeInputInterface {
-        NextPcToFetchInterface[config]
-    }
-
-    fn from_external_pipe_output_interface_ty(config: C) -> Self::FromExternalPipeOutputInterface {
-        DecodeToPostDecodeInterface[config]
-    }
-
-    fn max_outputs_per_step(_config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    fn max_output_count(
+        _config: PhantomConst<CpuConfig>,
+    ) -> <Self::MaxOutputCount as Size>::SizeType {
         ConstUsize
     }
 
-    fn input_queue_size(config: C) -> <Self::InputQueueSize as Size>::SizeType {
-        CpuConfigMaxFetchesInFlight[config]
-    }
-
-    fn output_queue_size(_config: C) -> <Self::OutputQueueSize as Size>::SizeType {
-        ConstUsize
-    }
-
-    fn cancel_in_progress_for_stage_mut(
-        cancel: &mut SimValue<CancelInProgress<C>>,
-    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>> {
-        &mut cancel.fetch_decode
-    }
-
     #[hdl]
     fn run(
         state: &mut SimValue<Self>,
         inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageRunOutput<C, Self>> {
-        let this_ty = state.ty();
+    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputCount, PhantomConst<CpuConfig>>> {
         #[hdl(sim)]
         let Self { config } = state;
         let config = config.ty();
-        let StageRunOutput { outputs, cancel } = StageRunOutput[config][this_ty];
+        let StageOutput { outputs, cancel } = Self::stage_output_ty(config);
         #[hdl(sim)]
-        StageRunOutput::<_, _> {
+        StageOutput::<_, _, _> {
             outputs: outputs.new_full_sim([inputs]),
             cancel: #[hdl(sim)]
             cancel.HdlNone(),
@@ -1102,14 +797,14 @@ impl<C: PhantomConstCpuConfig> Stage<C> for FetchDecodeStageState<C> {
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<C>>) {
+    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
         #[hdl(sim)]
         let Self { config: _ } = state;
     }
 }
 
 #[hdl(no_static)]
-struct PostDecodeStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
+struct PostDecodeStageState<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
@@ -1119,7 +814,7 @@ struct PostDecodeStageInput<C: PhantomConstGet<CpuConfig>> {
     br_pred_stage_output: BrPredStageOutput<C>,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for PostDecodeStageInput<C> {
+impl SimValueDefault for PostDecodeStageInput<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -1141,7 +836,7 @@ struct PostDecodeStageOutput<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for PostDecodeStageOutput<C> {
+impl SimValueDefault for PostDecodeStageOutput<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -1159,7 +854,7 @@ impl<C: PhantomConstCpuConfig> SimValueDefault for PostDecodeStageOutput<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for PostDecodeStageState<C> {
+impl SimValueDefault for PostDecodeStageState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -1169,7 +864,7 @@ impl<C: PhantomConstCpuConfig> SimValueDefault for PostDecodeStageState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> ResetSteps for PostDecodeStageState<C> {
+impl ResetSteps for PostDecodeStageState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, _step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -1178,60 +873,26 @@ impl<C: PhantomConstCpuConfig> ResetSteps for PostDecodeStageState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> Stage<C> for PostDecodeStageState<C> {
-    type Input = PostDecodeStageInput<C>;
-    type Inputs = PostDecodeStageInput<C>;
-    type Output = PostDecodeStageOutput<C>;
-    type ToExternalPipeInputInterface = ();
-    type FromExternalPipeOutputInterface = ();
-    type MaxOutputsPerStep = CpuConfigFetchWidth<C>;
-    type InputQueueSize = ConstUsize<1>;
-    type OutputQueueSize = TwiceCpuConfigFetchWidth<C>;
+impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
+    type Inputs = PostDecodeStageInput<PhantomConst<CpuConfig>>;
+    type Output = PostDecodeStageOutput<PhantomConst<CpuConfig>>;
+    type MaxOutputCount = CpuConfigFetchWidth<PhantomConst<CpuConfig>>;
 
-    fn input_ty(config: C) -> Self::Input {
-        PostDecodeStageInput[config]
-    }
-
-    fn inputs_ty(config: C) -> Self::Inputs {
-        PostDecodeStageInput[config]
-    }
-
-    fn output_ty(config: C) -> Self::Output {
+    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
         PostDecodeStageOutput[config]
     }
 
-    fn to_external_pipe_input_interface_ty(_config: C) -> Self::ToExternalPipeInputInterface {
-        ()
-    }
-
-    fn from_external_pipe_output_interface_ty(_config: C) -> Self::FromExternalPipeOutputInterface {
-        ()
-    }
-
-    fn max_outputs_per_step(config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    fn max_output_count(
+        config: PhantomConst<CpuConfig>,
+    ) -> <Self::MaxOutputCount as Size>::SizeType {
         CpuConfigFetchWidth[config]
     }
 
-    fn input_queue_size(_config: C) -> <Self::InputQueueSize as Size>::SizeType {
-        ConstUsize
-    }
-
-    fn output_queue_size(config: C) -> <Self::OutputQueueSize as Size>::SizeType {
-        TwiceCpuConfigFetchWidth[config]
-    }
-
-    fn cancel_in_progress_for_stage_mut(
-        cancel: &mut SimValue<CancelInProgress<C>>,
-    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>> {
-        &mut cancel.post_decode
-    }
-
     #[hdl]
     fn run(
         state: &mut SimValue<Self>,
         inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageRunOutput<C, Self>> {
-        let this_ty = state.ty();
+    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputCount, PhantomConst<CpuConfig>>> {
         #[hdl(sim)]
         let Self { config } = state;
         let config = config.ty();
@@ -1269,10 +930,10 @@ impl<C: PhantomConstCpuConfig> Stage<C> for PostDecodeStageState<C> {
             -- either the decoded instructions or a WipDecodedInsnKind::Interrupt",
         );
         let insns = ArrayVec::elements_sim_ref(&insns);
-        let StageRunOutput {
+        let StageOutput {
             outputs: outputs_ty,
             cancel: cancel_ty,
-        } = StageRunOutput[config][this_ty];
+        } = Self::stage_output_ty(config);
         assert_eq!(outputs_ty.capacity(), decode_output.insns.ty().capacity());
         let mut outputs = outputs_ty.sim_value_default();
         let mut add_output_insn = |insn: &SimValue<WipDecodedInsn>,
@@ -1321,7 +982,7 @@ impl<C: PhantomConstCpuConfig> Stage<C> for PostDecodeStageState<C> {
             let mut call_stack = start_call_stack.clone();
             CallStack::push(&mut call_stack, start_pc);
             let retval = #[hdl(sim)]
-            StageRunOutput::<_, _> {
+            StageOutput::<_, _, _> {
                 outputs,
                 cancel: #[hdl(sim)]
                 cancel_ty.HdlSome(
@@ -1518,7 +1179,7 @@ impl<C: PhantomConstCpuConfig> Stage<C> for PostDecodeStageState<C> {
         };
         if *new_btb_entry.cmp_ne(predicted_btb_entry) {
             #[hdl(sim)]
-            StageRunOutput::<_, _> {
+            StageOutput::<_, _, _> {
                 outputs: outputs_ty.sim_value_default(),
                 cancel: #[hdl(sim)]
                 cancel_ty.HdlSome(
@@ -1535,7 +1196,7 @@ impl<C: PhantomConstCpuConfig> Stage<C> for PostDecodeStageState<C> {
             }
         } else {
             #[hdl(sim)]
-            StageRunOutput::<_, _> {
+            StageOutput::<_, _, _> {
                 outputs,
                 cancel: #[hdl(sim)]
                 cancel_ty.HdlNone(),
@@ -1544,45 +1205,36 @@ impl<C: PhantomConstCpuConfig> Stage<C> for PostDecodeStageState<C> {
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<C>>) {
+    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
         #[hdl(sim)]
         let Self { config: _ } = state;
     }
 }
 
 #[hdl(no_static)]
-struct ExecuteRetireStageInput<C: PhantomConstGet<CpuConfig>> {
-    post_decode_stage_output: PostDecodeStageOutput<C>,
-    retire_interface_per_insn: RetireToNextPcInterfacePerInsn<C>,
+struct RenameDispatchExecuteStageState<C: PhantomConstGet<CpuConfig>> {
+    config: C,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for ExecuteRetireStageInput<C> {
+#[hdl(no_static)]
+struct RenameDispatchExecuteStageOutput<C: PhantomConstGet<CpuConfig>> {
+    post_decode_stage_output: PostDecodeStageOutput<C>,
+}
+
+impl SimValueDefault for RenameDispatchExecuteStageOutput<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
             post_decode_stage_output,
-            retire_interface_per_insn,
         } = self;
         #[hdl(sim)]
         Self {
             post_decode_stage_output: post_decode_stage_output.sim_value_default(),
-            retire_interface_per_insn: retire_interface_per_insn.sim_value_default(),
         }
     }
 }
 
-#[hdl(no_static)]
-struct ExecuteRetireStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
-    config: C,
-}
-
-#[hdl(no_static)]
-struct ExecuteRetireStageOutput<C: PhantomConstGet<CpuConfig>> {
-    train_branch_predictor: HdlOption<TrainBranchPredictor>,
-    config: C,
-}
-
-impl<C: PhantomConstCpuConfig> SimValueDefault for ExecuteRetireStageState<C> {
+impl SimValueDefault for RenameDispatchExecuteStageState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self { config } = self;
@@ -1591,7 +1243,7 @@ impl<C: PhantomConstCpuConfig> SimValueDefault for ExecuteRetireStageState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> ResetSteps for ExecuteRetireStageState<C> {
+impl ResetSteps for RenameDispatchExecuteStageState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, _step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -1600,66 +1252,122 @@ impl<C: PhantomConstCpuConfig> ResetSteps for ExecuteRetireStageState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> Stage<C> for ExecuteRetireStageState<C> {
-    type Input = PostDecodeStageOutput<C>;
-    type Inputs = ExecuteRetireStageInput<C>;
-    type Output = ExecuteRetireStageOutput<C>;
-    type ToExternalPipeInputInterface = PostDecodeOutputInterface<C>;
-    type FromExternalPipeOutputInterface = RetireToNextPcInterface<C>;
-    type MaxOutputsPerStep = ConstUsize<1>;
-    type InputQueueSize = CpuConfigRobSize<C>;
-    type OutputQueueSize = ConstUsize<1>;
+impl Stage for RenameDispatchExecuteStageState<PhantomConst<CpuConfig>> {
+    type Inputs = RenameDispatchExecuteStageOutput<PhantomConst<CpuConfig>>;
+    type Output = RenameDispatchExecuteStageOutput<PhantomConst<CpuConfig>>;
+    type MaxOutputCount = ConstUsize<1>;
 
-    fn input_ty(config: C) -> Self::Input {
-        PostDecodeStageOutput[config]
+    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+        RenameDispatchExecuteStageOutput[config]
     }
 
-    fn inputs_ty(config: C) -> Self::Inputs {
-        ExecuteRetireStageInput[config]
-    }
-
-    fn output_ty(config: C) -> Self::Output {
-        ExecuteRetireStageOutput[config]
-    }
-
-    fn to_external_pipe_input_interface_ty(config: C) -> Self::ToExternalPipeInputInterface {
-        PostDecodeOutputInterface[config]
-    }
-
-    fn from_external_pipe_output_interface_ty(config: C) -> Self::FromExternalPipeOutputInterface {
-        RetireToNextPcInterface[config]
-    }
-
-    fn max_outputs_per_step(_config: C) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    fn max_output_count(
+        _config: PhantomConst<CpuConfig>,
+    ) -> <Self::MaxOutputCount as Size>::SizeType {
         ConstUsize
     }
 
-    fn input_queue_size(config: C) -> <Self::InputQueueSize as Size>::SizeType {
-        CpuConfigRobSize[config]
-    }
-
-    fn output_queue_size(_config: C) -> <Self::OutputQueueSize as Size>::SizeType {
-        ConstUsize
-    }
-
-    fn cancel_in_progress_for_stage_mut(
-        cancel: &mut SimValue<CancelInProgress<C>>,
-    ) -> &mut SimValue<CancelInProgressForStageWithQueues<C, Self>> {
-        &mut cancel.execute_retire
-    }
-
     #[hdl]
     fn run(
         state: &mut SimValue<Self>,
         inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageRunOutput<C, Self>> {
-        let this_ty = state.ty();
+    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputCount, PhantomConst<CpuConfig>>> {
+        #[hdl(sim)]
+        let Self { config } = state;
+        let config = config.ty();
+        let StageOutput { outputs, cancel } = Self::stage_output_ty(config);
+        #[hdl(sim)]
+        StageOutput::<_, _, _> {
+            outputs: outputs.new_full_sim([inputs]),
+            cancel: #[hdl(sim)]
+            cancel.HdlNone(),
+        }
+    }
+
+    #[hdl]
+    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
+        #[hdl(sim)]
+        let Self { config: _ } = state;
+    }
+}
+
+#[hdl(no_static)]
+struct RetireStageInput<C: PhantomConstGet<CpuConfig>> {
+    rename_dispatch_execute_stage_output: RenameDispatchExecuteStageOutput<C>,
+    retire_interface_per_insn: RetireToNextPcInterfacePerInsn<C>,
+}
+
+impl SimValueDefault for RetireStageInput<PhantomConst<CpuConfig>> {
+    #[hdl]
+    fn sim_value_default(self) -> SimValue<Self> {
+        let Self {
+            rename_dispatch_execute_stage_output,
+            retire_interface_per_insn,
+        } = self;
+        #[hdl(sim)]
+        Self {
+            rename_dispatch_execute_stage_output: rename_dispatch_execute_stage_output
+                .sim_value_default(),
+            retire_interface_per_insn: retire_interface_per_insn.sim_value_default(),
+        }
+    }
+}
+
+#[hdl(no_static)]
+struct RetireStageState<C: PhantomConstGet<CpuConfig>> {
+    config: C,
+}
+
+#[hdl(no_static)]
+struct RetireStageOutput<C: PhantomConstGet<CpuConfig>> {
+    train_branch_predictor: HdlOption<TrainBranchPredictor>,
+    config: C,
+}
+
+impl SimValueDefault for RetireStageState<PhantomConst<CpuConfig>> {
+    #[hdl]
+    fn sim_value_default(self) -> SimValue<Self> {
+        let Self { config } = self;
+        #[hdl(sim)]
+        Self { config }
+    }
+}
+
+impl ResetSteps for RetireStageState<PhantomConst<CpuConfig>> {
+    #[hdl]
+    fn reset_step(this: &mut SimValue<Self>, _step: usize) -> ResetStatus {
+        #[hdl(sim)]
+        let Self { config: _ } = this;
+        ResetStatus::Done
+    }
+}
+
+impl Stage for RetireStageState<PhantomConst<CpuConfig>> {
+    type Inputs = RetireStageInput<PhantomConst<CpuConfig>>;
+    type Output = RetireStageOutput<PhantomConst<CpuConfig>>;
+    type MaxOutputCount = ConstUsize<1>;
+
+    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+        RetireStageOutput[config]
+    }
+
+    fn max_output_count(
+        _config: PhantomConst<CpuConfig>,
+    ) -> <Self::MaxOutputCount as Size>::SizeType {
+        ConstUsize
+    }
+
+    #[hdl]
+    fn run(
+        state: &mut SimValue<Self>,
+        inputs: &SimValue<Self::Inputs>,
+    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputCount, PhantomConst<CpuConfig>>> {
         #[hdl(sim)]
         let Self { config } = state;
         let config = config.ty();
         #[hdl(sim)]
-        let ExecuteRetireStageInput::<_> {
-            post_decode_stage_output,
+        let RetireStageInput::<_> {
+            rename_dispatch_execute_stage_output,
             retire_interface_per_insn,
         } = inputs;
         #[hdl(sim)]
@@ -1671,6 +1379,10 @@ impl<C: PhantomConstCpuConfig> Stage<C> for ExecuteRetireStageState<C> {
             config: _,
         } = retire_interface_per_insn;
         #[hdl(sim)]
+        let RenameDispatchExecuteStageOutput::<_> {
+            post_decode_stage_output,
+        } = rename_dispatch_execute_stage_output;
+        #[hdl(sim)]
         let PostDecodeStageOutput::<_> {
             insn,
             next_pc: predicted_next_pc,
@@ -1681,10 +1393,10 @@ impl<C: PhantomConstCpuConfig> Stage<C> for ExecuteRetireStageState<C> {
             config: _,
         } = post_decode_stage_output;
         assert_eq!(*id, insn.id, "instruction queuing out of sync");
-        let StageRunOutput {
+        let StageOutput {
             outputs: outputs_ty,
             cancel: cancel_ty,
-        } = StageRunOutput[config][this_ty];
+        } = Self::stage_output_ty(config);
         let mut branch_history = start_branch_history.clone();
         let train_branch_predictor = #[hdl(sim)]
         if let HdlSome(taken) = cond_br_taken {
@@ -1811,10 +1523,10 @@ impl<C: PhantomConstCpuConfig> Stage<C> for ExecuteRetireStageState<C> {
                 CallStackOp::Unknown => unreachable!(),
             }
             #[hdl(sim)]
-            StageRunOutput::<_, _> {
+            StageOutput::<_, _, _> {
                 outputs: outputs_ty.new_sim(
                     #[hdl(sim)]
-                    ExecuteRetireStageOutput::<_> {
+                    RetireStageOutput::<_> {
                         train_branch_predictor,
                         config,
                     },
@@ -1834,10 +1546,10 @@ impl<C: PhantomConstCpuConfig> Stage<C> for ExecuteRetireStageState<C> {
             }
         } else {
             #[hdl(sim)]
-            StageRunOutput::<_, _> {
+            StageOutput::<_, _, _> {
                 outputs: outputs_ty.new_full_sim([
                     #[hdl(sim)]
-                    ExecuteRetireStageOutput::<_> {
+                    RetireStageOutput::<_> {
                         train_branch_predictor,
                         config,
                     },
@@ -1849,7 +1561,7 @@ impl<C: PhantomConstCpuConfig> Stage<C> for ExecuteRetireStageState<C> {
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<C>>) {
+    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
         #[hdl(sim)]
         let Self { config: _ } = state;
     }
@@ -1934,18 +1646,6 @@ impl<T: SimOnlyValueTrait> SimValueDefault for SimOnly<T> {
     }
 }
 
-impl<T: ?Sized + fayalite::phantom_const::PhantomConstValue> SimValueDefault for PhantomConst<T> {
-    fn sim_value_default(self) -> SimValue<Self> {
-        self.to_sim_value()
-    }
-}
-
-impl SimValueDefault for () {
-    fn sim_value_default(self) -> SimValue<Self> {
-        self.to_sim_value()
-    }
-}
-
 impl<T: SimValueDefault, N: Size> SimValueDefault for ArrayVec<T, N> {
     fn sim_value_default(self) -> SimValue<Self> {
         self.new_sim(self.element().sim_value_default())
@@ -2383,8 +2083,6 @@ struct Queue<T, Capacity: Size> {
     head: UIntInRangeType<ConstUsize<0>, Capacity>,
     /// exclusive
     tail: UIntInRangeType<ConstUsize<0>, Capacity>,
-    /// used to disambiguate between a full and an empty queue
-    eq_head_tail_means_full: Bool,
 }
 
 impl<T: Type, Capacity: Size> Queue<T, Capacity> {
@@ -2395,27 +2093,21 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
         assert_ne!(self.capacity(), 0);
         (pos + 1) % self.capacity()
     }
-    fn nth_pos_after(self, pos: usize, nth: usize) -> usize {
-        assert_ne!(self.capacity(), 0);
-        (pos + nth) % self.capacity()
-    }
     fn prev_pos(self, pos: usize) -> usize {
         assert_ne!(self.capacity(), 0);
         (pos + self.capacity() - 1) % self.capacity()
     }
     fn is_empty(this: &SimValue<Self>) -> bool {
-        this.head == this.tail && !*this.eq_head_tail_means_full
+        this.head == this.tail
     }
     fn is_full(this: &SimValue<Self>) -> bool {
-        this.head == this.tail && *this.eq_head_tail_means_full
+        let head = *this.head;
+        let tail = *this.tail;
+        this.ty().next_pos(head) == tail
     }
     fn len(this: &SimValue<Self>) -> usize {
         let capacity = this.ty().capacity();
-        if Self::is_full(this) {
-            capacity
-        } else {
-            (*this.tail + capacity - *this.head) % capacity
-        }
+        (*this.tail + capacity - *this.head) % capacity
     }
     fn space_left(this: &SimValue<Self>) -> usize {
         this.ty().capacity() - Self::len(this)
@@ -2423,7 +2115,6 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
     fn clear(this: &mut SimValue<Self>) {
         *this.head = 0;
         *this.tail = 0;
-        *this.eq_head_tail_means_full = false;
     }
     fn try_push(this: &mut SimValue<Self>, value: impl ToSimValueWithType<T>) -> Result<(), ()> {
         if Self::is_full(this) {
@@ -2432,7 +2123,6 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
             let head = *this.head;
             let head = this.ty().next_pos(head);
             *this.head = head;
-            *this.eq_head_tail_means_full = true;
             let data = &mut this.data[head];
             *data = value.to_sim_value_with_type(data.ty());
             Ok(())
@@ -2446,7 +2136,6 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
             let data = this.data[head].clone();
             let head = this.ty().prev_pos(head);
             *this.head = head;
-            *this.eq_head_tail_means_full = false;
             Some(data)
         }
     }
@@ -2457,11 +2146,6 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
             Some(this.data[*this.tail].clone())
         }
     }
-    fn peek_iter(
-        this: &SimValue<Self>,
-    ) -> impl Clone + DoubleEndedIterator<Item = SimValue<T>> + ExactSizeIterator {
-        (0..Self::len(this)).map(|nth| this.data[this.ty().nth_pos_after(*this.tail, nth)].clone())
-    }
     fn pop(this: &mut SimValue<Self>) -> Option<SimValue<T>> {
         if Self::is_empty(this) {
             None
@@ -2469,7 +2153,6 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
             let tail = *this.tail;
             let data = this.data[tail].clone();
             *this.tail = this.ty().next_pos(tail);
-            *this.eq_head_tail_means_full = false;
             Some(data)
         }
     }
@@ -2478,12 +2161,7 @@ impl<T: Type, Capacity: Size> Queue<T, Capacity> {
 impl<T: SimValueDefault, Capacity: Size> SimValueDefault for Queue<T, Capacity> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
-        let Self {
-            data,
-            head,
-            tail,
-            eq_head_tail_means_full: _,
-        } = self;
+        let Self { data, head, tail } = self;
         #[hdl(sim)]
         Queue::<T, Capacity> {
             data: repeat(
@@ -2492,7 +2170,6 @@ impl<T: SimValueDefault, Capacity: Size> SimValueDefault for Queue<T, Capacity>
             ),
             head: 0usize.to_sim_value_with_type(head),
             tail: 0usize.to_sim_value_with_type(tail),
-            eq_head_tail_means_full: false,
         }
     }
 }
@@ -2501,148 +2178,66 @@ impl<T: SimValueDefault, Capacity: Size> ResetSteps for Queue<T, Capacity> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
-        let Queue::<T, Capacity> {
-            data,
-            head,
-            tail,
-            eq_head_tail_means_full,
-        } = this;
+        let Queue::<T, Capacity> { data, head, tail } = this;
         **head = 0;
         **tail = 0;
-        **eq_head_tail_means_full = false;
         ResetSteps::reset_step(data, step)
     }
 }
 
-#[hdl(no_static)]
-struct CancelInProgressForStageWithQueues<
-    C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig,
-    S: Type + Stage<C>,
-> {
-    cancel_state: Bool,
-    input_queue_to_cancel: UIntInRangeInclusiveType<ConstUsize<0>, StageInputQueueSize<C, S>>,
-    output_queue_to_cancel: UIntInRangeInclusiveType<ConstUsize<0>, StageOutputQueueSize<C, S>>,
+#[hdl]
+struct FetchQueueEntry {
+    fetch_block_id: UInt<{ FETCH_BLOCK_ID_WIDTH }>,
+    btb_entry: HdlOption<BTBEntry>,
+    btb_entry_index: UIntInRange<0, { BranchTargetBuffer::SIZE }>,
+    next_pc: UInt<64>,
 }
 
-#[hdl(no_static)]
-struct StageWithQueues<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig, S: Type + Stage<C>> {
-    input_queue: Queue<StageInput<C, S>, StageInputQueueSize<C, S>>,
-    state: S,
-    output_queue: Queue<StageOutput<C, S>, StageOutputQueueSize<C, S>>,
-    config: C,
-}
-
-impl<C: PhantomConstCpuConfig, S: Stage<C>> StageWithQueues<C, S> {
+impl SimValueDefault for FetchQueueEntry {
     #[hdl]
-    fn to_external_pipe_input_input<PrevLen: Size>(
-        this: &SimValue<Self>,
-        cancel: &SimValue<HdlOption<CancelInProgress<C>>>,
-        prev_stage_output_queue: &SimValue<Queue<StageInput<C, S>, PrevLen>>,
-    ) -> SimValue<StageToExternalPipeInputInput<C, S>> {
+    fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
-        let Self {
-            input_queue,
-            state,
-            output_queue,
-            config,
-        } = this;
-        let config = config.ty();
-        let state_ty = state.ty();
-        let mut retval = StageToExternalPipeInputInput[config][state_ty].sim_value_default();
-        #[hdl(sim)]
-        if let HdlNone = cancel {
-            for input in
-                Queue::peek_iter(prev_stage_output_queue).take(Queue::space_left(&this.input_queue))
-            {
-                let Ok(_) = ArrayVec::try_push_sim(&mut retval, input) else {
-                    break;
-                };
-            }
+        FetchQueueEntry {
+            fetch_block_id: 0 as FetchBlockIdInt,
+            btb_entry: #[hdl(sim)]
+            HdlNone(),
+            btb_entry_index: 0usize.to_sim_value_with_type(FetchQueueEntry.btb_entry_index),
+            next_pc: 0u64,
         }
-        retval
-    }
-    #[hdl]
-    fn to_external_pipe_input_cancel(
-        this: &mut SimValue<Self>,
-        cancel: &mut SimValue<HdlOption<CancelInProgress<C>>>,
-    ) -> SimValue<StageToExternalPipeInputCancel<C, S>> {
-        #[hdl(sim)]
-        let Self {
-            input_queue,
-            state,
-            output_queue,
-            config,
-        } = this;
-        let config = config.ty();
-        let state_ty = state.ty();
-        #[hdl(sim)]
-        if let HdlSome(cancel) = cancel {
-            S::cancel_in_progress_for_stage_mut(cancel)
-                .input_queue_to_cancel
-                .clone()
-        } else {
-            0usize.to_sim_value_with_type(StageToExternalPipeInputCancel[config][state_ty])
-        }
-    }
-    #[hdl]
-    fn to_external_pipe_input_cancel(
-        this: &mut SimValue<Self>,
-        cancel: &mut SimValue<HdlOption<CancelInProgress<C>>>,
-    ) -> SimValue<StageToExternalPipeInputCancel<C, S>> {
-        #[hdl(sim)]
-        let Self {
-            input_queue,
-            state,
-            output_queue,
-            config,
-        } = this;
-        let config = config.ty();
-        let state_ty = state.ty();
-        #[hdl(sim)]
-        if let HdlSome(cancel) = cancel {
-            S::cancel_in_progress_for_stage_mut(cancel)
-                .input_queue_to_cancel
-                .clone()
-        } else {
-            0usize.to_sim_value_with_type(StageToExternalPipeInputCancel[config][state_ty])
-        }
-    }
-    #[hdl]
-    fn run<PrevLen: Size>(
-        this: &mut SimValue<Self>,
-        cancel: &mut SimValue<HdlOption<CancelInProgress<C>>>,
-        to_external_pipe_input_input_ready: usize,
-        prev_stage_output_queue: &mut SimValue<Queue<StageInput<C, S>, PrevLen>>,
-    ) {
-        #[hdl(sim)]
-        let Self {
-            input_queue,
-            state,
-            output_queue,
-            config,
-        } = this;
-        let config = config.ty();
-        todo!()
     }
 }
 
+const BRANCH_PREDICTOR_LOG2_SIZE: usize = 8;
+const BRANCH_PREDICTOR_SIZE: usize = 1 << BRANCH_PREDICTOR_LOG2_SIZE;
+
 #[hdl(no_static)]
-struct CancelInProgress<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
+struct CancelInProgress<C: PhantomConstGet<CpuConfig>> {
     cancel: Cancel<C>,
-    next_pc: CancelInProgressForStageWithQueues<C, NextPcStageState<C>>,
-    br_pred: CancelInProgressForStageWithQueues<C, BrPredStageState<C>>,
-    fetch_decode: CancelInProgressForStageWithQueues<C, FetchDecodeStageState<C>>,
-    post_decode: CancelInProgressForStageWithQueues<C, PostDecodeStageState<C>>,
-    execute_retire: CancelInProgressForStageWithQueues<C, ExecuteRetireStageState<C>>,
+    br_pred_stage_inputs_to_cancel: UIntInRangeInclusive<0, 32>,
+    br_pred_stage_cancel: Bool,
+    fetch_decode_stage_inputs_to_cancel:
+        UIntInRangeInclusiveType<ConstUsize<0>, CpuConfigMaxFetchesInFlight<C>>,
+    fetch_decode_stage_cancel: Bool,
+    post_decode_stage_inputs_to_cancel: UIntInRangeInclusive<0, 1>,
+    post_decode_stage_cancel: Bool,
+    post_decode_stage_outputs_to_cancel:
+        UIntInRangeInclusiveType<ConstUsize<0>, TwiceCpuConfigFetchWidth<C>>,
+    rename_dispatch_execute_stage_inputs_to_cancel: UIntInRangeInclusive<0, 256>,
+    rename_dispatch_execute_stage_cancel: Bool,
+    retire_stage_inputs_to_cancel: UIntInRangeInclusive<0, 1>,
+    retire_stage_cancel: Bool,
     config: C,
 }
 
-impl<C: PhantomConstCpuConfig> CancelInProgress<C> {
+impl CancelInProgress<PhantomConst<CpuConfig>> {
     #[hdl]
     fn to_fetch_cancel_data(
         this: &SimValue<Self>,
-    ) -> SimValue<HdlOption<UIntInRangeInclusiveType<ConstUsize<1>, CpuConfigMaxFetchesInFlight<C>>>>
-    {
+    ) -> SimValue<
+        HdlOption<
+            UIntInRangeInclusiveType<ConstUsize<1>, CpuConfigMaxFetchesInFlight<PhantomConst<CpuConfig>>>,
+        >,
+    > {
         let NextPcStateOutputs {
             to_fetch_cancel_data,
             ..
@@ -2669,12 +2264,12 @@ pub struct StatesAndQueues<C: PhantomConstGet<CpuConfig>> {
     post_decode_stage_outputs: Queue<PostDecodeStageOutput<C>, CpuConfigFetchWidth<C>>,
     rename_dispatch_execute_stage_inputs: Queue<PostDecodeStageOutput<C>, ConstUsize<256>>,
     rename_dispatch_execute_stage_state: RenameDispatchExecuteStageState<C>,
-    retire_stage_inputs: Queue<ExecuteRetireStageInput<C>, ConstUsize<1>>,
-    retire_stage_state: ExecuteRetireStageState<C>,
+    retire_stage_inputs: Queue<RetireStageInput<C>, ConstUsize<1>>,
+    retire_stage_state: RetireStageState<C>,
     config: C,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for StatesAndQueues<C> {
+impl SimValueDefault for StatesAndQueues<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -2713,7 +2308,7 @@ impl<C: PhantomConstCpuConfig> SimValueDefault for StatesAndQueues<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> ResetSteps for StatesAndQueues<C> {
+impl ResetSteps for StatesAndQueues<PhantomConst<CpuConfig>> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -2761,12 +2356,12 @@ impl<C: PhantomConstCpuConfig> ResetSteps for StatesAndQueues<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> StatesAndQueues<C> {
+impl StatesAndQueues<PhantomConst<CpuConfig>> {
     #[hdl]
     fn step_no_cancel(
         this: &mut SimValue<Self>,
-        inputs: SimValue<NextPcStateStepInputs<C>>,
-    ) -> SimValue<HdlOption<CancelInProgress<C>>> {
+        inputs: SimValue<NextPcStateStepInputs<PhantomConst<CpuConfig>>>,
+    ) -> SimValue<HdlOption<CancelInProgress<PhantomConst<CpuConfig>>>> {
         #[hdl(sim)]
         let NextPcStateStepInputs::<_> {
             to_fetch_fetch_triggered,
@@ -2796,20 +2391,18 @@ impl<C: PhantomConstCpuConfig> StatesAndQueues<C> {
         let retval_ty = HdlOption[CancelInProgress[config]];
         let mut retval = #[hdl(sim)]
         retval_ty.HdlNone();
-        if Queue::capacity(br_pred_stage_inputs) - Queue::len(br_pred_stage_inputs) {
-            todo!()
-        }
+        if Queue::capacity(br_pred_stage_inputs) - Queue::len(br_pred_stage_inputs)
         #[hdl(sim)]
-        let StageRunOutput::<_, _> { outputs, cancel } =
+        let StageOutput::<_, _, _> { outputs, cancel } =
             Stage::run(next_pc_stage_state, &().to_sim_value());
-
+        
         retval
     }
     #[hdl]
     fn step_cancel(
         this: &mut SimValue<Self>,
-        cancel_opt: &mut SimValue<HdlOption<CancelInProgress<C>>>,
-        inputs: SimValue<NextPcStateStepInputs<C>>,
+        cancel_opt: &mut SimValue<HdlOption<CancelInProgress<PhantomConst<CpuConfig>>>>,
+        inputs: SimValue<NextPcStateStepInputs<PhantomConst<CpuConfig>>>,
     ) {
         #[hdl(sim)]
         let NextPcStateStepInputs::<_> {
@@ -2917,7 +2510,7 @@ pub struct NextPcState<C: PhantomConstGet<CpuConfig>> {
     cancel: HdlOption<CancelInProgress<C>>,
 }
 
-impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcState<C> {
+impl SimValueDefault for NextPcState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -2932,7 +2525,7 @@ impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcState<C> {
     }
 }
 
-impl<C: PhantomConstCpuConfig> ResetSteps for NextPcState<C> {
+impl ResetSteps for NextPcState<PhantomConst<CpuConfig>> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -2966,9 +2559,9 @@ struct NextPcStateStepInputs<C: PhantomConstGet<CpuConfig>> {
     from_retire_inner_triggered: HdlOption<RetireToNextPcInterfaceInner<C>>,
 }
 
-impl<C: PhantomConstCpuConfig> NextPcState<C> {
+impl NextPcState<PhantomConst<CpuConfig>> {
     #[hdl]
-    fn outputs(this: &SimValue<Self>) -> SimValue<NextPcStateOutputs<C>> {
+    fn outputs(this: &SimValue<Self>) -> SimValue<NextPcStateOutputs<PhantomConst<CpuConfig>>> {
         #[hdl(sim)]
         let Self {
             states_and_queues,
@@ -3053,7 +2646,10 @@ impl<C: PhantomConstCpuConfig> NextPcState<C> {
         }
     }
     #[hdl]
-    fn step(this: &mut SimValue<Self>, inputs: SimValue<NextPcStateStepInputs<C>>) {
+    fn step(
+        this: &mut SimValue<Self>,
+        inputs: SimValue<NextPcStateStepInputs<PhantomConst<CpuConfig>>>,
+    ) {
         #[hdl(sim)]
         let Self {
             states_and_queues,
diff --git a/crates/cpu/src/next_pc/next_pc.mermaid b/crates/cpu/src/next_pc/next_pc.mermaid
index 613e4b3..05ac31c 100644
--- a/crates/cpu/src/next_pc/next_pc.mermaid
+++ b/crates/cpu/src/next_pc/next_pc.mermaid
@@ -16,7 +16,10 @@ stateDiagram-v2
     br_pred --> post_decode
     post_decode --> next_pc: cancel following
 
-    state "Execute/Retire" as execute_retire
-    post_decode --> execute_retire
-    execute_retire --> [*]
-    execute_retire --> next_pc: cancel following
\ No newline at end of file
+    state "Rename\nDispatch\nExecute" as execute
+    post_decode --> execute
+
+    state "Retire" as retire
+    execute --> retire
+    retire --> [*]
+    retire --> next_pc: cancel following
\ No newline at end of file