diff --git a/crates/cpu/src/config.rs b/crates/cpu/src/config.rs
index a7dd7d9..cf2fd08 100644
--- a/crates/cpu/src/config.rs
+++ b/crates/cpu/src/config.rs
@@ -163,3 +163,15 @@ 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 45c3db5..e76fa6a 100644
--- a/crates/cpu/src/next_pc.rs
+++ b/crates/cpu/src/next_pc.rs
@@ -14,7 +14,7 @@
 use crate::{
     config::{
         CpuConfig, CpuConfigFetchWidth, CpuConfigMaxFetchesInFlight, CpuConfigRobSize,
-        TwiceCpuConfigFetchWidth,
+        PhantomConstCpuConfig, TwiceCpuConfigFetchWidth,
     },
     util::array_vec::ArrayVec,
 };
@@ -115,7 +115,7 @@ pub struct RetireToNextPcInterfacePerInsn<C: PhantomConstGet<CpuConfig>> {
     pub config: C,
 }
 
-impl SimValueDefault for RetireToNextPcInterfacePerInsn<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for RetireToNextPcInterfacePerInsn<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -159,7 +159,7 @@ pub struct DecodeToPostDecodeInterfaceInner<C: PhantomConstGet<CpuConfig>> {
     pub config: C,
 }
 
-impl SimValueDefault for DecodeToPostDecodeInterfaceInner<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for DecodeToPostDecodeInterfaceInner<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self { insns, config } = self;
@@ -204,150 +204,231 @@ struct Cancel<C: PhantomConstGet<CpuConfig>> {
 }
 
 /// the output of [`Stage::run`].
-/// when cancelling operations, the returned [`StageOutput.cancel`] should be the state after
-/// running all operations returned in [`StageOutput.output`].
+/// when cancelling operations, the returned [`StageRunOutput.cancel`] should be the state after
+/// running all operations returned in [`StageRunOutput.output`].
 #[hdl(no_static)]
-struct StageOutput<Output, MaxOutputCount: Size, C: PhantomConstGet<CpuConfig>> {
-    outputs: ArrayVec<Output, MaxOutputCount>,
+struct StageRunOutput<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig, S: Type + Stage<C>> {
+    outputs: ArrayVec<StageOutput<C, S>, StageMaxOutputsPerStep<C, S>>,
     /// when set to [`HdlSome`], [`Stage::cancel`] is called on all previous stages
     cancel: HdlOption<Cancel<C>>,
 }
 
-trait Stage: Type + SimValueDefault + ResetSteps {
-    type Input: Type;
+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;
     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;
 
-    fn input_ty(config: PhantomConst<CpuConfig>) -> Self::Input;
-    fn inputs_ty(config: PhantomConst<CpuConfig>) -> Self::Inputs;
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output;
-    fn max_outputs_per_step(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType;
-    fn input_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType;
-    fn output_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType;
-    fn stage_output_ty(
-        config: PhantomConst<CpuConfig>,
-    ) -> StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>> {
-        StageOutput[Self::output_ty(config)][Self::max_outputs_per_step(config)][config]
-    }
-    /// see [`StageOutput`] for docs on output
+    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 run(
         state: &mut SimValue<Self>,
         inputs: &SimValue<Self::Inputs>,
-    ) -> SimValue<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>>;
+    ) -> SimValue<StageRunOutput<C, Self>>;
     /// changes state to match `cancel`
-    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>);
+    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<C>>);
 }
 
 macro_rules! hdl_type_alias_with_generics {
     (
         #[without_generics = $WithoutGenerics:ident, $OneGeneric:ident]
         #[ty = $ty:expr]
-        $vis:vis type $Type:ident<$Arg:ident: $Trait:ident, $C:ident: PhantomConstGet<CpuConfig>> = $Target:ty;
+        $vis:vis type $Type:ident<$C:ident: $PhantomConstCpuConfig:ident, $Arg:ident: $Trait:ident<$TraitC:ident>> = $Target:ty;
     ) => {
-        $vis type $Type<$Arg, $C> = <$Target as fayalite::phantom_const::ReturnSelfUnchanged<$C>>::Type;
+        $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 {};
 
-        #[derive(Clone, PartialEq, Eq, Hash, Debug)]
-        $vis struct $OneGeneric<$Arg: $Trait>($Arg);
+        const _: () = {
+            #[derive(Clone, PartialEq, Eq, Hash, Debug)]
+            $vis struct $OneGeneric<$C: $PhantomConstCpuConfig>($C);
 
-        impl<$Arg: $Trait> std::ops::Index<$Arg> for $WithoutGenerics {
-            type Output = $OneGeneric<$Arg>;
+            impl<$C: $PhantomConstCpuConfig> std::ops::Index<$C> for $WithoutGenerics {
+                type Output = $OneGeneric<$C>;
 
-            fn index(&self, arg: $Arg) -> &Self::Output {
-                fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($OneGeneric(arg)))
+                fn index(&self, config: $C) -> &Self::Output {
+                    fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($OneGeneric(config)))
+                }
             }
-        }
 
-        impl<$Arg: $Trait, $C: PhantomConstGet<CpuConfig>> std::ops::Index<$C> for $OneGeneric<$Arg> {
-            type Output = $Type<$Arg, $C>;
+            impl<$C: $PhantomConstCpuConfig, $Arg: $Trait<$TraitC>> std::ops::Index<$Arg> for $OneGeneric<$C> {
+                type Output = $Type<$C, $Arg>;
 
-            fn index(&self, config: $C) -> &Self::Output {
-                fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($ty(self.0, config)))
+                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<$Arg:ident: $Trait:ident, $C:ident: PhantomConstGet<CpuConfig>> = $Target:ty;
+        $vis:vis type $Type:ident<$C:ident: $PhantomConstCpuConfig:ident, $Arg:ident: $Trait:ident<$TraitC:ident>> = $Target:ty;
     ) => {
-        $vis type $Type<$Arg, $C> = <$Target as fayalite::phantom_const::ReturnSelfUnchanged<$C>>::Type;
+        $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 {};
 
-        #[derive(Clone, PartialEq, Eq, Hash, Debug)]
-        $vis struct $OneGeneric<$Arg: $Trait>($Arg);
+        const _: () = {
+            #[derive(Clone, PartialEq, Eq, Hash, Debug)]
+            $vis struct $OneGeneric<$C: $PhantomConstCpuConfig>($C);
 
-        impl<$Arg: $Trait> std::ops::Index<$Arg> for $WithoutGenerics {
-            type Output = $OneGeneric<$Arg>;
+            impl<$C: $PhantomConstCpuConfig> std::ops::Index<$C> for $WithoutGenerics {
+                type Output = $OneGeneric<$C>;
 
-            fn index(&self, arg: $Arg) -> &Self::Output {
-                fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($OneGeneric(arg)))
+                fn index(&self, config: $C) -> &Self::Output {
+                    fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($OneGeneric(config)))
+                }
             }
-        }
 
-        impl<$Arg: $Trait, $C: PhantomConstGet<CpuConfig>> std::ops::Index<$C> for $OneGeneric<$Arg> {
-            type Output = <$Type<$Arg, $C> as Size>::SizeType;
+            impl<$C: $PhantomConstCpuConfig, $Arg: $Trait<$TraitC>> std::ops::Index<$Arg> for $OneGeneric<$C> {
+                type Output = <$Type<$C, $Arg> as Size>::SizeType;
 
-            fn index(&self, config: $C) -> &Self::Output {
-                fayalite::intern::Interned::into_inner(fayalite::intern::Intern::intern_sized($size(self.0, config)))
+                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 = StageTraitInputWithoutGenerics, StageTraitInputWithStage]
-    #[ty = |_stage, config: C| T::input_ty(PhantomConst::new_interned(config.get()))]
-    type StageTraitInput<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::Input;
+    #[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 = StageTraitInputsWithoutGenerics, StageTraitInputsWithStage]
-    #[ty = |_stage, config: C| T::inputs_ty(PhantomConst::new_interned(config.get()))]
-    type StageTraitInputs<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::Inputs;
+    #[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 = StageTraitOutputWithoutGenerics, StageTraitOutputWithStage]
-    #[ty = |_stage, config: C| T::output_ty(PhantomConst::new_interned(config.get()))]
-    type StageTraitOutput<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::Output;
+    #[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 = |_stage, config: C| T::max_outputs_per_step(PhantomConst::new_interned(config.get()))]
-    type StageMaxOutputsPerStep<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::MaxOutputsPerStep;
+    #[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 = |_stage, config: C| T::input_queue_size(PhantomConst::new_interned(config.get()))]
-    type StageInputQueueSize<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::InputQueueSize;
+    #[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 = |_stage, config: C| T::output_queue_size(PhantomConst::new_interned(config.get()))]
-    type StageOutputQueueSize<T: Stage, C: PhantomConstGet<CpuConfig>> = <T as Stage>::OutputQueueSize;
+    #[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>,
@@ -361,7 +442,7 @@ struct NextPcStageOutput<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for NextPcStageOutput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcStageOutput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -386,7 +467,7 @@ impl SimValueDefault for NextPcStageOutput<PhantomConst<CpuConfig>> {
 }
 
 #[hdl(no_static)]
-struct NextPcStageState<C: PhantomConstGet<CpuConfig>> {
+struct NextPcStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
     call_stack: CallStack,
     branch_target_buffer: BranchTargetBuffer,
     next_pc: UInt<64>,
@@ -394,7 +475,7 @@ struct NextPcStageState<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for NextPcStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcStageState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -417,7 +498,7 @@ impl SimValueDefault for NextPcStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for NextPcStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for NextPcStageState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -436,49 +517,60 @@ impl ResetSteps for NextPcStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl Stage for NextPcStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> Stage<C> for NextPcStageState<C> {
     type Input = ();
     type Inputs = ();
-    type Output = NextPcStageOutput<PhantomConst<CpuConfig>>;
+    type Output = NextPcStageOutput<C>;
+    type ToExternalPipeInputInterface = ();
+    type FromExternalPipeOutputInterface = ();
     type MaxOutputsPerStep = ConstUsize<1>;
     type InputQueueSize = ConstUsize<1>;
     type OutputQueueSize = ConstUsize<1>;
 
-    fn input_ty(_config: PhantomConst<CpuConfig>) -> Self::Input {
+    fn input_ty(_config: C) -> Self::Input {
         ()
     }
 
-    fn inputs_ty(_config: PhantomConst<CpuConfig>) -> Self::Inputs {
+    fn inputs_ty(_config: C) -> Self::Inputs {
         ()
     }
 
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+    fn output_ty(config: C) -> Self::Output {
         NextPcStageOutput[config]
     }
 
-    fn max_outputs_per_step(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    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 {
         ConstUsize
     }
 
-    fn input_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType {
+    fn input_queue_size(_config: C) -> <Self::InputQueueSize as Size>::SizeType {
         ConstUsize
     }
 
-    fn output_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType {
+    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<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>> {
+    ) -> SimValue<StageRunOutput<C, Self>> {
+        let this_ty = state.ty();
         let config = state.config.ty();
         let start_call_stack = state.call_stack.clone();
         let fetch_block_id = state.next_fetch_block_id.as_int();
@@ -557,15 +649,17 @@ impl Stage for NextPcStageState<PhantomConst<CpuConfig>> {
             config,
         };
         #[hdl(sim)]
-        StageOutput::<_, _, _> {
-            outputs: Self::stage_output_ty(config).outputs.new_full_sim([output]),
+        StageRunOutput::<_, _> {
+            outputs: StageRunOutput[config][this_ty]
+                .outputs
+                .new_full_sim([output]),
             cancel: #[hdl(sim)]
             (HdlOption[Cancel[config]]).HdlNone(),
         }
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
+    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<C>>) {
         #[hdl(sim)]
         let Self {
             call_stack,
@@ -645,7 +739,7 @@ struct BrPredStageOutput<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for BrPredStageOutput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for BrPredStageOutput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -659,7 +753,7 @@ impl SimValueDefault for BrPredStageOutput<PhantomConst<CpuConfig>> {
 }
 
 #[hdl(no_static)]
-struct BrPredStageState<C: PhantomConstGet<CpuConfig>> {
+struct BrPredStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
     branch_history: UInt<6>,
     branch_predictor: Array<BranchPredictionState, { BRANCH_PREDICTOR_SIZE }>,
     config: C,
@@ -670,7 +764,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 BrPredStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> BrPredStageState<C> {
     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);
@@ -684,7 +778,7 @@ impl BrPredStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl SimValueDefault for BrPredStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for BrPredStageState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -705,7 +799,7 @@ impl SimValueDefault for BrPredStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for BrPredStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for BrPredStageState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -719,49 +813,60 @@ impl ResetSteps for BrPredStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl Stage for BrPredStageState<PhantomConst<CpuConfig>> {
-    type Input = NextPcStageOutput<PhantomConst<CpuConfig>>;
-    type Inputs = NextPcStageOutput<PhantomConst<CpuConfig>>;
-    type Output = BrPredStageOutput<PhantomConst<CpuConfig>>;
+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<PhantomConst<CpuConfig>>;
+    type OutputQueueSize = CpuConfigMaxFetchesInFlight<C>;
 
-    fn input_ty(config: PhantomConst<CpuConfig>) -> Self::Input {
+    fn input_ty(config: C) -> Self::Input {
         NextPcStageOutput[config]
     }
 
-    fn inputs_ty(config: PhantomConst<CpuConfig>) -> Self::Inputs {
+    fn inputs_ty(config: C) -> Self::Inputs {
         NextPcStageOutput[config]
     }
 
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+    fn output_ty(config: C) -> Self::Output {
         BrPredStageOutput[config]
     }
 
-    fn max_outputs_per_step(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    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 {
         ConstUsize
     }
 
-    fn input_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType {
+    fn input_queue_size(_config: C) -> <Self::InputQueueSize as Size>::SizeType {
         ConstUsize
     }
 
-    fn output_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType {
+    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<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>> {
+    ) -> SimValue<StageRunOutput<C, Self>> {
+        let this_ty = state.ty();
         let config = state.config.ty();
         #[hdl(sim)]
         let NextPcStageOutput::<_> {
@@ -806,9 +911,9 @@ impl Stage for BrPredStageState<PhantomConst<CpuConfig>> {
                     let btb_entry_index = &btb_entry.0;
                     let mut btb_entry = btb_entry.1.clone();
                     btb_entry.addr_kind = opposite_addr_kind;
-                    let StageOutput { outputs, cancel } = Self::stage_output_ty(config);
+                    let StageRunOutput { outputs, cancel } = StageRunOutput[config][this_ty];
                     let retval = #[hdl(sim)]
-                    StageOutput::<_, _, _> {
+                    StageRunOutput::<_, _> {
                         outputs: outputs.sim_value_default(),
                         cancel: #[hdl(sim)]
                         cancel.HdlSome(
@@ -839,15 +944,17 @@ impl Stage for BrPredStageState<PhantomConst<CpuConfig>> {
             config,
         };
         #[hdl(sim)]
-        StageOutput::<_, _, _> {
-            outputs: Self::stage_output_ty(config).outputs.new_full_sim([output]),
+        StageRunOutput::<_, _> {
+            outputs: StageRunOutput[config][this_ty]
+                .outputs
+                .new_full_sim([output]),
             cancel: #[hdl(sim)]
             (HdlOption[Cancel[config]]).HdlNone(),
         }
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
+    fn cancel(state: &mut SimValue<Self>, cancel: &SimValue<Cancel<C>>) {
         #[hdl(sim)]
         let Cancel::<_> {
             call_stack: _,
@@ -861,7 +968,7 @@ impl Stage for BrPredStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl BrPredStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> BrPredStageState<C> {
     #[hdl]
     fn train_branch_predictor(
         this: &mut SimValue<Self>,
@@ -884,11 +991,11 @@ impl BrPredStageState<PhantomConst<CpuConfig>> {
 }
 
 #[hdl(no_static)]
-struct FetchDecodeStageState<C: PhantomConstGet<CpuConfig>> {
+struct FetchDecodeStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
     config: C,
 }
 
-impl SimValueDefault for FetchDecodeStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for FetchDecodeStageState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -898,7 +1005,7 @@ impl SimValueDefault for FetchDecodeStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for FetchDecodeStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for FetchDecodeStageState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, _step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -913,7 +1020,7 @@ struct FetchDecodeStageOutput<C: PhantomConstGet<CpuConfig>> {
     decode_output: DecodeToPostDecodeInterfaceInner<C>,
 }
 
-impl SimValueDefault for FetchDecodeStageOutput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for FetchDecodeStageOutput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -928,55 +1035,66 @@ impl SimValueDefault for FetchDecodeStageOutput<PhantomConst<CpuConfig>> {
     }
 }
 
-impl Stage for FetchDecodeStageState<PhantomConst<CpuConfig>> {
-    type Input = NextPcStageOutput<PhantomConst<CpuConfig>>;
-    type Inputs = FetchDecodeStageOutput<PhantomConst<CpuConfig>>;
-    type Output = FetchDecodeStageOutput<PhantomConst<CpuConfig>>;
+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<PhantomConst<CpuConfig>>;
+    type InputQueueSize = CpuConfigMaxFetchesInFlight<C>;
     type OutputQueueSize = ConstUsize<1>;
 
-    fn input_ty(config: PhantomConst<CpuConfig>) -> Self::Input {
+    fn input_ty(config: C) -> Self::Input {
         NextPcStageOutput[config]
     }
 
-    fn inputs_ty(config: PhantomConst<CpuConfig>) -> Self::Inputs {
+    fn inputs_ty(config: C) -> Self::Inputs {
         FetchDecodeStageOutput[config]
     }
 
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+    fn output_ty(config: C) -> Self::Output {
         FetchDecodeStageOutput[config]
     }
 
-    fn max_outputs_per_step(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    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 {
         ConstUsize
     }
 
-    fn input_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType {
+    fn input_queue_size(config: C) -> <Self::InputQueueSize as Size>::SizeType {
         CpuConfigMaxFetchesInFlight[config]
     }
 
-    fn output_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType {
+    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<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>> {
+    ) -> SimValue<StageRunOutput<C, Self>> {
+        let this_ty = state.ty();
         #[hdl(sim)]
         let Self { config } = state;
         let config = config.ty();
-        let StageOutput { outputs, cancel } = Self::stage_output_ty(config);
+        let StageRunOutput { outputs, cancel } = StageRunOutput[config][this_ty];
         #[hdl(sim)]
-        StageOutput::<_, _, _> {
+        StageRunOutput::<_, _> {
             outputs: outputs.new_full_sim([inputs]),
             cancel: #[hdl(sim)]
             cancel.HdlNone(),
@@ -984,14 +1102,14 @@ impl Stage for FetchDecodeStageState<PhantomConst<CpuConfig>> {
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
+    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<C>>) {
         #[hdl(sim)]
         let Self { config: _ } = state;
     }
 }
 
 #[hdl(no_static)]
-struct PostDecodeStageState<C: PhantomConstGet<CpuConfig>> {
+struct PostDecodeStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
     config: C,
 }
 
@@ -1001,7 +1119,7 @@ struct PostDecodeStageInput<C: PhantomConstGet<CpuConfig>> {
     br_pred_stage_output: BrPredStageOutput<C>,
 }
 
-impl SimValueDefault for PostDecodeStageInput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for PostDecodeStageInput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -1023,7 +1141,7 @@ struct PostDecodeStageOutput<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for PostDecodeStageOutput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for PostDecodeStageOutput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -1041,7 +1159,7 @@ impl SimValueDefault for PostDecodeStageOutput<PhantomConst<CpuConfig>> {
     }
 }
 
-impl SimValueDefault for PostDecodeStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for PostDecodeStageState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         #[hdl(sim)]
@@ -1051,7 +1169,7 @@ impl SimValueDefault for PostDecodeStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for PostDecodeStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for PostDecodeStageState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, _step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -1060,49 +1178,60 @@ impl ResetSteps for PostDecodeStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
-    type Input = PostDecodeStageInput<PhantomConst<CpuConfig>>;
-    type Inputs = PostDecodeStageInput<PhantomConst<CpuConfig>>;
-    type Output = PostDecodeStageOutput<PhantomConst<CpuConfig>>;
-    type MaxOutputsPerStep = CpuConfigFetchWidth<PhantomConst<CpuConfig>>;
+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<PhantomConst<CpuConfig>>;
+    type OutputQueueSize = TwiceCpuConfigFetchWidth<C>;
 
-    fn input_ty(config: PhantomConst<CpuConfig>) -> Self::Input {
+    fn input_ty(config: C) -> Self::Input {
         PostDecodeStageInput[config]
     }
 
-    fn inputs_ty(config: PhantomConst<CpuConfig>) -> Self::Inputs {
+    fn inputs_ty(config: C) -> Self::Inputs {
         PostDecodeStageInput[config]
     }
 
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+    fn output_ty(config: C) -> Self::Output {
         PostDecodeStageOutput[config]
     }
 
-    fn max_outputs_per_step(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    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 {
         CpuConfigFetchWidth[config]
     }
 
-    fn input_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType {
+    fn input_queue_size(_config: C) -> <Self::InputQueueSize as Size>::SizeType {
         ConstUsize
     }
 
-    fn output_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType {
+    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<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>> {
+    ) -> SimValue<StageRunOutput<C, Self>> {
+        let this_ty = state.ty();
         #[hdl(sim)]
         let Self { config } = state;
         let config = config.ty();
@@ -1140,10 +1269,10 @@ impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
             -- either the decoded instructions or a WipDecodedInsnKind::Interrupt",
         );
         let insns = ArrayVec::elements_sim_ref(&insns);
-        let StageOutput {
+        let StageRunOutput {
             outputs: outputs_ty,
             cancel: cancel_ty,
-        } = Self::stage_output_ty(config);
+        } = StageRunOutput[config][this_ty];
         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>,
@@ -1192,7 +1321,7 @@ impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
             let mut call_stack = start_call_stack.clone();
             CallStack::push(&mut call_stack, start_pc);
             let retval = #[hdl(sim)]
-            StageOutput::<_, _, _> {
+            StageRunOutput::<_, _> {
                 outputs,
                 cancel: #[hdl(sim)]
                 cancel_ty.HdlSome(
@@ -1389,7 +1518,7 @@ impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
         };
         if *new_btb_entry.cmp_ne(predicted_btb_entry) {
             #[hdl(sim)]
-            StageOutput::<_, _, _> {
+            StageRunOutput::<_, _> {
                 outputs: outputs_ty.sim_value_default(),
                 cancel: #[hdl(sim)]
                 cancel_ty.HdlSome(
@@ -1406,7 +1535,7 @@ impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
             }
         } else {
             #[hdl(sim)]
-            StageOutput::<_, _, _> {
+            StageRunOutput::<_, _> {
                 outputs,
                 cancel: #[hdl(sim)]
                 cancel_ty.HdlNone(),
@@ -1415,7 +1544,7 @@ impl Stage for PostDecodeStageState<PhantomConst<CpuConfig>> {
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
+    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<C>>) {
         #[hdl(sim)]
         let Self { config: _ } = state;
     }
@@ -1427,7 +1556,7 @@ struct ExecuteRetireStageInput<C: PhantomConstGet<CpuConfig>> {
     retire_interface_per_insn: RetireToNextPcInterfacePerInsn<C>,
 }
 
-impl SimValueDefault for ExecuteRetireStageInput<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for ExecuteRetireStageInput<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -1443,7 +1572,7 @@ impl SimValueDefault for ExecuteRetireStageInput<PhantomConst<CpuConfig>> {
 }
 
 #[hdl(no_static)]
-struct ExecuteRetireStageState<C: PhantomConstGet<CpuConfig>> {
+struct ExecuteRetireStageState<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
     config: C,
 }
 
@@ -1453,7 +1582,7 @@ struct ExecuteRetireStageOutput<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for ExecuteRetireStageState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self { config } = self;
@@ -1462,7 +1591,7 @@ impl SimValueDefault for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for ExecuteRetireStageState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, _step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -1471,49 +1600,60 @@ impl ResetSteps for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl Stage for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
-    type Input = PostDecodeStageOutput<PhantomConst<CpuConfig>>;
-    type Inputs = ExecuteRetireStageInput<PhantomConst<CpuConfig>>;
-    type Output = ExecuteRetireStageOutput<PhantomConst<CpuConfig>>;
+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<PhantomConst<CpuConfig>>;
+    type InputQueueSize = CpuConfigRobSize<C>;
     type OutputQueueSize = ConstUsize<1>;
 
-    fn input_ty(config: PhantomConst<CpuConfig>) -> Self::Input {
+    fn input_ty(config: C) -> Self::Input {
         PostDecodeStageOutput[config]
     }
 
-    fn inputs_ty(config: PhantomConst<CpuConfig>) -> Self::Inputs {
+    fn inputs_ty(config: C) -> Self::Inputs {
         ExecuteRetireStageInput[config]
     }
 
-    fn output_ty(config: PhantomConst<CpuConfig>) -> Self::Output {
+    fn output_ty(config: C) -> Self::Output {
         ExecuteRetireStageOutput[config]
     }
 
-    fn max_outputs_per_step(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::MaxOutputsPerStep as Size>::SizeType {
+    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 {
         ConstUsize
     }
 
-    fn input_queue_size(
-        config: PhantomConst<CpuConfig>,
-    ) -> <Self::InputQueueSize as Size>::SizeType {
+    fn input_queue_size(config: C) -> <Self::InputQueueSize as Size>::SizeType {
         CpuConfigRobSize[config]
     }
 
-    fn output_queue_size(
-        _config: PhantomConst<CpuConfig>,
-    ) -> <Self::OutputQueueSize as Size>::SizeType {
+    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<StageOutput<Self::Output, Self::MaxOutputsPerStep, PhantomConst<CpuConfig>>> {
+    ) -> SimValue<StageRunOutput<C, Self>> {
+        let this_ty = state.ty();
         #[hdl(sim)]
         let Self { config } = state;
         let config = config.ty();
@@ -1541,10 +1681,10 @@ impl Stage for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
             config: _,
         } = post_decode_stage_output;
         assert_eq!(*id, insn.id, "instruction queuing out of sync");
-        let StageOutput {
+        let StageRunOutput {
             outputs: outputs_ty,
             cancel: cancel_ty,
-        } = Self::stage_output_ty(config);
+        } = StageRunOutput[config][this_ty];
         let mut branch_history = start_branch_history.clone();
         let train_branch_predictor = #[hdl(sim)]
         if let HdlSome(taken) = cond_br_taken {
@@ -1671,7 +1811,7 @@ impl Stage for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
                 CallStackOp::Unknown => unreachable!(),
             }
             #[hdl(sim)]
-            StageOutput::<_, _, _> {
+            StageRunOutput::<_, _> {
                 outputs: outputs_ty.new_sim(
                     #[hdl(sim)]
                     ExecuteRetireStageOutput::<_> {
@@ -1694,7 +1834,7 @@ impl Stage for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
             }
         } else {
             #[hdl(sim)]
-            StageOutput::<_, _, _> {
+            StageRunOutput::<_, _> {
                 outputs: outputs_ty.new_full_sim([
                     #[hdl(sim)]
                     ExecuteRetireStageOutput::<_> {
@@ -1709,7 +1849,7 @@ impl Stage for ExecuteRetireStageState<PhantomConst<CpuConfig>> {
     }
 
     #[hdl]
-    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<PhantomConst<CpuConfig>>>) {
+    fn cancel(state: &mut SimValue<Self>, _cancel: &SimValue<Cancel<C>>) {
         #[hdl(sim)]
         let Self { config: _ } = state;
     }
@@ -1794,6 +1934,18 @@ 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())
@@ -2231,6 +2383,8 @@ 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> {
@@ -2241,21 +2395,27 @@ 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.head == this.tail && !*this.eq_head_tail_means_full
     }
     fn is_full(this: &SimValue<Self>) -> bool {
-        let head = *this.head;
-        let tail = *this.tail;
-        this.ty().next_pos(head) == tail
+        this.head == this.tail && *this.eq_head_tail_means_full
     }
     fn len(this: &SimValue<Self>) -> usize {
         let capacity = this.ty().capacity();
-        (*this.tail + capacity - *this.head) % capacity
+        if Self::is_full(this) {
+            capacity
+        } else {
+            (*this.tail + capacity - *this.head) % capacity
+        }
     }
     fn space_left(this: &SimValue<Self>) -> usize {
         this.ty().capacity() - Self::len(this)
@@ -2263,6 +2423,7 @@ 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) {
@@ -2271,6 +2432,7 @@ 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(())
@@ -2284,6 +2446,7 @@ 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)
         }
     }
@@ -2294,6 +2457,11 @@ 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
@@ -2301,6 +2469,7 @@ 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)
         }
     }
@@ -2309,7 +2478,12 @@ 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 } = self;
+        let Self {
+            data,
+            head,
+            tail,
+            eq_head_tail_means_full: _,
+        } = self;
         #[hdl(sim)]
         Queue::<T, Capacity> {
             data: repeat(
@@ -2318,6 +2492,7 @@ 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,
         }
     }
 }
@@ -2326,55 +2501,148 @@ 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 } = this;
+        let Queue::<T, Capacity> {
+            data,
+            head,
+            tail,
+            eq_head_tail_means_full,
+        } = this;
         **head = 0;
         **tail = 0;
+        **eq_head_tail_means_full = false;
         ResetSteps::reset_step(data, step)
     }
 }
 
 #[hdl(no_static)]
-struct StageWithQueues<S: Type + Stage, C: PhantomConstGet<CpuConfig>> {
-    state: S,
-    input_queue: Queue<StageTraitInput<S, C>, StageInputQueueSize<S, C>>,
-    output_queue: Queue<StageTraitOutput<S, C>, StageOutputQueueSize<S, C>>,
-}
-
-impl<S: Stage> StageWithQueues<S, PhantomConst<CpuConfig>> {
-    FIXME
+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(no_static)]
-struct CancelInProgress<C: PhantomConstGet<CpuConfig>> {
-    cancel: Cancel<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,
+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 CancelInProgress<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig, S: Stage<C>> StageWithQueues<C, S> {
+    #[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>> {
+        #[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;
+                };
+            }
+        }
+        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!()
+    }
+}
+
+#[hdl(no_static)]
+struct CancelInProgress<C: PhantomConstGet<CpuConfig> + PhantomConstCpuConfig> {
+    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>>,
+    config: C,
+}
+
+impl<C: PhantomConstCpuConfig> CancelInProgress<C> {
     #[hdl]
     fn to_fetch_cancel_data(
         this: &SimValue<Self>,
-    ) -> SimValue<
-        HdlOption<
-            UIntInRangeInclusiveType<
-                ConstUsize<1>,
-                CpuConfigMaxFetchesInFlight<PhantomConst<CpuConfig>>,
-            >,
-        >,
-    > {
+    ) -> SimValue<HdlOption<UIntInRangeInclusiveType<ConstUsize<1>, CpuConfigMaxFetchesInFlight<C>>>>
+    {
         let NextPcStateOutputs {
             to_fetch_cancel_data,
             ..
@@ -2406,7 +2674,7 @@ pub struct StatesAndQueues<C: PhantomConstGet<CpuConfig>> {
     config: C,
 }
 
-impl SimValueDefault for StatesAndQueues<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for StatesAndQueues<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -2445,7 +2713,7 @@ impl SimValueDefault for StatesAndQueues<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for StatesAndQueues<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for StatesAndQueues<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -2493,12 +2761,12 @@ impl ResetSteps for StatesAndQueues<PhantomConst<CpuConfig>> {
     }
 }
 
-impl StatesAndQueues<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> StatesAndQueues<C> {
     #[hdl]
     fn step_no_cancel(
         this: &mut SimValue<Self>,
-        inputs: SimValue<NextPcStateStepInputs<PhantomConst<CpuConfig>>>,
-    ) -> SimValue<HdlOption<CancelInProgress<PhantomConst<CpuConfig>>>> {
+        inputs: SimValue<NextPcStateStepInputs<C>>,
+    ) -> SimValue<HdlOption<CancelInProgress<C>>> {
         #[hdl(sim)]
         let NextPcStateStepInputs::<_> {
             to_fetch_fetch_triggered,
@@ -2532,7 +2800,7 @@ impl StatesAndQueues<PhantomConst<CpuConfig>> {
             todo!()
         }
         #[hdl(sim)]
-        let StageOutput::<_, _, _> { outputs, cancel } =
+        let StageRunOutput::<_, _> { outputs, cancel } =
             Stage::run(next_pc_stage_state, &().to_sim_value());
 
         retval
@@ -2540,8 +2808,8 @@ impl StatesAndQueues<PhantomConst<CpuConfig>> {
     #[hdl]
     fn step_cancel(
         this: &mut SimValue<Self>,
-        cancel_opt: &mut SimValue<HdlOption<CancelInProgress<PhantomConst<CpuConfig>>>>,
-        inputs: SimValue<NextPcStateStepInputs<PhantomConst<CpuConfig>>>,
+        cancel_opt: &mut SimValue<HdlOption<CancelInProgress<C>>>,
+        inputs: SimValue<NextPcStateStepInputs<C>>,
     ) {
         #[hdl(sim)]
         let NextPcStateStepInputs::<_> {
@@ -2649,7 +2917,7 @@ pub struct NextPcState<C: PhantomConstGet<CpuConfig>> {
     cancel: HdlOption<CancelInProgress<C>>,
 }
 
-impl SimValueDefault for NextPcState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> SimValueDefault for NextPcState<C> {
     #[hdl]
     fn sim_value_default(self) -> SimValue<Self> {
         let Self {
@@ -2664,7 +2932,7 @@ impl SimValueDefault for NextPcState<PhantomConst<CpuConfig>> {
     }
 }
 
-impl ResetSteps for NextPcState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> ResetSteps for NextPcState<C> {
     #[hdl]
     fn reset_step(this: &mut SimValue<Self>, step: usize) -> ResetStatus {
         #[hdl(sim)]
@@ -2698,9 +2966,9 @@ struct NextPcStateStepInputs<C: PhantomConstGet<CpuConfig>> {
     from_retire_inner_triggered: HdlOption<RetireToNextPcInterfaceInner<C>>,
 }
 
-impl NextPcState<PhantomConst<CpuConfig>> {
+impl<C: PhantomConstCpuConfig> NextPcState<C> {
     #[hdl]
-    fn outputs(this: &SimValue<Self>) -> SimValue<NextPcStateOutputs<PhantomConst<CpuConfig>>> {
+    fn outputs(this: &SimValue<Self>) -> SimValue<NextPcStateOutputs<C>> {
         #[hdl(sim)]
         let Self {
             states_and_queues,
@@ -2785,10 +3053,7 @@ impl NextPcState<PhantomConst<CpuConfig>> {
         }
     }
     #[hdl]
-    fn step(
-        this: &mut SimValue<Self>,
-        inputs: SimValue<NextPcStateStepInputs<PhantomConst<CpuConfig>>>,
-    ) {
+    fn step(this: &mut SimValue<Self>, inputs: SimValue<NextPcStateStepInputs<C>>) {
         #[hdl(sim)]
         let Self {
             states_and_queues,