From 87e3732f95724a2b50b5e5361d981dd2a1f8c8eb Mon Sep 17 00:00:00 2001
From: Matty Kuhn <mattykuh@amazon.com>
Date: Fri, 10 Apr 2026 15:49:45 -0600
Subject: [PATCH 1/2] add infallible serialization functionality

---
 vest-dsl/src/codegen.rs               |   55 +
 vest-dsl/test/src/anonymous_nested.rs |  439 ++++++
 vest-dsl/test/src/codegen.rs          |  127 ++
 vest-dsl/test/src/elab.rs             |  163 +++
 vest-dsl/test/src/enum_constraints.rs |   86 ++
 vest-dsl/test/src/enums.rs            |  210 +++
 vest-dsl/test/src/ikev2.rs            | 1782 ++++++++++++++++++++++++-
 vest-dsl/test/src/josh.rs             |  107 ++
 vest-dsl/test/src/length_expr.rs      |  415 ++++++
 vest-dsl/test/src/matches.rs          |  246 ++++
 vest-dsl/test/src/nested_access.rs    |  107 ++
 vest-dsl/test/src/opt.rs              |   86 ++
 vest-dsl/test/src/repeat.rs           |  106 ++
 vest/Cargo.toml                       |    2 +-
 vest/src/infallible.rs                |  750 +++++++++++
 vest/src/lib.rs                       |    2 +
 16 files changed, 4678 insertions(+), 5 deletions(-)
 create mode 100644 vest/src/infallible.rs

diff --git a/vest-dsl/src/codegen.rs b/vest-dsl/src/codegen.rs
index 728d7d13..00d6e4e6 100644
--- a/vest-dsl/src/codegen.rs
+++ b/vest-dsl/src/codegen.rs
@@ -664,6 +664,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for {name}Combinator {{
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     {{ <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }}
 }}
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for {name}Combinator {{
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    {{ <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }}
+}}
 "#
                     )
                 }
@@ -3715,6 +3719,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -3733,6 +3738,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -3928,6 +3938,22 @@ pub fn serialize_{name}<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }}
 
+pub fn serialize_{name}_infallible<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_{name}().wf(v@),
+        spec_{name}().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_{name}().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_{name}().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_{name}().spec_serialize(v@)),
+{{
+    let combinator = {name}();
+    serialize_infallible(&combinator, v, data, pos)
+}}
+
 pub fn {name}_len<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_{name}().wf(v@),
@@ -4077,6 +4103,19 @@ pub fn serialize_{name}<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'
     combinator.serialize(v, data, pos)
 }}
 
+pub fn serialize_{name}_infallible<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, {exec_params}) -> (n: usize)
+{serialize_requires}        spec_{name}({args_view}).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_{name}({args_view}).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_{name}({args_view}).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_{name}({args_view}).spec_serialize(v@)),
+{{
+    let combinator = {name}( {args} );
+    serialize_infallible(&combinator, v, data, pos)
+}}
+
 pub fn {name}_len<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, {exec_params}) -> (serialize_len: usize)
 {len_requires}
     ensures
@@ -4160,6 +4199,22 @@ pub fn serialize_{name}<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'
     combinator.serialize(v, data, pos)
 }}
 
+pub fn serialize_{name}_infallible<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_{name}().wf(v@),
+        spec_{name}().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_{name}().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_{name}().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_{name}().spec_serialize(v@)),
+{{
+    let combinator = {name}();
+    serialize_infallible(&combinator, v, data, pos)
+}}
+
 pub fn {name}_len<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_{name}().wf(v@),
diff --git a/vest-dsl/test/src/anonymous_nested.rs b/vest-dsl/test/src/anonymous_nested.rs
index ea3dfa59..c1816186 100644
--- a/vest-dsl/test/src/anonymous_nested.rs
+++ b/vest-dsl/test/src/anonymous_nested.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -190,6 +196,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXAPayloadComb
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXAPayloadCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureParamAndLocalXAPayloadCombinatorAlias = Mapped<CaptureParamAndLocalXAPayloadCombinator1, CaptureParamAndLocalXAPayloadMapper>;
 
 
@@ -248,6 +258,23 @@ pub fn serialize_capture_param_and_local_x_a_payload<'a>(v: <CaptureParamAndLoca
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_capture_param_and_local_x_a_payload_infallible<'a>(v: <CaptureParamAndLocalXAPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice2: COrD, len: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_param_and_local_x_a_payload(choice2@, len@).wf(v@),
+        spec_c_or_d().wf(choice2@),
+        spec_capture_param_and_local_x_a_payload(choice2@, len@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_param_and_local_x_a_payload(choice2@, len@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_param_and_local_x_a_payload(choice2@, len@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_param_and_local_x_a_payload(choice2@, len@).spec_serialize(v@)),
+{
+    let combinator = capture_param_and_local_x_a_payload( choice2, len );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_param_and_local_x_a_payload_len<'a>(v: <CaptureParamAndLocalXAPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, choice2: COrD, len: u8) -> (serialize_len: usize)
     requires
         spec_capture_param_and_local_x_a_payload(choice2@, len@).wf(v@),
@@ -389,6 +416,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXACombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXACombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureParamAndLocalXACombinatorAlias = Mapped<Pair<U8, CaptureParamAndLocalXAPayloadCombinator, CaptureParamAndLocalXACont0>, CaptureParamAndLocalXAMapper>;
 
 
@@ -470,6 +501,23 @@ pub fn serialize_capture_param_and_local_x_a<'a>(v: <CaptureParamAndLocalXACombi
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_capture_param_and_local_x_a_infallible<'a>(v: <CaptureParamAndLocalXACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice2: COrD) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_param_and_local_x_a(choice2@).wf(v@),
+        spec_c_or_d().wf(choice2@),
+        spec_capture_param_and_local_x_a(choice2@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_param_and_local_x_a(choice2@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_param_and_local_x_a(choice2@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_param_and_local_x_a(choice2@).spec_serialize(v@)),
+{
+    let combinator = capture_param_and_local_x_a( choice2 );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_param_and_local_x_a_len<'a>(v: <CaptureParamAndLocalXACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, choice2: COrD) -> (serialize_len: usize)
     requires
         spec_capture_param_and_local_x_a(choice2@).wf(v@),
@@ -676,6 +724,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXBYCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXBYCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureParamAndLocalXBYCombinatorAlias = Mapped<CaptureParamAndLocalXBYCombinator1, CaptureParamAndLocalXBYMapper>;
 
 
@@ -730,6 +782,22 @@ pub fn serialize_capture_param_and_local_x_b_y<'a>(v: <CaptureParamAndLocalXBYCo
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_capture_param_and_local_x_b_y_infallible<'a>(v: <CaptureParamAndLocalXBYCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, tag: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_param_and_local_x_b_y(tag@).wf(v@),
+        spec_capture_param_and_local_x_b_y(tag@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_param_and_local_x_b_y(tag@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_param_and_local_x_b_y(tag@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_param_and_local_x_b_y(tag@).spec_serialize(v@)),
+{
+    let combinator = capture_param_and_local_x_b_y( tag );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_param_and_local_x_b_y_len<'a>(v: <CaptureParamAndLocalXBYCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, tag: u8) -> (serialize_len: usize)
     requires
         spec_capture_param_and_local_x_b_y(tag@).wf(v@),
@@ -870,6 +938,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXBCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXBCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureParamAndLocalXBCombinatorAlias = Mapped<Pair<U8, CaptureParamAndLocalXBYCombinator, CaptureParamAndLocalXBCont0>, CaptureParamAndLocalXBMapper>;
 
 
@@ -945,6 +1017,22 @@ pub fn serialize_capture_param_and_local_x_b<'a>(v: <CaptureParamAndLocalXBCombi
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_capture_param_and_local_x_b_infallible<'a>(v: <CaptureParamAndLocalXBCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_param_and_local_x_b().wf(v@),
+        spec_capture_param_and_local_x_b().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_param_and_local_x_b().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_param_and_local_x_b().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_param_and_local_x_b().spec_serialize(v@)),
+{
+    let combinator = capture_param_and_local_x_b();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_param_and_local_x_b_len<'a>(v: <CaptureParamAndLocalXBCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_capture_param_and_local_x_b().wf(v@),
@@ -1144,6 +1232,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureParamAndLocalXCombinatorAlias = Mapped<CaptureParamAndLocalXCombinator1, CaptureParamAndLocalXMapper>;
 
 
@@ -1205,6 +1297,24 @@ pub fn serialize_capture_param_and_local_x<'a>(v: <CaptureParamAndLocalXCombinat
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_capture_param_and_local_x_infallible<'a>(v: <CaptureParamAndLocalXCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice1: AOrB, choice2: COrD) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_param_and_local_x(choice1@, choice2@).wf(v@),
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+        spec_capture_param_and_local_x(choice1@, choice2@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_param_and_local_x(choice1@, choice2@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_param_and_local_x(choice1@, choice2@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_param_and_local_x(choice1@, choice2@).spec_serialize(v@)),
+{
+    let combinator = capture_param_and_local_x( choice1, choice2 );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_param_and_local_x_len<'a>(v: <CaptureParamAndLocalXCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, choice1: AOrB, choice2: COrD) -> (serialize_len: usize)
     requires
         spec_capture_param_and_local_x(choice1@, choice2@).wf(v@),
@@ -1375,6 +1485,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceXACombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceXACombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NestedInnerChoiceXACombinatorAlias = Mapped<NestedInnerChoiceXACombinator1, NestedInnerChoiceXAMapper>;
 
 
@@ -1433,6 +1547,23 @@ pub fn serialize_nested_inner_choice_x_a<'a>(v: <NestedInnerChoiceXACombinator a
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_nested_inner_choice_x_a_infallible<'a>(v: <NestedInnerChoiceXACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice2: COrD) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_nested_inner_choice_x_a(choice2@).wf(v@),
+        spec_c_or_d().wf(choice2@),
+        spec_nested_inner_choice_x_a(choice2@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_nested_inner_choice_x_a(choice2@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_nested_inner_choice_x_a(choice2@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_nested_inner_choice_x_a(choice2@).spec_serialize(v@)),
+{
+    let combinator = nested_inner_choice_x_a( choice2 );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn nested_inner_choice_x_a_len<'a>(v: <NestedInnerChoiceXACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, choice2: COrD) -> (serialize_len: usize)
     requires
         spec_nested_inner_choice_x_a(choice2@).wf(v@),
@@ -1574,6 +1705,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadAnonIn
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureOuterAndLocalPayloadAnonInnerBodyChoice1CombinatorAlias = Mapped<Pair<U8, bytes::Variable, CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0>, CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Mapper>;
 
 
@@ -1649,6 +1784,22 @@ pub fn serialize_capture_outer_and_local_payload_anon_inner_body_choice1<'a>(v:
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_capture_outer_and_local_payload_anon_inner_body_choice1_infallible<'a>(v: <CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_outer_and_local_payload_anon_inner_body_choice1().wf(v@),
+        spec_capture_outer_and_local_payload_anon_inner_body_choice1().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_outer_and_local_payload_anon_inner_body_choice1().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_outer_and_local_payload_anon_inner_body_choice1().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_outer_and_local_payload_anon_inner_body_choice1().spec_serialize(v@)),
+{
+    let combinator = capture_outer_and_local_payload_anon_inner_body_choice1();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_outer_and_local_payload_anon_inner_body_choice1_len<'a>(v: <CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_capture_outer_and_local_payload_anon_inner_body_choice1().wf(v@),
@@ -1848,6 +1999,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadAnonIn
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadAnonInnerBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias = Mapped<CaptureOuterAndLocalPayloadAnonInnerBodyCombinator1, CaptureOuterAndLocalPayloadAnonInnerBodyMapper>;
 
 
@@ -1906,6 +2061,23 @@ pub fn serialize_capture_outer_and_local_payload_anon_inner_body<'a>(v: <Capture
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_capture_outer_and_local_payload_anon_inner_body_infallible<'a>(v: <CaptureOuterAndLocalPayloadAnonInnerBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, frame_len: u8, tag: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).wf(v@),
+        ((frame_len) >= 1),
+        spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).spec_serialize(v@)),
+{
+    let combinator = capture_outer_and_local_payload_anon_inner_body( frame_len, tag );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_outer_and_local_payload_anon_inner_body_len<'a>(v: <CaptureOuterAndLocalPayloadAnonInnerBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, frame_len: u8, tag: u8) -> (serialize_len: usize)
     requires
         spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).wf(v@),
@@ -2047,6 +2219,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadCombin
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureOuterAndLocalPayloadCombinatorAlias = AndThen<bytes::Variable, Mapped<Pair<U8, CaptureOuterAndLocalPayloadAnonInnerBodyCombinator, CaptureOuterAndLocalPayloadCont0>, CaptureOuterAndLocalPayloadMapper>>;
 
 
@@ -2128,6 +2304,23 @@ pub fn serialize_capture_outer_and_local_payload<'a>(v: <CaptureOuterAndLocalPay
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_capture_outer_and_local_payload_infallible<'a>(v: <CaptureOuterAndLocalPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, frame_len: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_outer_and_local_payload(frame_len@).wf(v@),
+        ((frame_len) >= 1),
+        spec_capture_outer_and_local_payload(frame_len@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_outer_and_local_payload(frame_len@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_outer_and_local_payload(frame_len@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_outer_and_local_payload(frame_len@).spec_serialize(v@)),
+{
+    let combinator = capture_outer_and_local_payload( frame_len );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_outer_and_local_payload_len<'a>(v: <CaptureOuterAndLocalPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, frame_len: u8) -> (serialize_len: usize)
     requires
         spec_capture_outer_and_local_payload(frame_len@).wf(v@),
@@ -2326,6 +2519,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureOuterAndLocalCombinatorAlias = Mapped<Pair<Refined<U8, Predicate2172399096230090262>, CaptureOuterAndLocalPayloadCombinator, CaptureOuterAndLocalCont0>, CaptureOuterAndLocalMapper>;
 
 
@@ -2401,6 +2598,22 @@ pub fn serialize_capture_outer_and_local<'a>(v: <CaptureOuterAndLocalCombinator
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_capture_outer_and_local_infallible<'a>(v: <CaptureOuterAndLocalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_outer_and_local().wf(v@),
+        spec_capture_outer_and_local().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_outer_and_local().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_outer_and_local().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_outer_and_local().spec_serialize(v@)),
+{
+    let combinator = capture_outer_and_local();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_outer_and_local_len<'a>(v: <CaptureOuterAndLocalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_capture_outer_and_local().wf(v@),
@@ -2579,6 +2792,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerStructAnonInnerCombina
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NestedInnerStructAnonInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NestedInnerStructAnonInnerCombinatorAlias = AndThen<bytes::Variable, Mapped<NestedInnerStructAnonInnerCombinator1, NestedInnerStructAnonInnerMapper>>;
 
 
@@ -2641,6 +2858,22 @@ pub fn serialize_nested_inner_struct_anon_inner<'a>(v: <NestedInnerStructAnonInn
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_nested_inner_struct_anon_inner_infallible<'a>(v: <NestedInnerStructAnonInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, len: u32) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_nested_inner_struct_anon_inner(len@).wf(v@),
+        spec_nested_inner_struct_anon_inner(len@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_nested_inner_struct_anon_inner(len@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_nested_inner_struct_anon_inner(len@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_nested_inner_struct_anon_inner(len@).spec_serialize(v@)),
+{
+    let combinator = nested_inner_struct_anon_inner( len );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn nested_inner_struct_anon_inner_len<'a>(v: <NestedInnerStructAnonInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, len: u32) -> (serialize_len: usize)
     requires
         spec_nested_inner_struct_anon_inner(len@).wf(v@),
@@ -2781,6 +3014,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperVa
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperValueChoice0Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureLocalInAnonStructWrapperValueChoice0CombinatorAlias = Mapped<Pair<U8, bytes::Variable, CaptureLocalInAnonStructWrapperValueChoice0Cont0>, CaptureLocalInAnonStructWrapperValueChoice0Mapper>;
 
 
@@ -2856,6 +3093,22 @@ pub fn serialize_capture_local_in_anon_struct_wrapper_value_choice0<'a>(v: <Capt
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_capture_local_in_anon_struct_wrapper_value_choice0_infallible<'a>(v: <CaptureLocalInAnonStructWrapperValueChoice0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_local_in_anon_struct_wrapper_value_choice0().wf(v@),
+        spec_capture_local_in_anon_struct_wrapper_value_choice0().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_local_in_anon_struct_wrapper_value_choice0().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_local_in_anon_struct_wrapper_value_choice0().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_local_in_anon_struct_wrapper_value_choice0().spec_serialize(v@)),
+{
+    let combinator = capture_local_in_anon_struct_wrapper_value_choice0();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_local_in_anon_struct_wrapper_value_choice0_len<'a>(v: <CaptureLocalInAnonStructWrapperValueChoice0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_capture_local_in_anon_struct_wrapper_value_choice0().wf(v@),
@@ -3055,6 +3308,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperVa
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperValueCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureLocalInAnonStructWrapperValueCombinatorAlias = Mapped<CaptureLocalInAnonStructWrapperValueCombinator1, CaptureLocalInAnonStructWrapperValueMapper>;
 
 
@@ -3109,6 +3366,22 @@ pub fn serialize_capture_local_in_anon_struct_wrapper_value<'a>(v: <CaptureLocal
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_capture_local_in_anon_struct_wrapper_value_infallible<'a>(v: <CaptureLocalInAnonStructWrapperValueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, tag: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_local_in_anon_struct_wrapper_value(tag@).wf(v@),
+        spec_capture_local_in_anon_struct_wrapper_value(tag@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_local_in_anon_struct_wrapper_value(tag@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_local_in_anon_struct_wrapper_value(tag@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_local_in_anon_struct_wrapper_value(tag@).spec_serialize(v@)),
+{
+    let combinator = capture_local_in_anon_struct_wrapper_value( tag );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_local_in_anon_struct_wrapper_value_len<'a>(v: <CaptureLocalInAnonStructWrapperValueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, tag: u8) -> (serialize_len: usize)
     requires
         spec_capture_local_in_anon_struct_wrapper_value(tag@).wf(v@),
@@ -3277,6 +3550,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceXCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceXCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NestedInnerChoiceXCombinatorAlias = Mapped<NestedInnerChoiceXCombinator1, NestedInnerChoiceXMapper>;
 
 
@@ -3338,6 +3615,24 @@ pub fn serialize_nested_inner_choice_x<'a>(v: <NestedInnerChoiceXCombinator as C
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_nested_inner_choice_x_infallible<'a>(v: <NestedInnerChoiceXCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice1: AOrB, choice2: COrD) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_nested_inner_choice_x(choice1@, choice2@).wf(v@),
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+        spec_nested_inner_choice_x(choice1@, choice2@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_nested_inner_choice_x(choice1@, choice2@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_nested_inner_choice_x(choice1@, choice2@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_nested_inner_choice_x(choice1@, choice2@).spec_serialize(v@)),
+{
+    let combinator = nested_inner_choice_x( choice1, choice2 );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn nested_inner_choice_x_len<'a>(v: <NestedInnerChoiceXCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, choice1: AOrB, choice2: COrD) -> (serialize_len: usize)
     requires
         spec_nested_inner_choice_x(choice1@, choice2@).wf(v@),
@@ -3477,6 +3772,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NestedInnerChoiceCombinatorAlias = Mapped<NestedInnerChoiceXCombinator, NestedInnerChoiceMapper>;
 
 
@@ -3546,6 +3845,24 @@ pub fn serialize_nested_inner_choice<'a>(v: <NestedInnerChoiceCombinator as Comb
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_nested_inner_choice_infallible<'a>(v: <NestedInnerChoiceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice1: AOrB, choice2: COrD) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_nested_inner_choice(choice1@, choice2@).wf(v@),
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+        spec_nested_inner_choice(choice1@, choice2@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_nested_inner_choice(choice1@, choice2@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_nested_inner_choice(choice1@, choice2@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_nested_inner_choice(choice1@, choice2@).spec_serialize(v@)),
+{
+    let combinator = nested_inner_choice( choice1, choice2 );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn nested_inner_choice_len<'a>(v: <NestedInnerChoiceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, choice1: AOrB, choice2: COrD) -> (serialize_len: usize)
     requires
         spec_nested_inner_choice(choice1@, choice2@).wf(v@),
@@ -3685,6 +4002,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureParamAndLocalCombinatorAlias = Mapped<CaptureParamAndLocalXCombinator, CaptureParamAndLocalMapper>;
 
 
@@ -3754,6 +4075,24 @@ pub fn serialize_capture_param_and_local<'a>(v: <CaptureParamAndLocalCombinator
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_capture_param_and_local_infallible<'a>(v: <CaptureParamAndLocalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice1: AOrB, choice2: COrD) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_param_and_local(choice1@, choice2@).wf(v@),
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+        spec_capture_param_and_local(choice1@, choice2@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_param_and_local(choice1@, choice2@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_param_and_local(choice1@, choice2@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_param_and_local(choice1@, choice2@).spec_serialize(v@)),
+{
+    let combinator = capture_param_and_local( choice1, choice2 );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_param_and_local_len<'a>(v: <CaptureParamAndLocalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, choice1: AOrB, choice2: COrD) -> (serialize_len: usize)
     requires
         spec_capture_param_and_local(choice1@, choice2@).wf(v@),
@@ -3896,6 +4235,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerStructCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NestedInnerStructCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NestedInnerStructCombinatorAlias = Mapped<Pair<U32Le, NestedInnerStructAnonInnerCombinator, NestedInnerStructCont0>, NestedInnerStructMapper>;
 
 
@@ -3971,6 +4314,22 @@ pub fn serialize_nested_inner_struct<'a>(v: <NestedInnerStructCombinator as Comb
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_nested_inner_struct_infallible<'a>(v: <NestedInnerStructCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_nested_inner_struct().wf(v@),
+        spec_nested_inner_struct().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_nested_inner_struct().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_nested_inner_struct().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_nested_inner_struct().spec_serialize(v@)),
+{
+    let combinator = nested_inner_struct();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn nested_inner_struct_len<'a>(v: <NestedInnerStructCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_nested_inner_struct().wf(v@),
@@ -4174,6 +4533,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for COrDCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for COrDCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type COrDCombinatorAlias = TryMap<U8, COrDMapper>;
 
 
@@ -4226,6 +4589,22 @@ pub fn serialize_c_or_d<'a>(v: <COrDCombinator as Combinator<'a, &'a [u8], Vec<u
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_c_or_d_infallible<'a>(v: <COrDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_c_or_d().wf(v@),
+        spec_c_or_d().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_c_or_d().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_c_or_d().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_c_or_d().spec_serialize(v@)),
+{
+    let combinator = c_or_d();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn c_or_d_len<'a>(v: <COrDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_c_or_d().wf(v@),
@@ -4366,6 +4745,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperCo
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureLocalInAnonStructWrapperCombinatorAlias = Mapped<Pair<U8, CaptureLocalInAnonStructWrapperValueCombinator, CaptureLocalInAnonStructWrapperCont0>, CaptureLocalInAnonStructWrapperMapper>;
 
 
@@ -4441,6 +4824,22 @@ pub fn serialize_capture_local_in_anon_struct_wrapper<'a>(v: <CaptureLocalInAnon
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_capture_local_in_anon_struct_wrapper_infallible<'a>(v: <CaptureLocalInAnonStructWrapperCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_local_in_anon_struct_wrapper().wf(v@),
+        spec_capture_local_in_anon_struct_wrapper().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_local_in_anon_struct_wrapper().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_local_in_anon_struct_wrapper().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_local_in_anon_struct_wrapper().spec_serialize(v@)),
+{
+    let combinator = capture_local_in_anon_struct_wrapper();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_local_in_anon_struct_wrapper_len<'a>(v: <CaptureLocalInAnonStructWrapperCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_capture_local_in_anon_struct_wrapper().wf(v@),
@@ -4609,6 +5008,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructCombinato
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CaptureLocalInAnonStructCombinatorAlias = Mapped<CaptureLocalInAnonStructWrapperCombinator, CaptureLocalInAnonStructMapper>;
 
 
@@ -4669,6 +5072,22 @@ pub fn serialize_capture_local_in_anon_struct<'a>(v: <CaptureLocalInAnonStructCo
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_capture_local_in_anon_struct_infallible<'a>(v: <CaptureLocalInAnonStructCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_local_in_anon_struct().wf(v@),
+        spec_capture_local_in_anon_struct().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_capture_local_in_anon_struct().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_capture_local_in_anon_struct().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_capture_local_in_anon_struct().spec_serialize(v@)),
+{
+    let combinator = capture_local_in_anon_struct();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn capture_local_in_anon_struct_len<'a>(v: <CaptureLocalInAnonStructCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_capture_local_in_anon_struct().wf(v@),
@@ -4841,6 +5260,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AOrBCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AOrBCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type AOrBCombinatorAlias = TryMap<U8, AOrBMapper>;
 
 
@@ -4893,6 +5316,22 @@ pub fn serialize_a_or_b<'a>(v: <AOrBCombinator as Combinator<'a, &'a [u8], Vec<u
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_a_or_b_infallible<'a>(v: <AOrBCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_or_b().wf(v@),
+        spec_a_or_b().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a_or_b().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a_or_b().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a_or_b().spec_serialize(v@)),
+{
+    let combinator = a_or_b();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_or_b_len<'a>(v: <AOrBCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_a_or_b().wf(v@),
diff --git a/vest-dsl/test/src/codegen.rs b/vest-dsl/test/src/codegen.rs
index e9785fcc..4bd0c63f 100644
--- a/vest-dsl/test/src/codegen.rs
+++ b/vest-dsl/test/src/codegen.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -201,6 +207,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg1Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg1Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg1CombinatorAlias = Mapped<Msg1Combinator2, Msg1Mapper>;
 
 
@@ -261,6 +271,22 @@ pub fn serialize_msg1<'a>(v: <Msg1Combinator as Combinator<'a, &'a [u8], Vec<u8>
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg1_infallible<'a>(v: <Msg1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg1().wf(v@),
+        spec_msg1().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg1().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg1().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg1().spec_serialize(v@)),
+{
+    let combinator = msg1();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg1_len<'a>(v: <Msg1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg1().wf(v@),
@@ -420,6 +446,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg2Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg2Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg2CombinatorAlias = Mapped<Msg2Combinator2, Msg2Mapper>;
 
 
@@ -480,6 +510,22 @@ pub fn serialize_msg2<'a>(v: <Msg2Combinator as Combinator<'a, &'a [u8], Vec<u8>
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg2_infallible<'a>(v: <Msg2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg2().wf(v@),
+        spec_msg2().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg2().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg2().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg2().spec_serialize(v@)),
+{
+    let combinator = msg2();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg2_len<'a>(v: <Msg2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg2().wf(v@),
@@ -659,6 +705,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ATypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ATypeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ATypeCombinatorAlias = TryMap<U8, ATypeMapper>;
 
 
@@ -711,6 +761,22 @@ pub fn serialize_a_type<'a>(v: <ATypeCombinator as Combinator<'a, &'a [u8], Vec<
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_a_type_infallible<'a>(v: <ATypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_type().wf(v@),
+        spec_a_type().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a_type().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a_type().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a_type().spec_serialize(v@)),
+{
+    let combinator = a_type();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_type_len<'a>(v: <ATypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_a_type().wf(v@),
@@ -777,6 +843,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg3Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg3Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg3CombinatorAlias = bytes::Fixed<6>;
 
 
@@ -829,6 +899,22 @@ pub fn serialize_msg3<'a>(v: <Msg3Combinator as Combinator<'a, &'a [u8], Vec<u8>
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg3_infallible<'a>(v: <Msg3Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg3().wf(v@),
+        spec_msg3().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg3().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg3().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg3().spec_serialize(v@)),
+{
+    let combinator = msg3();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg3_len<'a>(v: <Msg3Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg3().wf(v@),
@@ -1013,6 +1099,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg4VCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg4VCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg4VCombinatorAlias = Mapped<Msg4VCombinator2, Msg4VMapper>;
 
 
@@ -1071,6 +1161,23 @@ pub fn serialize_msg4_v<'a>(v: <Msg4VCombinator as Combinator<'a, &'a [u8], Vec<
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_msg4_v_infallible<'a>(v: <Msg4VCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, t: AType) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg4_v(t@).wf(v@),
+        spec_a_type().wf(t@),
+        spec_msg4_v(t@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg4_v(t@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg4_v(t@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg4_v(t@).spec_serialize(v@)),
+{
+    let combinator = msg4_v( t );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg4_v_len<'a>(v: <Msg4VCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, t: AType) -> (serialize_len: usize)
     requires
         spec_msg4_v(t@).wf(v@),
@@ -1215,6 +1322,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg4Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg4CombinatorAlias = Mapped<Pair<ATypeCombinator, (Msg4VCombinator, bytes::Tail), Msg4Cont0>, Msg4Mapper>;
 
 
@@ -1290,6 +1401,22 @@ pub fn serialize_msg4<'a>(v: <Msg4Combinator as Combinator<'a, &'a [u8], Vec<u8>
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg4_infallible<'a>(v: <Msg4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg4().wf(v@),
+        spec_msg4().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg4().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg4().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg4().spec_serialize(v@)),
+{
+    let combinator = msg4();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg4_len<'a>(v: <Msg4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg4().wf(v@),
diff --git a/vest-dsl/test/src/elab.rs b/vest-dsl/test/src/elab.rs
index 6acfebe0..cdf702c5 100644
--- a/vest-dsl/test/src/elab.rs
+++ b/vest-dsl/test/src/elab.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -88,6 +94,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Content0Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Content0Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Content0CombinatorAlias = bytes::Variable;
 
 
@@ -142,6 +152,22 @@ pub fn serialize_content_0<'a>(v: <Content0Combinator as Combinator<'a, &'a [u8]
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_content_0_infallible<'a>(v: <Content0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num: u24) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_content_0(num@).wf(v@),
+        spec_content_0(num@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_content_0(num@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_content_0(num@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_content_0(num@).spec_serialize(v@)),
+{
+    let combinator = content_0( num );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn content_0_len<'a>(v: <Content0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, num: u24) -> (serialize_len: usize)
     requires
         spec_content_0(num@).wf(v@),
@@ -214,6 +240,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ContentTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ContentTypeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ContentTypeCombinatorAlias = U8;
 
 
@@ -266,6 +296,22 @@ pub fn serialize_content_type<'a>(v: <ContentTypeCombinator as Combinator<'a, &'
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_content_type_infallible<'a>(v: <ContentTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_content_type().wf(v@),
+        spec_content_type().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_content_type().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_content_type().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_content_type().spec_serialize(v@)),
+{
+    let combinator = content_type();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn content_type_len<'a>(v: <ContentTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_content_type().wf(v@),
@@ -466,6 +512,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgCF4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgCF4Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MsgCF4CombinatorAlias = AndThen<bytes::Variable, Mapped<MsgCF4Combinator3, MsgCF4Mapper>>;
 
 
@@ -524,6 +574,23 @@ pub fn serialize_msg_c_f4<'a>(v: <MsgCF4Combinator as Combinator<'a, &'a [u8], V
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_msg_c_f4_infallible<'a>(v: <MsgCF4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, f2: u8, f3: u24) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg_c_f4(f2@, f3@).wf(v@),
+        spec_content_type().wf(f2@),
+        spec_msg_c_f4(f2@, f3@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg_c_f4(f2@, f3@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg_c_f4(f2@, f3@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg_c_f4(f2@, f3@).spec_serialize(v@)),
+{
+    let combinator = msg_c_f4( f2, f3 );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg_c_f4_len<'a>(v: <MsgCF4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, f2: u8, f3: u24) -> (serialize_len: usize)
     requires
         spec_msg_c_f4(f2@, f3@).wf(v@),
@@ -692,6 +759,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgDCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgDCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MsgDCombinatorAlias = Mapped<MsgDCombinator2, MsgDMapper>;
 
 
@@ -752,6 +823,22 @@ pub fn serialize_msg_d<'a>(v: <MsgDCombinator as Combinator<'a, &'a [u8], Vec<u8
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg_d_infallible<'a>(v: <MsgDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg_d().wf(v@),
+        spec_msg_d().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg_d().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg_d().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg_d().spec_serialize(v@)),
+{
+    let combinator = msg_d();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg_d_len<'a>(v: <MsgDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg_d().wf(v@),
@@ -889,6 +976,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgBCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgBCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MsgBCombinatorAlias = Mapped<MsgDCombinator, MsgBMapper>;
 
 
@@ -949,6 +1040,22 @@ pub fn serialize_msg_b<'a>(v: <MsgBCombinator as Combinator<'a, &'a [u8], Vec<u8
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg_b_infallible<'a>(v: <MsgBCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg_b().wf(v@),
+        spec_msg_b().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg_b().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg_b().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg_b().spec_serialize(v@)),
+{
+    let combinator = msg_b();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg_b_len<'a>(v: <MsgBCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg_b().wf(v@),
@@ -1096,6 +1203,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgACombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgACombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MsgACombinatorAlias = Mapped<MsgACombinator1, MsgAMapper>;
 
 
@@ -1156,6 +1267,22 @@ pub fn serialize_msg_a<'a>(v: <MsgACombinator as Combinator<'a, &'a [u8], Vec<u8
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg_a_infallible<'a>(v: <MsgACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg_a().wf(v@),
+        spec_msg_a().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg_a().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg_a().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg_a().spec_serialize(v@)),
+{
+    let combinator = msg_a();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg_a_len<'a>(v: <MsgACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg_a().wf(v@),
@@ -1299,6 +1426,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgCCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgCCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MsgCCombinatorAlias = Mapped<Pair<Pair<ContentTypeCombinator, U24Be, MsgCCont1>, MsgCF4Combinator, MsgCCont0>, MsgCMapper>;
 
 
@@ -1389,6 +1520,22 @@ pub fn serialize_msg_c<'a>(v: <MsgCCombinator as Combinator<'a, &'a [u8], Vec<u8
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg_c_infallible<'a>(v: <MsgCCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg_c().wf(v@),
+        spec_msg_c().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg_c().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg_c().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg_c().spec_serialize(v@)),
+{
+    let combinator = msg_c();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg_c_len<'a>(v: <MsgCCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg_c().wf(v@),
@@ -1528,6 +1675,22 @@ pub fn serialize_F5<'a>(v: <F5Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_F5_infallible<'a>(v: <F5Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_F5().wf(v@),
+        spec_F5().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_F5().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_F5().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_F5().spec_serialize(v@)),
+{
+    let combinator = F5();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn F5_len<'a>(v: <F5Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_F5().wf(v@),
diff --git a/vest-dsl/test/src/enum_constraints.rs b/vest-dsl/test/src/enum_constraints.rs
index cf06e59f..d283f8bc 100644
--- a/vest-dsl/test/src/enum_constraints.rs
+++ b/vest-dsl/test/src/enum_constraints.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -201,6 +207,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MyTypedEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MyTypedEnumCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MyTypedEnumCombinatorAlias = TryMap<U16Le, MyTypedEnumMapper>;
 
 
@@ -253,6 +263,22 @@ pub fn serialize_my_typed_enum<'a>(v: <MyTypedEnumCombinator as Combinator<'a, &
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_my_typed_enum_infallible<'a>(v: <MyTypedEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_my_typed_enum().wf(v@),
+        spec_my_typed_enum().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_my_typed_enum().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_my_typed_enum().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_my_typed_enum().spec_serialize(v@)),
+{
+    let combinator = my_typed_enum();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn my_typed_enum_len<'a>(v: <MyTypedEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_my_typed_enum().wf(v@),
@@ -432,6 +458,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MyEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MyEnumCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MyEnumCombinatorAlias = TryMap<U8, MyEnumMapper>;
 
 
@@ -484,6 +514,22 @@ pub fn serialize_my_enum<'a>(v: <MyEnumCombinator as Combinator<'a, &'a [u8], Ve
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_my_enum_infallible<'a>(v: <MyEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_my_enum().wf(v@),
+        spec_my_enum().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_my_enum().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_my_enum().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_my_enum().spec_serialize(v@)),
+{
+    let combinator = my_enum();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn my_enum_len<'a>(v: <MyEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_my_enum().wf(v@),
@@ -710,6 +756,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TypedEnumConstraintsCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TypedEnumConstraintsCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TypedEnumConstraintsCombinatorAlias = Mapped<TypedEnumConstraintsCombinator3, TypedEnumConstraintsMapper>;
 
 
@@ -770,6 +820,22 @@ pub fn serialize_typed_enum_constraints<'a>(v: <TypedEnumConstraintsCombinator a
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_typed_enum_constraints_infallible<'a>(v: <TypedEnumConstraintsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_typed_enum_constraints().wf(v@),
+        spec_typed_enum_constraints().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_typed_enum_constraints().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_typed_enum_constraints().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_typed_enum_constraints().spec_serialize(v@)),
+{
+    let combinator = typed_enum_constraints();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn typed_enum_constraints_len<'a>(v: <TypedEnumConstraintsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_typed_enum_constraints().wf(v@),
@@ -996,6 +1062,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EnumConstraintsCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EnumConstraintsCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type EnumConstraintsCombinatorAlias = Mapped<EnumConstraintsCombinator3, EnumConstraintsMapper>;
 
 
@@ -1056,6 +1126,22 @@ pub fn serialize_enum_constraints<'a>(v: <EnumConstraintsCombinator as Combinato
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_enum_constraints_infallible<'a>(v: <EnumConstraintsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_enum_constraints().wf(v@),
+        spec_enum_constraints().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_enum_constraints().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_enum_constraints().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_enum_constraints().spec_serialize(v@)),
+{
+    let combinator = enum_constraints();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn enum_constraints_len<'a>(v: <EnumConstraintsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_enum_constraints().wf(v@),
diff --git a/vest-dsl/test/src/enums.rs b/vest-dsl/test/src/enums.rs
index 9c730cbc..340aaed6 100644
--- a/vest-dsl/test/src/enums.rs
+++ b/vest-dsl/test/src/enums.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -206,6 +212,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ATypedChooseCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ATypedChooseCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ATypedChooseCombinatorAlias = Mapped<ATypedChooseCombinator2, ATypedChooseMapper>;
 
 
@@ -264,6 +274,23 @@ pub fn serialize_a_typed_choose<'a>(v: <ATypedChooseCombinator as Combinator<'a,
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_a_typed_choose_infallible<'a>(v: <ATypedChooseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, e: ATypedClosedEnum) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_typed_choose(e@).wf(v@),
+        spec_a_typed_closed_enum().wf(e@),
+        spec_a_typed_choose(e@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a_typed_choose(e@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a_typed_choose(e@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a_typed_choose(e@).spec_serialize(v@)),
+{
+    let combinator = a_typed_choose( e );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_typed_choose_len<'a>(v: <ATypedChooseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, e: ATypedClosedEnum) -> (serialize_len: usize)
     requires
         spec_a_typed_choose(e@).wf(v@),
@@ -337,6 +364,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ATypedOpenEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ATypedOpenEnumCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ATypedOpenEnumCombinatorAlias = U32Le;
 
 
@@ -389,6 +420,22 @@ pub fn serialize_a_typed_open_enum<'a>(v: <ATypedOpenEnumCombinator as Combinato
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_a_typed_open_enum_infallible<'a>(v: <ATypedOpenEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_typed_open_enum().wf(v@),
+        spec_a_typed_open_enum().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a_typed_open_enum().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a_typed_open_enum().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a_typed_open_enum().spec_serialize(v@)),
+{
+    let combinator = a_typed_open_enum();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_typed_open_enum_len<'a>(v: <ATypedOpenEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_a_typed_open_enum().wf(v@),
@@ -633,6 +680,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ANonDependentChooseCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ANonDependentChooseCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ANonDependentChooseCombinatorAlias = Mapped<ANonDependentChooseCombinator2, ANonDependentChooseMapper>;
 
 
@@ -685,6 +736,22 @@ pub fn serialize_a_non_dependent_choose<'a>(v: <ANonDependentChooseCombinator as
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_a_non_dependent_choose_infallible<'a>(v: <ANonDependentChooseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_non_dependent_choose().wf(v@),
+        spec_a_non_dependent_choose().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a_non_dependent_choose().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a_non_dependent_choose().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a_non_dependent_choose().spec_serialize(v@)),
+{
+    let combinator = a_non_dependent_choose();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_non_dependent_choose_len<'a>(v: <ANonDependentChooseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_a_non_dependent_choose().wf(v@),
@@ -869,6 +936,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ARegularChooseCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ARegularChooseCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ARegularChooseCombinatorAlias = Mapped<ARegularChooseCombinator2, ARegularChooseMapper>;
 
 
@@ -927,6 +998,23 @@ pub fn serialize_a_regular_choose<'a>(v: <ARegularChooseCombinator as Combinator
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_a_regular_choose_infallible<'a>(v: <ARegularChooseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, e: AClosedEnum) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_regular_choose(e@).wf(v@),
+        spec_a_closed_enum().wf(e@),
+        spec_a_regular_choose(e@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a_regular_choose(e@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a_regular_choose(e@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a_regular_choose(e@).spec_serialize(v@)),
+{
+    let combinator = a_regular_choose( e );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_regular_choose_len<'a>(v: <ARegularChooseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, e: AClosedEnum) -> (serialize_len: usize)
     requires
         spec_a_regular_choose(e@).wf(v@),
@@ -1107,6 +1195,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AMixedTypedEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AMixedTypedEnumCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type AMixedTypedEnumCombinatorAlias = TryMap<U8, AMixedTypedEnumMapper>;
 
 
@@ -1159,6 +1251,22 @@ pub fn serialize_a_mixed_typed_enum<'a>(v: <AMixedTypedEnumCombinator as Combina
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_a_mixed_typed_enum_infallible<'a>(v: <AMixedTypedEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_mixed_typed_enum().wf(v@),
+        spec_a_mixed_typed_enum().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a_mixed_typed_enum().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a_mixed_typed_enum().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a_mixed_typed_enum().spec_serialize(v@)),
+{
+    let combinator = a_mixed_typed_enum();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_mixed_typed_enum_len<'a>(v: <AMixedTypedEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_a_mixed_typed_enum().wf(v@),
@@ -1338,6 +1446,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AClosedEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AClosedEnumCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type AClosedEnumCombinatorAlias = TryMap<U8, AClosedEnumMapper>;
 
 
@@ -1390,6 +1502,22 @@ pub fn serialize_a_closed_enum<'a>(v: <AClosedEnumCombinator as Combinator<'a, &
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_a_closed_enum_infallible<'a>(v: <AClosedEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_closed_enum().wf(v@),
+        spec_a_closed_enum().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a_closed_enum().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a_closed_enum().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a_closed_enum().spec_serialize(v@)),
+{
+    let combinator = a_closed_enum();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_closed_enum_len<'a>(v: <AClosedEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_a_closed_enum().wf(v@),
@@ -1569,6 +1697,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ATypedClosedEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ATypedClosedEnumCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ATypedClosedEnumCombinatorAlias = TryMap<U16Le, ATypedClosedEnumMapper>;
 
 
@@ -1621,6 +1753,22 @@ pub fn serialize_a_typed_closed_enum<'a>(v: <ATypedClosedEnumCombinator as Combi
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_a_typed_closed_enum_infallible<'a>(v: <ATypedClosedEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_typed_closed_enum().wf(v@),
+        spec_a_typed_closed_enum().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a_typed_closed_enum().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a_typed_closed_enum().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a_typed_closed_enum().spec_serialize(v@)),
+{
+    let combinator = a_typed_closed_enum();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_typed_closed_enum_len<'a>(v: <ATypedClosedEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_a_typed_closed_enum().wf(v@),
@@ -1693,6 +1841,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AnOpenEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AnOpenEnumCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type AnOpenEnumCombinatorAlias = U8;
 
 
@@ -1745,6 +1897,22 @@ pub fn serialize_an_open_enum<'a>(v: <AnOpenEnumCombinator as Combinator<'a, &'a
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_an_open_enum_infallible<'a>(v: <AnOpenEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_an_open_enum().wf(v@),
+        spec_an_open_enum().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_an_open_enum().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_an_open_enum().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_an_open_enum().spec_serialize(v@)),
+{
+    let combinator = an_open_enum();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn an_open_enum_len<'a>(v: <AnOpenEnumCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_an_open_enum().wf(v@),
@@ -1945,6 +2113,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ATypedChooseWithDefaultCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ATypedChooseWithDefaultCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ATypedChooseWithDefaultCombinatorAlias = Mapped<ATypedChooseWithDefaultCombinator3, ATypedChooseWithDefaultMapper>;
 
 
@@ -2003,6 +2175,23 @@ pub fn serialize_a_typed_choose_with_default<'a>(v: <ATypedChooseWithDefaultComb
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_a_typed_choose_with_default_infallible<'a>(v: <ATypedChooseWithDefaultCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, e: u32) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_typed_choose_with_default(e@).wf(v@),
+        spec_a_typed_open_enum().wf(e@),
+        spec_a_typed_choose_with_default(e@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a_typed_choose_with_default(e@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a_typed_choose_with_default(e@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a_typed_choose_with_default(e@).spec_serialize(v@)),
+{
+    let combinator = a_typed_choose_with_default( e );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_typed_choose_with_default_len<'a>(v: <ATypedChooseWithDefaultCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, e: u32) -> (serialize_len: usize)
     requires
         spec_a_typed_choose_with_default(e@).wf(v@),
@@ -2204,6 +2393,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AChooseWithDefaultCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AChooseWithDefaultCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type AChooseWithDefaultCombinatorAlias = Mapped<AChooseWithDefaultCombinator3, AChooseWithDefaultMapper>;
 
 
@@ -2262,6 +2455,23 @@ pub fn serialize_a_choose_with_default<'a>(v: <AChooseWithDefaultCombinator as C
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_a_choose_with_default_infallible<'a>(v: <AChooseWithDefaultCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, e: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_choose_with_default(e@).wf(v@),
+        spec_an_open_enum().wf(e@),
+        spec_a_choose_with_default(e@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a_choose_with_default(e@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a_choose_with_default(e@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a_choose_with_default(e@).spec_serialize(v@)),
+{
+    let combinator = a_choose_with_default( e );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_choose_with_default_len<'a>(v: <AChooseWithDefaultCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, e: u8) -> (serialize_len: usize)
     requires
         spec_a_choose_with_default(e@).wf(v@),
diff --git a/vest-dsl/test/src/ikev2.rs b/vest-dsl/test/src/ikev2.rs
index 2eba4416..c03f4a79 100644
--- a/vest-dsl/test/src/ikev2.rs
+++ b/vest-dsl/test/src/ikev2.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -94,6 +100,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeProtocolIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IkeProtocolIdCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type IkeProtocolIdCombinatorAlias = U8;
 
 
@@ -146,6 +156,22 @@ pub fn serialize_ike_protocol_id<'a>(v: <IkeProtocolIdCombinator as Combinator<'
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ike_protocol_id_infallible<'a>(v: <IkeProtocolIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ike_protocol_id().wf(v@),
+        spec_ike_protocol_id().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ike_protocol_id().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ike_protocol_id().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ike_protocol_id().spec_serialize(v@)),
+{
+    let combinator = ike_protocol_id();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ike_protocol_id_len<'a>(v: <IkeProtocolIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ike_protocol_id().wf(v@),
@@ -232,6 +258,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalSpiSizeByteCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalSpiSizeByteCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ProposalSpiSizeByteCombinatorAlias = Refined<U8, Predicate7607843399309189603>;
 
 
@@ -284,6 +314,22 @@ pub fn serialize_proposal_spi_size_byte<'a>(v: <ProposalSpiSizeByteCombinator as
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_proposal_spi_size_byte_infallible<'a>(v: <ProposalSpiSizeByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_proposal_spi_size_byte().wf(v@),
+        spec_proposal_spi_size_byte().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_proposal_spi_size_byte().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_proposal_spi_size_byte().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_proposal_spi_size_byte().spec_serialize(v@)),
+{
+    let combinator = proposal_spi_size_byte();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn proposal_spi_size_byte_len<'a>(v: <ProposalSpiSizeByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_proposal_spi_size_byte().wf(v@),
@@ -360,6 +406,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformTypeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TransformTypeCombinatorAlias = U8;
 
 
@@ -412,6 +462,22 @@ pub fn serialize_transform_type<'a>(v: <TransformTypeCombinator as Combinator<'a
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_transform_type_infallible<'a>(v: <TransformTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_type().wf(v@),
+        spec_transform_type().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_transform_type().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_transform_type().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_transform_type().spec_serialize(v@)),
+{
+    let combinator = transform_type();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn transform_type_len<'a>(v: <TransformTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_transform_type().wf(v@),
@@ -502,6 +568,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EncrIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EncrIdCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type EncrIdCombinatorAlias = U16Be;
 
 
@@ -554,6 +624,22 @@ pub fn serialize_encr_id<'a>(v: <EncrIdCombinator as Combinator<'a, &'a [u8], Ve
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_encr_id_infallible<'a>(v: <EncrIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_encr_id().wf(v@),
+        spec_encr_id().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_encr_id().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_encr_id().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_encr_id().spec_serialize(v@)),
+{
+    let combinator = encr_id();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn encr_id_len<'a>(v: <EncrIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_encr_id().wf(v@),
@@ -626,6 +712,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PrfIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PrfIdCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type PrfIdCombinatorAlias = U16Be;
 
 
@@ -678,6 +768,22 @@ pub fn serialize_prf_id<'a>(v: <PrfIdCombinator as Combinator<'a, &'a [u8], Vec<
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_prf_id_infallible<'a>(v: <PrfIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_prf_id().wf(v@),
+        spec_prf_id().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_prf_id().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_prf_id().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_prf_id().spec_serialize(v@)),
+{
+    let combinator = prf_id();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn prf_id_len<'a>(v: <PrfIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_prf_id().wf(v@),
@@ -756,6 +862,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IntegIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IntegIdCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type IntegIdCombinatorAlias = U16Be;
 
 
@@ -808,6 +918,22 @@ pub fn serialize_integ_id<'a>(v: <IntegIdCombinator as Combinator<'a, &'a [u8],
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_integ_id_infallible<'a>(v: <IntegIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_integ_id().wf(v@),
+        spec_integ_id().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_integ_id().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_integ_id().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_integ_id().spec_serialize(v@)),
+{
+    let combinator = integ_id();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn integ_id_len<'a>(v: <IntegIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_integ_id().wf(v@),
@@ -892,6 +1018,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DhIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DhIdCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type DhIdCombinatorAlias = U16Be;
 
 
@@ -944,6 +1074,22 @@ pub fn serialize_dh_id<'a>(v: <DhIdCombinator as Combinator<'a, &'a [u8], Vec<u8
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_dh_id_infallible<'a>(v: <DhIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_dh_id().wf(v@),
+        spec_dh_id().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_dh_id().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_dh_id().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_dh_id().spec_serialize(v@)),
+{
+    let combinator = dh_id();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn dh_id_len<'a>(v: <DhIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_dh_id().wf(v@),
@@ -1014,6 +1160,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EsnIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EsnIdCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type EsnIdCombinatorAlias = U16Be;
 
 
@@ -1066,6 +1216,22 @@ pub fn serialize_esn_id<'a>(v: <EsnIdCombinator as Combinator<'a, &'a [u8], Vec<
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_esn_id_infallible<'a>(v: <EsnIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_esn_id().wf(v@),
+        spec_esn_id().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_esn_id().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_esn_id().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_esn_id().spec_serialize(v@)),
+{
+    let combinator = esn_id();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn esn_id_len<'a>(v: <EsnIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_esn_id().wf(v@),
@@ -1298,6 +1464,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformIdValueCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformIdValueCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TransformIdValueCombinatorAlias = Mapped<TransformIdValueCombinator5, TransformIdValueMapper>;
 
 
@@ -1356,6 +1526,23 @@ pub fn serialize_transform_id_value<'a>(v: <TransformIdValueCombinator as Combin
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_transform_id_value_infallible<'a>(v: <TransformIdValueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, kind: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_id_value(kind@).wf(v@),
+        spec_transform_type().wf(kind@),
+        spec_transform_id_value(kind@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_transform_id_value(kind@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_transform_id_value(kind@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_transform_id_value(kind@).spec_serialize(v@)),
+{
+    let combinator = transform_id_value( kind );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn transform_id_value_len<'a>(v: <TransformIdValueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, kind: u8) -> (serialize_len: usize)
     requires
         spec_transform_id_value(kind@).wf(v@),
@@ -1505,6 +1692,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrKeyLengthCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformAttrKeyLengthCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TransformAttrKeyLengthCombinatorAlias = Mapped<TransformAttrKeyLengthCombinator1, TransformAttrKeyLengthMapper>;
 
 
@@ -1565,6 +1756,22 @@ pub fn serialize_transform_attr_key_length<'a>(v: <TransformAttrKeyLengthCombina
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_transform_attr_key_length_infallible<'a>(v: <TransformAttrKeyLengthCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_attr_key_length().wf(v@),
+        spec_transform_attr_key_length().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_transform_attr_key_length().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_transform_attr_key_length().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_transform_attr_key_length().spec_serialize(v@)),
+{
+    let combinator = transform_attr_key_length();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn transform_attr_key_length_len<'a>(v: <TransformAttrKeyLengthCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_transform_attr_key_length().wf(v@),
@@ -1725,6 +1932,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrTvCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformAttrTvCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TransformAttrTvCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate11909926070075194211>, U16Be, TransformAttrTvCont0>, TransformAttrTvMapper>;
 
 
@@ -1800,6 +2011,22 @@ pub fn serialize_transform_attr_tv<'a>(v: <TransformAttrTvCombinator as Combinat
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_transform_attr_tv_infallible<'a>(v: <TransformAttrTvCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_attr_tv().wf(v@),
+        spec_transform_attr_tv().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_transform_attr_tv().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_transform_attr_tv().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_transform_attr_tv().spec_serialize(v@)),
+{
+    let combinator = transform_attr_tv();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn transform_attr_tv_len<'a>(v: <TransformAttrTvCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_transform_attr_tv().wf(v@),
@@ -1994,6 +2221,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrTlvCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformAttrTlvCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TransformAttrTlvCombinatorAlias = Mapped<Pair<Pair<Refined<U16Be, Predicate5630542192344936318>, U16Be, TransformAttrTlvCont1>, bytes::Variable, TransformAttrTlvCont0>, TransformAttrTlvMapper>;
 
 
@@ -2084,6 +2315,22 @@ pub fn serialize_transform_attr_tlv<'a>(v: <TransformAttrTlvCombinator as Combin
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_transform_attr_tlv_infallible<'a>(v: <TransformAttrTlvCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_attr_tlv().wf(v@),
+        spec_transform_attr_tlv().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_transform_attr_tlv().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_transform_attr_tlv().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_transform_attr_tlv().spec_serialize(v@)),
+{
+    let combinator = transform_attr_tlv();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn transform_attr_tlv_len<'a>(v: <TransformAttrTlvCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_transform_attr_tlv().wf(v@),
@@ -2352,6 +2599,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformAttrCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TransformAttrCombinatorAlias = Mapped<TransformAttrCombinator2, TransformAttrMapper>;
 
 
@@ -2404,6 +2655,22 @@ pub fn serialize_transform_attr<'a>(v: <TransformAttrCombinator as Combinator<'a
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_transform_attr_infallible<'a>(v: <TransformAttrCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_attr().wf(v@),
+        spec_transform_attr().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_transform_attr().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_transform_attr().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_transform_attr().spec_serialize(v@)),
+{
+    let combinator = transform_attr();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn transform_attr_len<'a>(v: <TransformAttrCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_transform_attr().wf(v@),
@@ -2601,6 +2868,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TransformCombinatorAlias = Mapped<Pair<Pair<(Refined<U8, Predicate11363499016643468509>, (Refined<U8, TagPred<u8>>, Refined<U16Be, Predicate18193225726552524852>)), TransformTypeCombinator, TransformCont1>, (Refined<U8, TagPred<u8>>, (TransformIdValueCombinator, AndThen<bytes::Variable, Repeat<TransformAttrCombinator>>)), TransformCont0>, TransformMapper>;
 
 
@@ -2691,6 +2962,22 @@ pub fn serialize_transform<'a>(v: <TransformCombinator as Combinator<'a, &'a [u8
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_transform_infallible<'a>(v: <TransformCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform().wf(v@),
+        spec_transform().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_transform().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_transform().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_transform().spec_serialize(v@)),
+{
+    let combinator = transform();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn transform_len<'a>(v: <TransformCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_transform().wf(v@),
@@ -2902,6 +3189,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodySpi0Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalBodySpi0Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ProposalBodySpi0CombinatorAlias = Mapped<ProposalBodySpi0Combinator1, ProposalBodySpi0Mapper>;
 
 
@@ -2968,6 +3259,23 @@ pub fn serialize_proposal_body_spi0<'a>(v: <ProposalBodySpi0Combinator as Combin
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_proposal_body_spi0_infallible<'a>(v: <ProposalBodySpi0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num_transforms: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_proposal_body_spi0(num_transforms@).wf(v@),
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+        spec_proposal_body_spi0(num_transforms@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_proposal_body_spi0(num_transforms@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_proposal_body_spi0(num_transforms@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_proposal_body_spi0(num_transforms@).spec_serialize(v@)),
+{
+    let combinator = proposal_body_spi0( num_transforms );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn proposal_body_spi0_len<'a>(v: <ProposalBodySpi0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, num_transforms: u8) -> (serialize_len: usize)
     requires
         spec_proposal_body_spi0(num_transforms@).wf(v@),
@@ -3116,6 +3424,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodySpi4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalBodySpi4Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ProposalBodySpi4CombinatorAlias = Mapped<ProposalBodySpi4Combinator1, ProposalBodySpi4Mapper>;
 
 
@@ -3182,6 +3494,23 @@ pub fn serialize_proposal_body_spi4<'a>(v: <ProposalBodySpi4Combinator as Combin
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_proposal_body_spi4_infallible<'a>(v: <ProposalBodySpi4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num_transforms: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_proposal_body_spi4(num_transforms@).wf(v@),
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+        spec_proposal_body_spi4(num_transforms@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_proposal_body_spi4(num_transforms@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_proposal_body_spi4(num_transforms@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_proposal_body_spi4(num_transforms@).spec_serialize(v@)),
+{
+    let combinator = proposal_body_spi4( num_transforms );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn proposal_body_spi4_len<'a>(v: <ProposalBodySpi4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, num_transforms: u8) -> (serialize_len: usize)
     requires
         spec_proposal_body_spi4(num_transforms@).wf(v@),
@@ -3330,6 +3659,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodySpi8Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalBodySpi8Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ProposalBodySpi8CombinatorAlias = Mapped<ProposalBodySpi8Combinator1, ProposalBodySpi8Mapper>;
 
 
@@ -3396,6 +3729,23 @@ pub fn serialize_proposal_body_spi8<'a>(v: <ProposalBodySpi8Combinator as Combin
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_proposal_body_spi8_infallible<'a>(v: <ProposalBodySpi8Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num_transforms: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_proposal_body_spi8(num_transforms@).wf(v@),
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+        spec_proposal_body_spi8(num_transforms@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_proposal_body_spi8(num_transforms@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_proposal_body_spi8(num_transforms@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_proposal_body_spi8(num_transforms@).spec_serialize(v@)),
+{
+    let combinator = proposal_body_spi8( num_transforms );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn proposal_body_spi8_len<'a>(v: <ProposalBodySpi8Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, num_transforms: u8) -> (serialize_len: usize)
     requires
         spec_proposal_body_spi8(num_transforms@).wf(v@),
@@ -3581,6 +3931,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ProposalBodyCombinatorAlias = AndThen<bytes::Variable, Mapped<ProposalBodyCombinator2, ProposalBodyMapper>>;
 
 
@@ -3645,6 +3999,25 @@ pub fn serialize_proposal_body<'a>(v: <ProposalBodyCombinator as Combinator<'a,
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_proposal_body_infallible<'a>(v: <ProposalBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num_transforms: u8, proposal_length: u16, spi_size: ProposalSpiSizeByte) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_proposal_body(num_transforms@, proposal_length@, spi_size@).wf(v@),
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+        ((proposal_length) >= 8 && (proposal_length) <= 65535),
+        spec_proposal_spi_size_byte().wf(spi_size@),
+        spec_proposal_body(num_transforms@, proposal_length@, spi_size@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_proposal_body(num_transforms@, proposal_length@, spi_size@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_proposal_body(num_transforms@, proposal_length@, spi_size@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_proposal_body(num_transforms@, proposal_length@, spi_size@).spec_serialize(v@)),
+{
+    let combinator = proposal_body( num_transforms, proposal_length, spi_size );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn proposal_body_len<'a>(v: <ProposalBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, num_transforms: u8, proposal_length: u16, spi_size: ProposalSpiSizeByte) -> (serialize_len: usize)
     requires
         spec_proposal_body(num_transforms@, proposal_length@, spi_size@).wf(v@),
@@ -3867,6 +4240,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ProposalCombinatorAlias = Mapped<Pair<Pair<Pair<Pair<(Refined<U8, Predicate7277979220772363767>, (Refined<U8, TagPred<u8>>, Refined<U16Be, Predicate18193225726552524852>)), (Refined<U8, Predicate2172399096230090262>, IkeProtocolIdCombinator), ProposalCont3>, ProposalSpiSizeByteCombinator, ProposalCont2>, Refined<U8, Predicate3651688686135228051>, ProposalCont1>, ProposalBodyCombinator, ProposalCont0>, ProposalMapper>;
 
 
@@ -3987,6 +4364,22 @@ pub fn serialize_proposal<'a>(v: <ProposalCombinator as Combinator<'a, &'a [u8],
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_proposal_infallible<'a>(v: <ProposalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_proposal().wf(v@),
+        spec_proposal().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_proposal().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_proposal().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_proposal().spec_serialize(v@)),
+{
+    let combinator = proposal();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn proposal_len<'a>(v: <ProposalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_proposal().wf(v@),
@@ -4260,6 +4653,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SaPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for SaPayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type SaPayloadBodyCombinatorAlias = Mapped<AndThen<bytes::Variable, Repeat<ProposalCombinator>>, SaPayloadBodyMapper>;
 
 
@@ -4326,6 +4723,23 @@ pub fn serialize_sa_payload_body<'a>(v: <SaPayloadBodyCombinator as Combinator<'
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_sa_payload_body_infallible<'a>(v: <SaPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_sa_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+        spec_sa_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_sa_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_sa_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_sa_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = sa_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn sa_payload_body_len<'a>(v: <SaPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_sa_payload_body(payload_length@).wf(v@),
@@ -4536,6 +4950,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv6Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsIpv6Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TsIpv6CombinatorAlias = Mapped<TsIpv6Combinator6, TsIpv6Mapper>;
 
 
@@ -4596,6 +5014,22 @@ pub fn serialize_ts_ipv6<'a>(v: <TsIpv6Combinator as Combinator<'a, &'a [u8], Ve
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ts_ipv6_infallible<'a>(v: <TsIpv6Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_ipv6().wf(v@),
+        spec_ts_ipv6().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ts_ipv6().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ts_ipv6().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ts_ipv6().spec_serialize(v@)),
+{
+    let combinator = ts_ipv6();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ts_ipv6_len<'a>(v: <TsIpv6Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ts_ipv6().wf(v@),
@@ -4733,6 +5167,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2SaPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2SaPayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2SaPayloadInnerCombinatorAlias = Mapped<AndThen<bytes::Tail, Repeat<ProposalCombinator>>, Ikev2SaPayloadInnerMapper>;
 
 
@@ -4793,6 +5231,22 @@ pub fn serialize_ikev2_sa_payload_inner<'a>(v: <Ikev2SaPayloadInnerCombinator as
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_sa_payload_inner_infallible<'a>(v: <Ikev2SaPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_sa_payload_inner().wf(v@),
+        spec_ikev2_sa_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_sa_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_sa_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_sa_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_sa_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_sa_payload_inner_len<'a>(v: <Ikev2SaPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_sa_payload_inner().wf(v@),
@@ -4930,6 +5384,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NoncePayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NoncePayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NoncePayloadBodyCombinatorAlias = Mapped<bytes::Variable, NoncePayloadBodyMapper>;
 
 
@@ -4996,6 +5454,23 @@ pub fn serialize_nonce_payload_body<'a>(v: <NoncePayloadBodyCombinator as Combin
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_nonce_payload_body_infallible<'a>(v: <NoncePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_nonce_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 20 && (payload_length) <= 260),
+        spec_nonce_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_nonce_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_nonce_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_nonce_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = nonce_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn nonce_payload_body_len<'a>(v: <NoncePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_nonce_payload_body(payload_length@).wf(v@),
@@ -5077,6 +5552,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IdTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IdTypeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type IdTypeCombinatorAlias = U8;
 
 
@@ -5129,6 +5608,22 @@ pub fn serialize_id_type<'a>(v: <IdTypeCombinator as Combinator<'a, &'a [u8], Ve
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_id_type_infallible<'a>(v: <IdTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_id_type().wf(v@),
+        spec_id_type().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_id_type().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_id_type().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_id_type().spec_serialize(v@)),
+{
+    let combinator = id_type();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn id_type_len<'a>(v: <IdTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_id_type().wf(v@),
@@ -5295,6 +5790,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2IdPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2IdPayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2IdPayloadInnerCombinatorAlias = Mapped<Ikev2IdPayloadInnerCombinator2, Ikev2IdPayloadInnerMapper>;
 
 
@@ -5355,15 +5854,31 @@ pub fn serialize_ikev2_id_payload_inner<'a>(v: <Ikev2IdPayloadInnerCombinator as
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn ikev2_id_payload_inner_len<'a>(v: <Ikev2IdPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn serialize_ikev2_id_payload_inner_infallible<'a>(v: <Ikev2IdPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
     requires
+        pos <= old(data)@.len() <= usize::MAX,
         spec_ikev2_id_payload_inner().wf(v@),
         spec_ikev2_id_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_id_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
     ensures
-        serialize_len == spec_ikev2_id_payload_inner().spec_serialize(v@).len(),
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_id_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_id_payload_inner().spec_serialize(v@)),
 {
     let combinator = ikev2_id_payload_inner();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+    serialize_infallible(&combinator, v, data, pos)
+}
+
+pub fn ikev2_id_payload_inner_len<'a>(v: <Ikev2IdPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_ikev2_id_payload_inner().wf(v@),
+        spec_ikev2_id_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_id_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_id_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
@@ -5502,6 +6017,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodySpi0Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodySpi0Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NotifyPayloadBodySpi0CombinatorAlias = Mapped<NotifyPayloadBodySpi0Combinator1, NotifyPayloadBodySpi0Mapper>;
 
 
@@ -5562,6 +6081,22 @@ pub fn serialize_notify_payload_body_spi0<'a>(v: <NotifyPayloadBodySpi0Combinato
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_notify_payload_body_spi0_infallible<'a>(v: <NotifyPayloadBodySpi0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_notify_payload_body_spi0().wf(v@),
+        spec_notify_payload_body_spi0().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_notify_payload_body_spi0().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_notify_payload_body_spi0().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_notify_payload_body_spi0().spec_serialize(v@)),
+{
+    let combinator = notify_payload_body_spi0();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn notify_payload_body_spi0_len<'a>(v: <NotifyPayloadBodySpi0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_notify_payload_body_spi0().wf(v@),
@@ -5628,6 +6163,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CfgAttrTypeWordCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CfgAttrTypeWordCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CfgAttrTypeWordCombinatorAlias = Refined<U16Be, Predicate5630542192344936318>;
 
 
@@ -5680,6 +6219,22 @@ pub fn serialize_cfg_attr_type_word<'a>(v: <CfgAttrTypeWordCombinator as Combina
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_cfg_attr_type_word_infallible<'a>(v: <CfgAttrTypeWordCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cfg_attr_type_word().wf(v@),
+        spec_cfg_attr_type_word().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_cfg_attr_type_word().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_cfg_attr_type_word().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_cfg_attr_type_word().spec_serialize(v@)),
+{
+    let combinator = cfg_attr_type_word();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn cfg_attr_type_word_len<'a>(v: <CfgAttrTypeWordCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_cfg_attr_type_word().wf(v@),
@@ -5823,6 +6378,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CfgAttributeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CfgAttributeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CfgAttributeCombinatorAlias = Mapped<Pair<Pair<CfgAttrTypeWordCombinator, U16Be, CfgAttributeCont1>, bytes::Variable, CfgAttributeCont0>, CfgAttributeMapper>;
 
 
@@ -5913,6 +6472,22 @@ pub fn serialize_cfg_attribute<'a>(v: <CfgAttributeCombinator as Combinator<'a,
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_cfg_attribute_infallible<'a>(v: <CfgAttributeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cfg_attribute().wf(v@),
+        spec_cfg_attribute().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_cfg_attribute().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_cfg_attribute().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_cfg_attribute().spec_serialize(v@)),
+{
+    let combinator = cfg_attribute();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn cfg_attribute_len<'a>(v: <CfgAttributeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_cfg_attribute().wf(v@),
@@ -6047,6 +6622,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsTypeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TsTypeCombinatorAlias = U8;
 
 
@@ -6099,6 +6678,22 @@ pub fn serialize_ts_type<'a>(v: <TsTypeCombinator as Combinator<'a, &'a [u8], Ve
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ts_type_infallible<'a>(v: <TsTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_type().wf(v@),
+        spec_ts_type().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ts_type().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ts_type().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ts_type().spec_serialize(v@)),
+{
+    let combinator = ts_type();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ts_type_len<'a>(v: <TsTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ts_type().wf(v@),
@@ -6295,6 +6890,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv4SelectorBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsIpv4SelectorBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TsIpv4SelectorBodyCombinatorAlias = Mapped<TsIpv4SelectorBodyCombinator5, TsIpv4SelectorBodyMapper>;
 
 
@@ -6355,6 +6954,22 @@ pub fn serialize_ts_ipv4_selector_body<'a>(v: <TsIpv4SelectorBodyCombinator as C
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ts_ipv4_selector_body_infallible<'a>(v: <TsIpv4SelectorBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_ipv4_selector_body().wf(v@),
+        spec_ts_ipv4_selector_body().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ts_ipv4_selector_body().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ts_ipv4_selector_body().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ts_ipv4_selector_body().spec_serialize(v@)),
+{
+    let combinator = ts_ipv4_selector_body();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ts_ipv4_selector_body_len<'a>(v: <TsIpv4SelectorBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ts_ipv4_selector_body().wf(v@),
@@ -6551,6 +7166,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv6SelectorBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsIpv6SelectorBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TsIpv6SelectorBodyCombinatorAlias = Mapped<TsIpv6SelectorBodyCombinator5, TsIpv6SelectorBodyMapper>;
 
 
@@ -6611,6 +7230,22 @@ pub fn serialize_ts_ipv6_selector_body<'a>(v: <TsIpv6SelectorBodyCombinator as C
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ts_ipv6_selector_body_infallible<'a>(v: <TsIpv6SelectorBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_ipv6_selector_body().wf(v@),
+        spec_ts_ipv6_selector_body().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ts_ipv6_selector_body().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ts_ipv6_selector_body().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ts_ipv6_selector_body().spec_serialize(v@)),
+{
+    let combinator = ts_ipv6_selector_body();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ts_ipv6_selector_body_len<'a>(v: <TsIpv6SelectorBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ts_ipv6_selector_body().wf(v@),
@@ -6774,6 +7409,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsUnknownInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsUnknownInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TsUnknownInnerCombinatorAlias = Mapped<Pair<(U8, Refined<U16Be, Predicate17149271707383182075>), bytes::Variable, TsUnknownInnerCont0>, TsUnknownInnerMapper>;
 
 
@@ -6849,6 +7488,22 @@ pub fn serialize_ts_unknown_inner<'a>(v: <TsUnknownInnerCombinator as Combinator
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ts_unknown_inner_infallible<'a>(v: <TsUnknownInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_unknown_inner().wf(v@),
+        spec_ts_unknown_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ts_unknown_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ts_unknown_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ts_unknown_inner().spec_serialize(v@)),
+{
+    let combinator = ts_unknown_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ts_unknown_inner_len<'a>(v: <TsUnknownInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ts_unknown_inner().wf(v@),
@@ -7064,6 +7719,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TrafficSelectorTsBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TrafficSelectorTsBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TrafficSelectorTsBodyCombinatorAlias = Mapped<TrafficSelectorTsBodyCombinator2, TrafficSelectorTsBodyMapper>;
 
 
@@ -7122,6 +7781,23 @@ pub fn serialize_traffic_selector_ts_body<'a>(v: <TrafficSelectorTsBodyCombinato
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_traffic_selector_ts_body_infallible<'a>(v: <TrafficSelectorTsBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ts_type_byte: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_traffic_selector_ts_body(ts_type_byte@).wf(v@),
+        spec_ts_type().wf(ts_type_byte@),
+        spec_traffic_selector_ts_body(ts_type_byte@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_traffic_selector_ts_body(ts_type_byte@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_traffic_selector_ts_body(ts_type_byte@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_traffic_selector_ts_body(ts_type_byte@).spec_serialize(v@)),
+{
+    let combinator = traffic_selector_ts_body( ts_type_byte );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn traffic_selector_ts_body_len<'a>(v: <TrafficSelectorTsBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ts_type_byte: u8) -> (serialize_len: usize)
     requires
         spec_traffic_selector_ts_body(ts_type_byte@).wf(v@),
@@ -7263,6 +7939,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TrafficSelectorCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TrafficSelectorCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TrafficSelectorCombinatorAlias = Mapped<Pair<TsTypeCombinator, TrafficSelectorTsBodyCombinator, TrafficSelectorCont0>, TrafficSelectorMapper>;
 
 
@@ -7338,6 +8018,22 @@ pub fn serialize_traffic_selector<'a>(v: <TrafficSelectorCombinator as Combinato
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_traffic_selector_infallible<'a>(v: <TrafficSelectorCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_traffic_selector().wf(v@),
+        spec_traffic_selector().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_traffic_selector().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_traffic_selector().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_traffic_selector().spec_serialize(v@)),
+{
+    let combinator = traffic_selector();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn traffic_selector_len<'a>(v: <TrafficSelectorCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_traffic_selector().wf(v@),
@@ -7519,6 +8215,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2TsPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2TsPayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2TsPayloadInnerCombinatorAlias = Mapped<Pair<Refined<U8, Predicate3651688686135228051>, (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, AndThen<bytes::Tail, RepeatN<TrafficSelectorCombinator>>), Ikev2TsPayloadInnerCont0>, Ikev2TsPayloadInnerMapper>;
 
 
@@ -7594,6 +8294,22 @@ pub fn serialize_ikev2_ts_payload_inner<'a>(v: <Ikev2TsPayloadInnerCombinator as
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_ts_payload_inner_infallible<'a>(v: <Ikev2TsPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_ts_payload_inner().wf(v@),
+        spec_ikev2_ts_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_ts_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_ts_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_ts_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_ts_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_ts_payload_inner_len<'a>(v: <Ikev2TsPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_ts_payload_inner().wf(v@),
@@ -7773,6 +8489,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapSuccessRestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapSuccessRestCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type EapSuccessRestCombinatorAlias = Mapped<EapSuccessRestCombinator1, EapSuccessRestMapper>;
 
 
@@ -7833,6 +8553,22 @@ pub fn serialize_eap_success_rest<'a>(v: <EapSuccessRestCombinator as Combinator
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_eap_success_rest_infallible<'a>(v: <EapSuccessRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_success_rest().wf(v@),
+        spec_eap_success_rest().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_eap_success_rest().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_eap_success_rest().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_eap_success_rest().spec_serialize(v@)),
+{
+    let combinator = eap_success_rest();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn eap_success_rest_len<'a>(v: <EapSuccessRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_eap_success_rest().wf(v@),
@@ -7919,6 +8655,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IpsecSpiSizeOrNoneCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IpsecSpiSizeOrNoneCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type IpsecSpiSizeOrNoneCombinatorAlias = Refined<U8, Predicate15445621259281350129>;
 
 
@@ -7971,6 +8711,22 @@ pub fn serialize_ipsec_spi_size_or_none<'a>(v: <IpsecSpiSizeOrNoneCombinator as
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ipsec_spi_size_or_none_infallible<'a>(v: <IpsecSpiSizeOrNoneCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ipsec_spi_size_or_none().wf(v@),
+        spec_ipsec_spi_size_or_none().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ipsec_spi_size_or_none().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ipsec_spi_size_or_none().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ipsec_spi_size_or_none().spec_serialize(v@)),
+{
+    let combinator = ipsec_spi_size_or_none();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ipsec_spi_size_or_none_len<'a>(v: <IpsecSpiSizeOrNoneCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ipsec_spi_size_or_none().wf(v@),
@@ -8045,6 +8801,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapCodeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapCodeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type EapCodeCombinatorAlias = U8;
 
 
@@ -8097,6 +8857,22 @@ pub fn serialize_eap_code<'a>(v: <EapCodeCombinator as Combinator<'a, &'a [u8],
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_eap_code_infallible<'a>(v: <EapCodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_code().wf(v@),
+        spec_eap_code().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_eap_code().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_eap_code().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_eap_code().spec_serialize(v@)),
+{
+    let combinator = eap_code();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn eap_code_len<'a>(v: <EapCodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_eap_code().wf(v@),
@@ -8245,6 +9021,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapFailureRestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapFailureRestCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type EapFailureRestCombinatorAlias = Mapped<EapFailureRestCombinator1, EapFailureRestMapper>;
 
 
@@ -8305,6 +9085,22 @@ pub fn serialize_eap_failure_rest<'a>(v: <EapFailureRestCombinator as Combinator
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_eap_failure_rest_infallible<'a>(v: <EapFailureRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_failure_rest().wf(v@),
+        spec_eap_failure_rest().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_eap_failure_rest().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_eap_failure_rest().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_eap_failure_rest().spec_serialize(v@)),
+{
+    let combinator = eap_failure_rest();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn eap_failure_rest_len<'a>(v: <EapFailureRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_eap_failure_rest().wf(v@),
@@ -8471,6 +9267,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapReqRespRestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapReqRespRestCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type EapReqRespRestCombinatorAlias = Mapped<Pair<(U8, Refined<U16Be, Predicate7010197279221949030>), (U8, bytes::Variable), EapReqRespRestCont0>, EapReqRespRestMapper>;
 
 
@@ -8546,6 +9346,22 @@ pub fn serialize_eap_req_resp_rest<'a>(v: <EapReqRespRestCombinator as Combinato
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_eap_req_resp_rest_infallible<'a>(v: <EapReqRespRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_req_resp_rest().wf(v@),
+        spec_eap_req_resp_rest().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_eap_req_resp_rest().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_eap_req_resp_rest().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_eap_req_resp_rest().spec_serialize(v@)),
+{
+    let combinator = eap_req_resp_rest();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn eap_req_resp_rest_len<'a>(v: <EapReqRespRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_eap_req_resp_rest().wf(v@),
@@ -8777,6 +9593,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2EapPayloadInnerEapRestCombin
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2EapPayloadInnerEapRestCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2EapPayloadInnerEapRestCombinatorAlias = Mapped<Ikev2EapPayloadInnerEapRestCombinator3, Ikev2EapPayloadInnerEapRestMapper>;
 
 
@@ -8835,6 +9655,23 @@ pub fn serialize_ikev2_eap_payload_inner_eap_rest<'a>(v: <Ikev2EapPayloadInnerEa
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_ikev2_eap_payload_inner_eap_rest_infallible<'a>(v: <Ikev2EapPayloadInnerEapRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, code: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_eap_payload_inner_eap_rest(code@).wf(v@),
+        spec_eap_code().wf(code@),
+        spec_ikev2_eap_payload_inner_eap_rest(code@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_eap_payload_inner_eap_rest(code@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_eap_payload_inner_eap_rest(code@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_eap_payload_inner_eap_rest(code@).spec_serialize(v@)),
+{
+    let combinator = ikev2_eap_payload_inner_eap_rest( code );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_eap_payload_inner_eap_rest_len<'a>(v: <Ikev2EapPayloadInnerEapRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, code: u8) -> (serialize_len: usize)
     requires
         spec_ikev2_eap_payload_inner_eap_rest(code@).wf(v@),
@@ -8976,6 +9813,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2EapPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2EapPayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2EapPayloadInnerCombinatorAlias = Mapped<Pair<EapCodeCombinator, Ikev2EapPayloadInnerEapRestCombinator, Ikev2EapPayloadInnerCont0>, Ikev2EapPayloadInnerMapper>;
 
 
@@ -9051,6 +9892,22 @@ pub fn serialize_ikev2_eap_payload_inner<'a>(v: <Ikev2EapPayloadInnerCombinator
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_eap_payload_inner_infallible<'a>(v: <Ikev2EapPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_eap_payload_inner().wf(v@),
+        spec_ikev2_eap_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_eap_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_eap_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_eap_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_eap_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_eap_payload_inner_len<'a>(v: <Ikev2EapPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_eap_payload_inner().wf(v@),
@@ -9172,6 +10029,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertEncodingCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CertEncodingCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CertEncodingCombinatorAlias = U8;
 
 
@@ -9224,6 +10085,22 @@ pub fn serialize_cert_encoding<'a>(v: <CertEncodingCombinator as Combinator<'a,
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_cert_encoding_infallible<'a>(v: <CertEncodingCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cert_encoding().wf(v@),
+        spec_cert_encoding().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_cert_encoding().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_cert_encoding().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_cert_encoding().spec_serialize(v@)),
+{
+    let combinator = cert_encoding();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn cert_encoding_len<'a>(v: <CertEncodingCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_cert_encoding().wf(v@),
@@ -9371,6 +10248,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertreqPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CertreqPayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CertreqPayloadBodyCombinatorAlias = Mapped<CertreqPayloadBodyCombinator1, CertreqPayloadBodyMapper>;
 
 
@@ -9437,6 +10318,23 @@ pub fn serialize_certreq_payload_body<'a>(v: <CertreqPayloadBodyCombinator as Co
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_certreq_payload_body_infallible<'a>(v: <CertreqPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_certreq_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 5 && (payload_length) <= 65535),
+        spec_certreq_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_certreq_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_certreq_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_certreq_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = certreq_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn certreq_payload_body_len<'a>(v: <CertreqPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_certreq_payload_body(payload_length@).wf(v@),
@@ -9638,6 +10536,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapPayloadBodyEapRestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapPayloadBodyEapRestCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type EapPayloadBodyEapRestCombinatorAlias = Mapped<EapPayloadBodyEapRestCombinator3, EapPayloadBodyEapRestMapper>;
 
 
@@ -9696,6 +10598,23 @@ pub fn serialize_eap_payload_body_eap_rest<'a>(v: <EapPayloadBodyEapRestCombinat
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_eap_payload_body_eap_rest_infallible<'a>(v: <EapPayloadBodyEapRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, code: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_payload_body_eap_rest(code@).wf(v@),
+        spec_eap_code().wf(code@),
+        spec_eap_payload_body_eap_rest(code@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_eap_payload_body_eap_rest(code@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_eap_payload_body_eap_rest(code@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_eap_payload_body_eap_rest(code@).spec_serialize(v@)),
+{
+    let combinator = eap_payload_body_eap_rest( code );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn eap_payload_body_eap_rest_len<'a>(v: <EapPayloadBodyEapRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, code: u8) -> (serialize_len: usize)
     requires
         spec_eap_payload_body_eap_rest(code@).wf(v@),
@@ -9771,6 +10690,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CfgTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CfgTypeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CfgTypeCombinatorAlias = U8;
 
 
@@ -9823,6 +10746,22 @@ pub fn serialize_cfg_type<'a>(v: <CfgTypeCombinator as Combinator<'a, &'a [u8],
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_cfg_type_infallible<'a>(v: <CfgTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cfg_type().wf(v@),
+        spec_cfg_type().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_cfg_type().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_cfg_type().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_cfg_type().spec_serialize(v@)),
+{
+    let combinator = cfg_type();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn cfg_type_len<'a>(v: <CfgTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_cfg_type().wf(v@),
@@ -9989,6 +10928,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CpPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CpPayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CpPayloadBodyCombinatorAlias = Mapped<CpPayloadBodyCombinator2, CpPayloadBodyMapper>;
 
 
@@ -10055,6 +10998,23 @@ pub fn serialize_cp_payload_body<'a>(v: <CpPayloadBodyCombinator as Combinator<'
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_cp_payload_body_infallible<'a>(v: <CpPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cp_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+        spec_cp_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_cp_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_cp_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_cp_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = cp_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn cp_payload_body_len<'a>(v: <CpPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_cp_payload_body(payload_length@).wf(v@),
@@ -10196,6 +11156,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapPayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type EapPayloadBodyCombinatorAlias = Mapped<Pair<EapCodeCombinator, EapPayloadBodyEapRestCombinator, EapPayloadBodyCont0>, EapPayloadBodyMapper>;
 
 
@@ -10277,6 +11241,23 @@ pub fn serialize_eap_payload_body<'a>(v: <EapPayloadBodyCombinator as Combinator
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_eap_payload_body_infallible<'a>(v: <EapPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+        spec_eap_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_eap_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_eap_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_eap_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = eap_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn eap_payload_body_len<'a>(v: <EapPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_eap_payload_body(payload_length@).wf(v@),
@@ -10389,6 +11370,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExchangeTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ExchangeTypeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ExchangeTypeCombinatorAlias = U8;
 
 
@@ -10441,6 +11426,22 @@ pub fn serialize_exchange_type<'a>(v: <ExchangeTypeCombinator as Combinator<'a,
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_exchange_type_infallible<'a>(v: <ExchangeTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_exchange_type().wf(v@),
+        spec_exchange_type().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_exchange_type().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_exchange_type().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_exchange_type().spec_serialize(v@)),
+{
+    let combinator = exchange_type();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn exchange_type_len<'a>(v: <ExchangeTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_exchange_type().wf(v@),
@@ -10565,6 +11566,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyMsgTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyMsgTypeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NotifyMsgTypeCombinatorAlias = U16Be;
 
 
@@ -10617,6 +11622,22 @@ pub fn serialize_notify_msg_type<'a>(v: <NotifyMsgTypeCombinator as Combinator<'
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_notify_msg_type_infallible<'a>(v: <NotifyMsgTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_notify_msg_type().wf(v@),
+        spec_notify_msg_type().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_notify_msg_type().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_notify_msg_type().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_notify_msg_type().spec_serialize(v@)),
+{
+    let combinator = notify_msg_type();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn notify_msg_type_len<'a>(v: <NotifyMsgTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_notify_msg_type().wf(v@),
@@ -10777,6 +11798,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for KePayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for KePayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type KePayloadBodyCombinatorAlias = Mapped<KePayloadBodyCombinator2, KePayloadBodyMapper>;
 
 
@@ -10843,6 +11868,23 @@ pub fn serialize_ke_payload_body<'a>(v: <KePayloadBodyCombinator as Combinator<'
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_ke_payload_body_infallible<'a>(v: <KePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ke_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+        spec_ke_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ke_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ke_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ke_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = ke_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ke_payload_body_len<'a>(v: <KePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_ke_payload_body(payload_length@).wf(v@),
@@ -10944,6 +11986,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NextPayloadTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NextPayloadTypeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NextPayloadTypeCombinatorAlias = U8;
 
 
@@ -10996,6 +12042,22 @@ pub fn serialize_next_payload_type<'a>(v: <NextPayloadTypeCombinator as Combinat
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_next_payload_type_infallible<'a>(v: <NextPayloadTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_next_payload_type().wf(v@),
+        spec_next_payload_type().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_next_payload_type().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_next_payload_type().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_next_payload_type().spec_serialize(v@)),
+{
+    let combinator = next_payload_type();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn next_payload_type_len<'a>(v: <NextPayloadTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_next_payload_type().wf(v@),
@@ -11082,6 +12144,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeVersionByteCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IkeVersionByteCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type IkeVersionByteCombinatorAlias = Refined<U8, Predicate10005340194363141588>;
 
 
@@ -11134,6 +12200,22 @@ pub fn serialize_ike_version_byte<'a>(v: <IkeVersionByteCombinator as Combinator
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ike_version_byte_infallible<'a>(v: <IkeVersionByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ike_version_byte().wf(v@),
+        spec_ike_version_byte().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ike_version_byte().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ike_version_byte().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ike_version_byte().spec_serialize(v@)),
+{
+    let combinator = ike_version_byte();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ike_version_byte_len<'a>(v: <IkeVersionByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ike_version_byte().wf(v@),
@@ -11320,6 +12402,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeFlagsCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IkeFlagsCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type IkeFlagsCombinatorAlias = TryMap<U8, IkeFlagsMapper>;
 
 
@@ -11372,6 +12458,22 @@ pub fn serialize_ike_flags<'a>(v: <IkeFlagsCombinator as Combinator<'a, &'a [u8]
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ike_flags_infallible<'a>(v: <IkeFlagsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ike_flags().wf(v@),
+        spec_ike_flags().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ike_flags().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ike_flags().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ike_flags().spec_serialize(v@)),
+{
+    let combinator = ike_flags();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ike_flags_len<'a>(v: <IkeFlagsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ike_flags().wf(v@),
@@ -11611,6 +12713,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IkeHeaderCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type IkeHeaderCombinatorAlias = Mapped<IkeHeaderCombinator7, IkeHeaderMapper>;
 
 
@@ -11671,6 +12777,22 @@ pub fn serialize_ike_header<'a>(v: <IkeHeaderCombinator as Combinator<'a, &'a [u
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ike_header_infallible<'a>(v: <IkeHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ike_header().wf(v@),
+        spec_ike_header().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ike_header().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ike_header().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ike_header().spec_serialize(v@)),
+{
+    let combinator = ike_header();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ike_header_len<'a>(v: <IkeHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ike_header().wf(v@),
@@ -11737,6 +12859,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadSpisNoneCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DeletePayloadSpisNoneCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type DeletePayloadSpisNoneCombinatorAlias = bytes::Fixed<0>;
 
 
@@ -11789,6 +12915,22 @@ pub fn serialize_delete_payload_spis_none<'a>(v: <DeletePayloadSpisNoneCombinato
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_delete_payload_spis_none_infallible<'a>(v: <DeletePayloadSpisNoneCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_delete_payload_spis_none().wf(v@),
+        spec_delete_payload_spis_none().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_delete_payload_spis_none().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_delete_payload_spis_none().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_delete_payload_spis_none().spec_serialize(v@)),
+{
+    let combinator = delete_payload_spis_none();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn delete_payload_spis_none_len<'a>(v: <DeletePayloadSpisNoneCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_delete_payload_spis_none().wf(v@),
@@ -11967,6 +13109,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapMessageSuccessFailureCombinato
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapMessageSuccessFailureCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type EapMessageSuccessFailureCombinatorAlias = Mapped<EapMessageSuccessFailureCombinator2, EapMessageSuccessFailureMapper>;
 
 
@@ -12027,6 +13173,22 @@ pub fn serialize_eap_message_success_failure<'a>(v: <EapMessageSuccessFailureCom
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_eap_message_success_failure_infallible<'a>(v: <EapMessageSuccessFailureCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_message_success_failure().wf(v@),
+        spec_eap_message_success_failure().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_eap_message_success_failure().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_eap_message_success_failure().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_eap_message_success_failure().spec_serialize(v@)),
+{
+    let combinator = eap_message_success_failure();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn eap_message_success_failure_len<'a>(v: <EapMessageSuccessFailureCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_eap_message_success_failure().wf(v@),
@@ -12174,6 +13336,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2CertPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2CertPayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2CertPayloadInnerCombinatorAlias = Mapped<Ikev2CertPayloadInnerCombinator1, Ikev2CertPayloadInnerMapper>;
 
 
@@ -12234,6 +13400,22 @@ pub fn serialize_ikev2_cert_payload_inner<'a>(v: <Ikev2CertPayloadInnerCombinato
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_cert_payload_inner_infallible<'a>(v: <Ikev2CertPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_cert_payload_inner().wf(v@),
+        spec_ikev2_cert_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_cert_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_cert_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_cert_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_cert_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_cert_payload_inner_len<'a>(v: <Ikev2CertPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_cert_payload_inner().wf(v@),
@@ -12306,6 +13488,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AuthMethodCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AuthMethodCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type AuthMethodCombinatorAlias = U8;
 
 
@@ -12358,6 +13544,22 @@ pub fn serialize_auth_method<'a>(v: <AuthMethodCombinator as Combinator<'a, &'a
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_auth_method_infallible<'a>(v: <AuthMethodCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_auth_method().wf(v@),
+        spec_auth_method().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_auth_method().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_auth_method().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_auth_method().spec_serialize(v@)),
+{
+    let combinator = auth_method();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn auth_method_len<'a>(v: <AuthMethodCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_auth_method().wf(v@),
@@ -12524,6 +13726,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2AuthPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2AuthPayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2AuthPayloadInnerCombinatorAlias = Mapped<Ikev2AuthPayloadInnerCombinator2, Ikev2AuthPayloadInnerMapper>;
 
 
@@ -12584,6 +13790,22 @@ pub fn serialize_ikev2_auth_payload_inner<'a>(v: <Ikev2AuthPayloadInnerCombinato
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_auth_payload_inner_infallible<'a>(v: <Ikev2AuthPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_auth_payload_inner().wf(v@),
+        spec_ikev2_auth_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_auth_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_auth_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_auth_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_auth_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_auth_payload_inner_len<'a>(v: <Ikev2AuthPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_auth_payload_inner().wf(v@),
@@ -12721,6 +13943,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2NoncePayloadInnerCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2NoncePayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2NoncePayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2NoncePayloadInnerMapper>;
 
 
@@ -12781,6 +14007,22 @@ pub fn serialize_ikev2_nonce_payload_inner<'a>(v: <Ikev2NoncePayloadInnerCombina
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_nonce_payload_inner_infallible<'a>(v: <Ikev2NoncePayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_nonce_payload_inner().wf(v@),
+        spec_ikev2_nonce_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_nonce_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_nonce_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_nonce_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_nonce_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_nonce_payload_inner_len<'a>(v: <Ikev2NoncePayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_nonce_payload_inner().wf(v@),
@@ -12918,6 +14160,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2VendorIdPayloadInnerCombinat
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2VendorIdPayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2VendorIdPayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2VendorIdPayloadInnerMapper>;
 
 
@@ -12978,6 +14224,22 @@ pub fn serialize_ikev2_vendor_id_payload_inner<'a>(v: <Ikev2VendorIdPayloadInner
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_vendor_id_payload_inner_infallible<'a>(v: <Ikev2VendorIdPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_vendor_id_payload_inner().wf(v@),
+        spec_ikev2_vendor_id_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_vendor_id_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_vendor_id_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_vendor_id_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_vendor_id_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_vendor_id_payload_inner_len<'a>(v: <Ikev2VendorIdPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_vendor_id_payload_inner().wf(v@),
@@ -13115,6 +14377,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SkPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for SkPayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type SkPayloadBodyCombinatorAlias = Mapped<bytes::Variable, SkPayloadBodyMapper>;
 
 
@@ -13178,7 +14444,24 @@ pub fn serialize_sk_payload_body<'a>(v: <SkPayloadBodyCombinator as Combinator<'
         },
 {
     let combinator = sk_payload_body( payload_length );
-    combinator.serialize(v, data, pos)
+    combinator.serialize(v, data, pos)
+}
+
+pub fn serialize_sk_payload_body_infallible<'a>(v: <SkPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_sk_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+        spec_sk_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_sk_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_sk_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_sk_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = sk_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
 }
 
 pub fn sk_payload_body_len<'a>(v: <SkPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
@@ -13361,6 +14644,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyProtocolIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyProtocolIdCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NotifyProtocolIdCombinatorAlias = TryMap<U8, NotifyProtocolIdMapper>;
 
 
@@ -13413,6 +14700,22 @@ pub fn serialize_notify_protocol_id<'a>(v: <NotifyProtocolIdCombinator as Combin
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_notify_protocol_id_infallible<'a>(v: <NotifyProtocolIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_notify_protocol_id().wf(v@),
+        spec_notify_protocol_id().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_notify_protocol_id().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_notify_protocol_id().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_notify_protocol_id().spec_serialize(v@)),
+{
+    let combinator = notify_protocol_id();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn notify_protocol_id_len<'a>(v: <NotifyProtocolIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_notify_protocol_id().wf(v@),
@@ -13562,6 +14865,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2NotifyPayloadInnerCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2NotifyPayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2NotifyPayloadInnerCombinatorAlias = Mapped<Pair<Pair<NotifyProtocolIdCombinator, IpsecSpiSizeOrNoneCombinator, Ikev2NotifyPayloadInnerCont1>, (NotifyMsgTypeCombinator, (bytes::Variable, bytes::Tail)), Ikev2NotifyPayloadInnerCont0>, Ikev2NotifyPayloadInnerMapper>;
 
 
@@ -13652,6 +14959,22 @@ pub fn serialize_ikev2_notify_payload_inner<'a>(v: <Ikev2NotifyPayloadInnerCombi
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_notify_payload_inner_infallible<'a>(v: <Ikev2NotifyPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_notify_payload_inner().wf(v@),
+        spec_ikev2_notify_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_notify_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_notify_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_notify_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_notify_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_notify_payload_inner_len<'a>(v: <Ikev2NotifyPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_notify_payload_inner().wf(v@),
@@ -13782,6 +15105,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadSpisIpsecCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DeletePayloadSpisIpsecCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type DeletePayloadSpisIpsecCombinatorAlias = RepeatN<U32Be>;
 
 
@@ -13836,6 +15163,22 @@ pub fn serialize_delete_payload_spis_ipsec<'a>(v: <DeletePayloadSpisIpsecCombina
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_delete_payload_spis_ipsec_infallible<'a>(v: <DeletePayloadSpisIpsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num_spis: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_delete_payload_spis_ipsec(num_spis@).wf(v@),
+        spec_delete_payload_spis_ipsec(num_spis@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_delete_payload_spis_ipsec(num_spis@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_delete_payload_spis_ipsec(num_spis@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_delete_payload_spis_ipsec(num_spis@).spec_serialize(v@)),
+{
+    let combinator = delete_payload_spis_ipsec( num_spis );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn delete_payload_spis_ipsec_len<'a>(v: <DeletePayloadSpisIpsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, num_spis: u16) -> (serialize_len: usize)
     requires
         spec_delete_payload_spis_ipsec(num_spis@).wf(v@),
@@ -14003,6 +15346,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapMessageReqRespCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapMessageReqRespCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type EapMessageReqRespCombinatorAlias = Mapped<Pair<(Refined<EapCodeCombinator, Predicate8053454275691315570>, (U8, Refined<U16Be, Predicate7010197279221949030>)), (U8, bytes::Variable), EapMessageReqRespCont0>, EapMessageReqRespMapper>;
 
 
@@ -14078,6 +15425,22 @@ pub fn serialize_eap_message_req_resp<'a>(v: <EapMessageReqRespCombinator as Com
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_eap_message_req_resp_infallible<'a>(v: <EapMessageReqRespCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_message_req_resp().wf(v@),
+        spec_eap_message_req_resp().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_eap_message_req_resp().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_eap_message_req_resp().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_eap_message_req_resp().spec_serialize(v@)),
+{
+    let combinator = eap_message_req_resp();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn eap_message_req_resp_len<'a>(v: <EapMessageReqRespCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_eap_message_req_resp().wf(v@),
@@ -14256,6 +15619,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodySpi4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodySpi4Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NotifyPayloadBodySpi4CombinatorAlias = Mapped<NotifyPayloadBodySpi4Combinator1, NotifyPayloadBodySpi4Mapper>;
 
 
@@ -14316,6 +15683,22 @@ pub fn serialize_notify_payload_body_spi4<'a>(v: <NotifyPayloadBodySpi4Combinato
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_notify_payload_body_spi4_infallible<'a>(v: <NotifyPayloadBodySpi4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_notify_payload_body_spi4().wf(v@),
+        spec_notify_payload_body_spi4().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_notify_payload_body_spi4().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_notify_payload_body_spi4().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_notify_payload_body_spi4().spec_serialize(v@)),
+{
+    let combinator = notify_payload_body_spi4();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn notify_payload_body_spi4_len<'a>(v: <NotifyPayloadBodySpi4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_notify_payload_body_spi4().wf(v@),
@@ -14484,6 +15867,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodyRestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodyRestCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NotifyPayloadBodyRestCombinatorAlias = AndThen<bytes::Variable, Mapped<NotifyPayloadBodyRestCombinator1, NotifyPayloadBodyRestMapper>>;
 
 
@@ -14545,6 +15932,24 @@ pub fn serialize_notify_payload_body_rest<'a>(v: <NotifyPayloadBodyRestCombinato
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_notify_payload_body_rest_infallible<'a>(v: <NotifyPayloadBodyRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16, spi_size: IpsecSpiSizeOrNone) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_notify_payload_body_rest(payload_length@, spi_size@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+        spec_ipsec_spi_size_or_none().wf(spi_size@),
+        spec_notify_payload_body_rest(payload_length@, spi_size@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_notify_payload_body_rest(payload_length@, spi_size@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_notify_payload_body_rest(payload_length@, spi_size@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_notify_payload_body_rest(payload_length@, spi_size@).spec_serialize(v@)),
+{
+    let combinator = notify_payload_body_rest( payload_length, spi_size );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn notify_payload_body_rest_len<'a>(v: <NotifyPayloadBodyRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16, spi_size: IpsecSpiSizeOrNone) -> (serialize_len: usize)
     requires
         spec_notify_payload_body_rest(payload_length@, spi_size@).wf(v@),
@@ -14693,6 +16098,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NotifyPayloadBodyCombinatorAlias = Mapped<Pair<Pair<NotifyProtocolIdCombinator, IpsecSpiSizeOrNoneCombinator, NotifyPayloadBodyCont1>, (NotifyMsgTypeCombinator, NotifyPayloadBodyRestCombinator), NotifyPayloadBodyCont0>, NotifyPayloadBodyMapper>;
 
 
@@ -14789,6 +16198,23 @@ pub fn serialize_notify_payload_body<'a>(v: <NotifyPayloadBodyCombinator as Comb
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_notify_payload_body_infallible<'a>(v: <NotifyPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_notify_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+        spec_notify_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_notify_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_notify_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_notify_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = notify_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn notify_payload_body_len<'a>(v: <NotifyPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_notify_payload_body(payload_length@).wf(v@),
@@ -15013,6 +16439,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CertPayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CertPayloadBodyCombinatorAlias = Mapped<CertPayloadBodyCombinator1, CertPayloadBodyMapper>;
 
 
@@ -15079,6 +16509,23 @@ pub fn serialize_cert_payload_body<'a>(v: <CertPayloadBodyCombinator as Combinat
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_cert_payload_body_infallible<'a>(v: <CertPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cert_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 5 && (payload_length) <= 65535),
+        spec_cert_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_cert_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_cert_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_cert_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = cert_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn cert_payload_body_len<'a>(v: <CertPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_cert_payload_body(payload_length@).wf(v@),
@@ -15230,6 +16677,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsPayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TsPayloadBodyCombinatorAlias = Mapped<Pair<Refined<U8, Predicate3651688686135228051>, (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, AndThen<bytes::Variable, RepeatN<TrafficSelectorCombinator>>), TsPayloadBodyCont0>, TsPayloadBodyMapper>;
 
 
@@ -15311,6 +16762,23 @@ pub fn serialize_ts_payload_body<'a>(v: <TsPayloadBodyCombinator as Combinator<'
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_ts_payload_body_infallible<'a>(v: <TsPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+        spec_ts_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ts_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ts_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ts_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = ts_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ts_payload_body_len<'a>(v: <TsPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_ts_payload_body(payload_length@).wf(v@),
@@ -15486,6 +16954,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for VendorIdPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for VendorIdPayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type VendorIdPayloadBodyCombinatorAlias = Mapped<bytes::Variable, VendorIdPayloadBodyMapper>;
 
 
@@ -15552,6 +17024,23 @@ pub fn serialize_vendor_id_payload_body<'a>(v: <VendorIdPayloadBodyCombinator as
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_vendor_id_payload_body_infallible<'a>(v: <VendorIdPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_vendor_id_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+        spec_vendor_id_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_vendor_id_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_vendor_id_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_vendor_id_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = vendor_id_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn vendor_id_payload_body_len<'a>(v: <VendorIdPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_vendor_id_payload_body(payload_length@).wf(v@),
@@ -15725,6 +17214,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PayloadCriticalCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PayloadCriticalCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type PayloadCriticalCombinatorAlias = TryMap<U8, PayloadCriticalMapper>;
 
 
@@ -15777,6 +17270,22 @@ pub fn serialize_payload_critical<'a>(v: <PayloadCriticalCombinator as Combinato
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_payload_critical_infallible<'a>(v: <PayloadCriticalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_payload_critical().wf(v@),
+        spec_payload_critical().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_payload_critical().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_payload_critical().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_payload_critical().spec_serialize(v@)),
+{
+    let combinator = payload_critical();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn payload_critical_len<'a>(v: <PayloadCriticalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_payload_critical().wf(v@),
@@ -15945,6 +17454,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadBodySpisCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DeletePayloadBodySpisCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type DeletePayloadBodySpisCombinatorAlias = Mapped<DeletePayloadBodySpisCombinator1, DeletePayloadBodySpisMapper>;
 
 
@@ -16003,6 +17516,23 @@ pub fn serialize_delete_payload_body_spis<'a>(v: <DeletePayloadBodySpisCombinato
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_delete_payload_body_spis_infallible<'a>(v: <DeletePayloadBodySpisCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num_spis: u16, spi_size: IpsecSpiSizeOrNone) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_delete_payload_body_spis(num_spis@, spi_size@).wf(v@),
+        spec_ipsec_spi_size_or_none().wf(spi_size@),
+        spec_delete_payload_body_spis(num_spis@, spi_size@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_delete_payload_body_spis(num_spis@, spi_size@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_delete_payload_body_spis(num_spis@, spi_size@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_delete_payload_body_spis(num_spis@, spi_size@).spec_serialize(v@)),
+{
+    let combinator = delete_payload_body_spis( num_spis, spi_size );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn delete_payload_body_spis_len<'a>(v: <DeletePayloadBodySpisCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, num_spis: u16, spi_size: IpsecSpiSizeOrNone) -> (serialize_len: usize)
     requires
         spec_delete_payload_body_spis(num_spis@, spi_size@).wf(v@),
@@ -16150,6 +17680,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DeletePayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type DeletePayloadBodyCombinatorAlias = Mapped<Pair<Pair<Pair<IkeProtocolIdCombinator, IpsecSpiSizeOrNoneCombinator, DeletePayloadBodyCont2>, U16Be, DeletePayloadBodyCont1>, DeletePayloadBodySpisCombinator, DeletePayloadBodyCont0>, DeletePayloadBodyMapper>;
 
 
@@ -16255,6 +17789,22 @@ pub fn serialize_delete_payload_body<'a>(v: <DeletePayloadBodyCombinator as Comb
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_delete_payload_body_infallible<'a>(v: <DeletePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_delete_payload_body().wf(v@),
+        spec_delete_payload_body().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_delete_payload_body().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_delete_payload_body().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_delete_payload_body().spec_serialize(v@)),
+{
+    let combinator = delete_payload_body();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn delete_payload_body_len<'a>(v: <DeletePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_delete_payload_body().wf(v@),
@@ -16494,6 +18044,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeMessageCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IkeMessageCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type IkeMessageCombinatorAlias = Mapped<Pair<IkeHeaderCombinator, bytes::Variable, IkeMessageCont0>, IkeMessageMapper>;
 
 
@@ -16569,6 +18123,22 @@ pub fn serialize_ike_message<'a>(v: <IkeMessageCombinator as Combinator<'a, &'a
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ike_message_infallible<'a>(v: <IkeMessageCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ike_message().wf(v@),
+        spec_ike_message().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ike_message().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ike_message().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ike_message().spec_serialize(v@)),
+{
+    let combinator = ike_message();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ike_message_len<'a>(v: <IkeMessageCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ike_message().wf(v@),
@@ -16757,6 +18327,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GenericPayloadHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for GenericPayloadHeaderCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type GenericPayloadHeaderCombinatorAlias = Mapped<GenericPayloadHeaderCombinator2, GenericPayloadHeaderMapper>;
 
 
@@ -16817,6 +18391,22 @@ pub fn serialize_generic_payload_header<'a>(v: <GenericPayloadHeaderCombinator a
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_generic_payload_header_infallible<'a>(v: <GenericPayloadHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_generic_payload_header().wf(v@),
+        spec_generic_payload_header().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_generic_payload_header().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_generic_payload_header().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_generic_payload_header().spec_serialize(v@)),
+{
+    let combinator = generic_payload_header();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn generic_payload_header_len<'a>(v: <GenericPayloadHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_generic_payload_header().wf(v@),
@@ -16954,6 +18544,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2SkPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2SkPayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2SkPayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2SkPayloadInnerMapper>;
 
 
@@ -17014,6 +18608,22 @@ pub fn serialize_ikev2_sk_payload_inner<'a>(v: <Ikev2SkPayloadInnerCombinator as
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_sk_payload_inner_infallible<'a>(v: <Ikev2SkPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_sk_payload_inner().wf(v@),
+        spec_ikev2_sk_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_sk_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_sk_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_sk_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_sk_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_sk_payload_inner_len<'a>(v: <Ikev2SkPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_sk_payload_inner().wf(v@),
@@ -17223,6 +18833,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsIpv4Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TsIpv4CombinatorAlias = Mapped<TsIpv4Combinator6, TsIpv4Mapper>;
 
 
@@ -17283,6 +18897,22 @@ pub fn serialize_ts_ipv4<'a>(v: <TsIpv4Combinator as Combinator<'a, &'a [u8], Ve
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ts_ipv4_infallible<'a>(v: <TsIpv4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_ipv4().wf(v@),
+        spec_ts_ipv4().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ts_ipv4().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ts_ipv4().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ts_ipv4().spec_serialize(v@)),
+{
+    let combinator = ts_ipv4();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ts_ipv4_len<'a>(v: <TsIpv4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ts_ipv4().wf(v@),
@@ -17449,6 +19079,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2CpPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2CpPayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2CpPayloadInnerCombinatorAlias = Mapped<Ikev2CpPayloadInnerCombinator2, Ikev2CpPayloadInnerMapper>;
 
 
@@ -17509,6 +19143,22 @@ pub fn serialize_ikev2_cp_payload_inner<'a>(v: <Ikev2CpPayloadInnerCombinator as
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_cp_payload_inner_infallible<'a>(v: <Ikev2CpPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_cp_payload_inner().wf(v@),
+        spec_ikev2_cp_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_cp_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_cp_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_cp_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_cp_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_cp_payload_inner_len<'a>(v: <Ikev2CpPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_cp_payload_inner().wf(v@),
@@ -17669,6 +19319,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2KePayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2KePayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2KePayloadInnerCombinatorAlias = Mapped<Ikev2KePayloadInnerCombinator2, Ikev2KePayloadInnerMapper>;
 
 
@@ -17729,6 +19383,22 @@ pub fn serialize_ikev2_ke_payload_inner<'a>(v: <Ikev2KePayloadInnerCombinator as
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_ke_payload_inner_infallible<'a>(v: <Ikev2KePayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_ke_payload_inner().wf(v@),
+        spec_ikev2_ke_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_ke_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_ke_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_ke_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_ke_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_ke_payload_inner_len<'a>(v: <Ikev2KePayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_ke_payload_inner().wf(v@),
@@ -17895,6 +19565,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AuthPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AuthPayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type AuthPayloadBodyCombinatorAlias = Mapped<AuthPayloadBodyCombinator2, AuthPayloadBodyMapper>;
 
 
@@ -17961,6 +19635,23 @@ pub fn serialize_auth_payload_body<'a>(v: <AuthPayloadBodyCombinator as Combinat
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_auth_payload_body_infallible<'a>(v: <AuthPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_auth_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+        spec_auth_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_auth_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_auth_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_auth_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = auth_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn auth_payload_body_len<'a>(v: <AuthPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_auth_payload_body(payload_length@).wf(v@),
@@ -18128,6 +19819,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IdPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IdPayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type IdPayloadBodyCombinatorAlias = Mapped<IdPayloadBodyCombinator2, IdPayloadBodyMapper>;
 
 
@@ -18194,6 +19889,23 @@ pub fn serialize_id_payload_body<'a>(v: <IdPayloadBodyCombinator as Combinator<'
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_id_payload_body_infallible<'a>(v: <IdPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_id_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+        spec_id_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_id_payload_body(payload_length@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_id_payload_body(payload_length@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_id_payload_body(payload_length@).spec_serialize(v@)),
+{
+    let combinator = id_payload_body( payload_length );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn id_payload_body_len<'a>(v: <IdPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, payload_length: u16) -> (serialize_len: usize)
     requires
         spec_id_payload_body(payload_length@).wf(v@),
@@ -18342,6 +20054,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2CertreqPayloadInnerCombinato
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2CertreqPayloadInnerCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2CertreqPayloadInnerCombinatorAlias = Mapped<Ikev2CertreqPayloadInnerCombinator1, Ikev2CertreqPayloadInnerMapper>;
 
 
@@ -18402,6 +20118,22 @@ pub fn serialize_ikev2_certreq_payload_inner<'a>(v: <Ikev2CertreqPayloadInnerCom
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_ikev2_certreq_payload_inner_infallible<'a>(v: <Ikev2CertreqPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_certreq_payload_inner().wf(v@),
+        spec_ikev2_certreq_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_certreq_payload_inner().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_certreq_payload_inner().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_certreq_payload_inner().spec_serialize(v@)),
+{
+    let combinator = ikev2_certreq_payload_inner();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_certreq_payload_inner_len<'a>(v: <Ikev2CertreqPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_ikev2_certreq_payload_inner().wf(v@),
@@ -18810,6 +20542,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2PayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2PayloadBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2PayloadBodyCombinatorAlias = Mapped<Ikev2PayloadBodyCombinator16, Ikev2PayloadBodyMapper>;
 
 
@@ -18868,6 +20604,23 @@ pub fn serialize_ikev2_payload_body<'a>(v: <Ikev2PayloadBodyCombinator as Combin
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_ikev2_payload_body_infallible<'a>(v: <Ikev2PayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, next_pt: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_payload_body(next_pt@).wf(v@),
+        spec_next_payload_type().wf(next_pt@),
+        spec_ikev2_payload_body(next_pt@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_payload_body(next_pt@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_payload_body(next_pt@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_payload_body(next_pt@).spec_serialize(v@)),
+{
+    let combinator = ikev2_payload_body( next_pt );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_payload_body_len<'a>(v: <Ikev2PayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, next_pt: u8) -> (serialize_len: usize)
     requires
         spec_ikev2_payload_body(next_pt@).wf(v@),
@@ -19009,6 +20762,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2PayloadCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2PayloadCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Ikev2PayloadCombinatorAlias = Mapped<Pair<GenericPayloadHeaderCombinator, AndThen<bytes::Variable, Ikev2PayloadBodyCombinator>, Ikev2PayloadCont0>, Ikev2PayloadMapper>;
 
 
@@ -19090,6 +20847,23 @@ pub fn serialize_ikev2_payload<'a>(v: <Ikev2PayloadCombinator as Combinator<'a,
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_ikev2_payload_infallible<'a>(v: <Ikev2PayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, next_pt: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_payload(next_pt@).wf(v@),
+        spec_next_payload_type().wf(next_pt@),
+        spec_ikev2_payload(next_pt@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_ikev2_payload(next_pt@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_ikev2_payload(next_pt@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_ikev2_payload(next_pt@).spec_serialize(v@)),
+{
+    let combinator = ikev2_payload( next_pt );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn ikev2_payload_len<'a>(v: <Ikev2PayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, next_pt: u8) -> (serialize_len: usize)
     requires
         spec_ikev2_payload(next_pt@).wf(v@),
diff --git a/vest-dsl/test/src/josh.rs b/vest-dsl/test/src/josh.rs
index e6df3368..b2cdfba2 100644
--- a/vest-dsl/test/src/josh.rs
+++ b/vest-dsl/test/src/josh.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -150,6 +156,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TstTagCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TstTagCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TstTagCombinatorAlias = U8;
 
 
@@ -202,6 +212,22 @@ pub fn serialize_tst_tag<'a>(v: <TstTagCombinator as Combinator<'a, &'a [u8], Ve
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_tst_tag_infallible<'a>(v: <TstTagCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_tst_tag().wf(v@),
+        spec_tst_tag().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_tst_tag().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_tst_tag().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_tst_tag().spec_serialize(v@)),
+{
+    let combinator = tst_tag();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn tst_tag_len<'a>(v: <TstTagCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_tst_tag().wf(v@),
@@ -349,6 +375,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MydataCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MydataCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MydataCombinatorAlias = Mapped<MydataCombinator1, MydataMapper>;
 
 
@@ -409,6 +439,22 @@ pub fn serialize_mydata<'a>(v: <MydataCombinator as Combinator<'a, &'a [u8], Vec
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_mydata_infallible<'a>(v: <MydataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_mydata().wf(v@),
+        spec_mydata().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_mydata().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_mydata().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_mydata().spec_serialize(v@)),
+{
+    let combinator = mydata();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn mydata_len<'a>(v: <MydataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_mydata().wf(v@),
@@ -1041,6 +1087,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TstMydataCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TstMydataCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TstMydataCombinatorAlias = Mapped<TstMydataCombinator30, TstMydataMapper>;
 
 
@@ -1099,6 +1149,23 @@ pub fn serialize_tst_mydata<'a>(v: <TstMydataCombinator as Combinator<'a, &'a [u
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_tst_mydata_infallible<'a>(v: <TstMydataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, tag: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_tst_mydata(tag@).wf(v@),
+        spec_tst_tag().wf(tag@),
+        spec_tst_mydata(tag@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_tst_mydata(tag@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_tst_mydata(tag@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_tst_mydata(tag@).spec_serialize(v@)),
+{
+    let combinator = tst_mydata( tag );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn tst_mydata_len<'a>(v: <TstMydataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, tag: u8) -> (serialize_len: usize)
     requires
         spec_tst_mydata(tag@).wf(v@),
@@ -1240,6 +1307,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TstCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TstCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type TstCombinatorAlias = Mapped<Pair<TstTagCombinator, TstMydataCombinator, TstCont0>, TstMapper>;
 
 
@@ -1315,6 +1386,22 @@ pub fn serialize_tst<'a>(v: <TstCombinator as Combinator<'a, &'a [u8], Vec<u8>>>
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_tst_infallible<'a>(v: <TstCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_tst().wf(v@),
+        spec_tst().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_tst().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_tst().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_tst().spec_serialize(v@)),
+{
+    let combinator = tst();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn tst_len<'a>(v: <TstCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_tst().wf(v@),
@@ -1649,6 +1736,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PairStressCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PairStressCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type PairStressCombinatorAlias = Mapped<PairStressCombinator14, PairStressMapper>;
 
 
@@ -1709,6 +1800,22 @@ pub fn serialize_pair_stress<'a>(v: <PairStressCombinator as Combinator<'a, &'a
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_pair_stress_infallible<'a>(v: <PairStressCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_pair_stress().wf(v@),
+        spec_pair_stress().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_pair_stress().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_pair_stress().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_pair_stress().spec_serialize(v@)),
+{
+    let combinator = pair_stress();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn pair_stress_len<'a>(v: <PairStressCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_pair_stress().wf(v@),
diff --git a/vest-dsl/test/src/length_expr.rs b/vest-dsl/test/src/length_expr.rs
index cec8fcbe..f9454f17 100644
--- a/vest-dsl/test/src/length_expr.rs
+++ b/vest-dsl/test/src/length_expr.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -182,6 +188,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for HeaderCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type HeaderCombinatorAlias = Mapped<Pair<Refined<U16Le, Predicate12905524399844557818>, U8, HeaderCont0>, HeaderMapper>;
 
 
@@ -257,6 +267,22 @@ pub fn serialize_header<'a>(v: <HeaderCombinator as Combinator<'a, &'a [u8], Vec
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_header_infallible<'a>(v: <HeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_header().wf(v@),
+        spec_header().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_header().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_header().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_header().spec_serialize(v@)),
+{
+    let combinator = header();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn header_len<'a>(v: <HeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_header().wf(v@),
@@ -354,6 +380,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeaderAliasCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for HeaderAliasCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type HeaderAliasCombinatorAlias = HeaderCombinator;
 
 
@@ -406,6 +436,22 @@ pub fn serialize_header_alias<'a>(v: <HeaderAliasCombinator as Combinator<'a, &'
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_header_alias_infallible<'a>(v: <HeaderAliasCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_header_alias().wf(v@),
+        spec_header_alias().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_header_alias().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_header_alias().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_header_alias().spec_serialize(v@)),
+{
+    let combinator = header_alias();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn header_alias_len<'a>(v: <HeaderAliasCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_header_alias().wf(v@),
@@ -543,6 +589,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DivideCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DivideCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type DivideCombinatorAlias = Mapped<bytes::Variable, DivideMapper>;
 
 
@@ -605,6 +655,22 @@ pub fn serialize_divide<'a>(v: <DivideCombinator as Combinator<'a, &'a [u8], Vec
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_divide_infallible<'a>(v: <DivideCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, total: u32) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_divide(total@).wf(v@),
+        spec_divide(total@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_divide(total@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_divide(total@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_divide(total@).spec_serialize(v@)),
+{
+    let combinator = divide( total );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn divide_len<'a>(v: <DivideCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, total: u32) -> (serialize_len: usize)
     requires
         spec_divide(total@).wf(v@),
@@ -773,6 +839,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FixedChoiceCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for FixedChoiceCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type FixedChoiceCombinatorAlias = Mapped<FixedChoiceCombinator1, FixedChoiceMapper>;
 
 
@@ -827,6 +897,22 @@ pub fn serialize_fixed_choice<'a>(v: <FixedChoiceCombinator as Combinator<'a, &'
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_fixed_choice_infallible<'a>(v: <FixedChoiceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, tag: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_fixed_choice(tag@).wf(v@),
+        spec_fixed_choice(tag@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_fixed_choice(tag@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_fixed_choice(tag@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_fixed_choice(tag@).spec_serialize(v@)),
+{
+    let combinator = fixed_choice( tag );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn fixed_choice_len<'a>(v: <FixedChoiceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, tag: u8) -> (serialize_len: usize)
     requires
         spec_fixed_choice(tag@).wf(v@),
@@ -964,6 +1050,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SimpleSubCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for SimpleSubCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type SimpleSubCombinatorAlias = Mapped<bytes::Variable, SimpleSubMapper>;
 
 
@@ -1030,6 +1120,23 @@ pub fn serialize_simple_sub<'a>(v: <SimpleSubCombinator as Combinator<'a, &'a [u
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_simple_sub_infallible<'a>(v: <SimpleSubCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, len: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_simple_sub(len@).wf(v@),
+        ((len) >= 4 && (len) <= 65535),
+        spec_simple_sub(len@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_simple_sub(len@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_simple_sub(len@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_simple_sub(len@).spec_serialize(v@)),
+{
+    let combinator = simple_sub( len );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn simple_sub_len<'a>(v: <SimpleSubCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, len: u16) -> (serialize_len: usize)
     requires
         spec_simple_sub(len@).wf(v@),
@@ -1168,6 +1275,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AliasSizeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AliasSizeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type AliasSizeCombinatorAlias = Mapped<bytes::Fixed<3>, AliasSizeMapper>;
 
 
@@ -1228,6 +1339,22 @@ pub fn serialize_alias_size<'a>(v: <AliasSizeCombinator as Combinator<'a, &'a [u
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_alias_size_infallible<'a>(v: <AliasSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_alias_size().wf(v@),
+        spec_alias_size().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_alias_size().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_alias_size().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_alias_size().spec_serialize(v@)),
+{
+    let combinator = alias_size();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn alias_size_len<'a>(v: <AliasSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_alias_size().wf(v@),
@@ -1365,6 +1492,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MultiArithCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MultiArithCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MultiArithCombinatorAlias = Mapped<bytes::Variable, MultiArithMapper>;
 
 
@@ -1434,6 +1565,24 @@ pub fn serialize_multi_arith<'a>(v: <MultiArithCombinator as Combinator<'a, &'a
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_multi_arith_infallible<'a>(v: <MultiArithCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, total: u32, hdr_len: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_multi_arith(total@, hdr_len@).wf(v@),
+        ((total) >= 263 && (total) <= 4294967295),
+        ((hdr_len) >= 0 && (hdr_len) <= 255),
+        spec_multi_arith(total@, hdr_len@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_multi_arith(total@, hdr_len@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_multi_arith(total@, hdr_len@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_multi_arith(total@, hdr_len@).spec_serialize(v@)),
+{
+    let combinator = multi_arith( total, hdr_len );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn multi_arith_len<'a>(v: <MultiArithCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, total: u32, hdr_len: u8) -> (serialize_len: usize)
     requires
         spec_multi_arith(total@, hdr_len@).wf(v@),
@@ -1573,6 +1722,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SizeArithCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for SizeArithCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type SizeArithCombinatorAlias = Mapped<bytes::Fixed<4>, SizeArithMapper>;
 
 
@@ -1633,6 +1786,22 @@ pub fn serialize_size_arith<'a>(v: <SizeArithCombinator as Combinator<'a, &'a [u
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_size_arith_infallible<'a>(v: <SizeArithCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_size_arith().wf(v@),
+        spec_size_arith().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_size_arith().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_size_arith().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_size_arith().spec_serialize(v@)),
+{
+    let combinator = size_arith();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn size_arith_len<'a>(v: <SizeArithCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_size_arith().wf(v@),
@@ -1770,6 +1939,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PayloadWithHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PayloadWithHeaderCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type PayloadWithHeaderCombinatorAlias = Mapped<bytes::Variable, PayloadWithHeaderMapper>;
 
 
@@ -1836,6 +2009,23 @@ pub fn serialize_payload_with_header<'a>(v: <PayloadWithHeaderCombinator as Comb
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_payload_with_header_infallible<'a>(v: <PayloadWithHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, hdr: Header) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_payload_with_header(hdr@).wf(v@),
+        spec_header().wf(hdr@),
+        spec_payload_with_header(hdr@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_payload_with_header(hdr@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_payload_with_header(hdr@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_payload_with_header(hdr@).spec_serialize(v@)),
+{
+    let combinator = payload_with_header( hdr );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn payload_with_header_len<'a>(v: <PayloadWithHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, hdr: Header) -> (serialize_len: usize)
     requires
         spec_payload_with_header(hdr@).wf(v@),
@@ -1974,6 +2164,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MixedConstCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MixedConstCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MixedConstCombinatorAlias = Mapped<bytes::Variable, MixedConstMapper>;
 
 
@@ -2040,6 +2234,23 @@ pub fn serialize_mixed_const<'a>(v: <MixedConstCombinator as Combinator<'a, &'a
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_mixed_const_infallible<'a>(v: <MixedConstCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, len: u16) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_mixed_const(len@).wf(v@),
+        ((len) >= 4 && (len) <= 65535),
+        spec_mixed_const(len@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_mixed_const(len@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_mixed_const(len@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_mixed_const(len@).spec_serialize(v@)),
+{
+    let combinator = mixed_const( len );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn mixed_const_len<'a>(v: <MixedConstCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, len: u16) -> (serialize_len: usize)
     requires
         spec_mixed_const(len@).wf(v@),
@@ -2107,6 +2318,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceTagCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ChoiceTagCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ChoiceTagCombinatorAlias = bytes::Fixed<2>;
 
 
@@ -2159,6 +2374,22 @@ pub fn serialize_choice_tag<'a>(v: <ChoiceTagCombinator as Combinator<'a, &'a [u
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_choice_tag_infallible<'a>(v: <ChoiceTagCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_choice_tag().wf(v@),
+        spec_choice_tag().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_choice_tag().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_choice_tag().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_choice_tag().spec_serialize(v@)),
+{
+    let combinator = choice_tag();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn choice_tag_len<'a>(v: <ChoiceTagCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_choice_tag().wf(v@),
@@ -2296,6 +2527,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NamedSizeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NamedSizeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type NamedSizeCombinatorAlias = Mapped<bytes::Fixed<3>, NamedSizeMapper>;
 
 
@@ -2356,6 +2591,22 @@ pub fn serialize_named_size<'a>(v: <NamedSizeCombinator as Combinator<'a, &'a [u
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_named_size_infallible<'a>(v: <NamedSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_named_size().wf(v@),
+        spec_named_size().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_named_size().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_named_size().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_named_size().spec_serialize(v@)),
+{
+    let combinator = named_size();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn named_size_len<'a>(v: <NamedSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_named_size().wf(v@),
@@ -2493,6 +2744,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceFormatSizeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ChoiceFormatSizeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ChoiceFormatSizeCombinatorAlias = Mapped<bytes::Fixed<2>, ChoiceFormatSizeMapper>;
 
 
@@ -2553,6 +2808,22 @@ pub fn serialize_choice_format_size<'a>(v: <ChoiceFormatSizeCombinator as Combin
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_choice_format_size_infallible<'a>(v: <ChoiceFormatSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_choice_format_size().wf(v@),
+        spec_choice_format_size().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_choice_format_size().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_choice_format_size().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_choice_format_size().spec_serialize(v@)),
+{
+    let combinator = choice_format_size();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn choice_format_size_len<'a>(v: <ChoiceFormatSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_choice_format_size().wf(v@),
@@ -2619,6 +2890,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeaderBytesCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for HeaderBytesCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type HeaderBytesCombinatorAlias = AndThen<bytes::Variable, HeaderCombinator>;
 
 
@@ -2671,6 +2946,22 @@ pub fn serialize_header_bytes<'a>(v: <HeaderBytesCombinator as Combinator<'a, &'
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_header_bytes_infallible<'a>(v: <HeaderBytesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_header_bytes().wf(v@),
+        spec_header_bytes().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_header_bytes().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_header_bytes().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_header_bytes().spec_serialize(v@)),
+{
+    let combinator = header_bytes();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn header_bytes_len<'a>(v: <HeaderBytesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_header_bytes().wf(v@),
@@ -2808,6 +3099,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MultiplyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MultiplyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MultiplyCombinatorAlias = Mapped<bytes::Variable, MultiplyMapper>;
 
 
@@ -2874,6 +3169,23 @@ pub fn serialize_multiply<'a>(v: <MultiplyCombinator as Combinator<'a, &'a [u8],
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_multiply_infallible<'a>(v: <MultiplyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, count: u16, size: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_multiply(count@, size@).wf(v@),
+        ((size) == 1),
+        spec_multiply(count@, size@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_multiply(count@, size@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_multiply(count@, size@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_multiply(count@, size@).spec_serialize(v@)),
+{
+    let combinator = multiply( count, size );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn multiply_len<'a>(v: <MultiplyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, count: u16, size: u8) -> (serialize_len: usize)
     requires
         spec_multiply(count@, size@).wf(v@),
@@ -3043,6 +3355,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceArraysFoldedBodyCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ChoiceArraysFoldedBodyCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ChoiceArraysFoldedBodyCombinatorAlias = Mapped<ChoiceArraysFoldedBodyCombinator1, ChoiceArraysFoldedBodyMapper>;
 
 
@@ -3097,6 +3413,22 @@ pub fn serialize_choice_arrays_folded_body<'a>(v: <ChoiceArraysFoldedBodyCombina
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_choice_arrays_folded_body_infallible<'a>(v: <ChoiceArraysFoldedBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, tag: ChoiceTag) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_choice_arrays_folded_body(tag@).wf(v@),
+        spec_choice_arrays_folded_body(tag@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_choice_arrays_folded_body(tag@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_choice_arrays_folded_body(tag@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_choice_arrays_folded_body(tag@).spec_serialize(v@)),
+{
+    let combinator = choice_arrays_folded_body( tag );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn choice_arrays_folded_body_len<'a>(v: <ChoiceArraysFoldedBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, tag: ChoiceTag) -> (serialize_len: usize)
     requires
         spec_choice_arrays_folded_body(tag@).wf(v@),
@@ -3237,6 +3569,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceArraysFoldedCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ChoiceArraysFoldedCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ChoiceArraysFoldedCombinatorAlias = Mapped<Pair<ChoiceTagCombinator, ChoiceArraysFoldedBodyCombinator, ChoiceArraysFoldedCont0>, ChoiceArraysFoldedMapper>;
 
 
@@ -3312,6 +3648,22 @@ pub fn serialize_choice_arrays_folded<'a>(v: <ChoiceArraysFoldedCombinator as Co
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_choice_arrays_folded_infallible<'a>(v: <ChoiceArraysFoldedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_choice_arrays_folded().wf(v@),
+        spec_choice_arrays_folded().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_choice_arrays_folded().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_choice_arrays_folded().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_choice_arrays_folded().spec_serialize(v@)),
+{
+    let combinator = choice_arrays_folded();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn choice_arrays_folded_len<'a>(v: <ChoiceArraysFoldedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_choice_arrays_folded().wf(v@),
@@ -3480,6 +3832,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParenExprCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ParenExprCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ParenExprCombinatorAlias = Mapped<bytes::Variable, ParenExprMapper>;
 
 
@@ -3552,6 +3908,25 @@ pub fn serialize_paren_expr<'a>(v: <ParenExprCombinator as Combinator<'a, &'a [u
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_paren_expr_infallible<'a>(v: <ParenExprCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, a: u16, b: u8, c: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_paren_expr(a@, b@, c@).wf(v@),
+        ((a) >= 255 && (a) <= 65535),
+        ((b) >= 0 && (b) <= 255),
+        ((c) == 1),
+        spec_paren_expr(a@, b@, c@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_paren_expr(a@, b@, c@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_paren_expr(a@, b@, c@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_paren_expr(a@, b@, c@).spec_serialize(v@)),
+{
+    let combinator = paren_expr( a, b, c );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn paren_expr_len<'a>(v: <ParenExprCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, a: u16, b: u8, c: u8) -> (serialize_len: usize)
     requires
         spec_paren_expr(a@, b@, c@).wf(v@),
@@ -3692,6 +4067,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ReinterpretSizeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ReinterpretSizeCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ReinterpretSizeCombinatorAlias = Mapped<bytes::Fixed<3>, ReinterpretSizeMapper>;
 
 
@@ -3752,6 +4131,22 @@ pub fn serialize_reinterpret_size<'a>(v: <ReinterpretSizeCombinator as Combinato
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_reinterpret_size_infallible<'a>(v: <ReinterpretSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_reinterpret_size().wf(v@),
+        spec_reinterpret_size().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_reinterpret_size().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_reinterpret_size().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_reinterpret_size().spec_serialize(v@)),
+{
+    let combinator = reinterpret_size();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn reinterpret_size_len<'a>(v: <ReinterpretSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_reinterpret_size().wf(v@),
@@ -3899,6 +4294,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PrimitiveSizesCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PrimitiveSizesCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type PrimitiveSizesCombinatorAlias = Mapped<PrimitiveSizesCombinator1, PrimitiveSizesMapper>;
 
 
@@ -3959,6 +4358,22 @@ pub fn serialize_primitive_sizes<'a>(v: <PrimitiveSizesCombinator as Combinator<
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_primitive_sizes_infallible<'a>(v: <PrimitiveSizesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_primitive_sizes().wf(v@),
+        spec_primitive_sizes().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_primitive_sizes().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_primitive_sizes().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_primitive_sizes().spec_serialize(v@)),
+{
+    let combinator = primitive_sizes();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn primitive_sizes_len<'a>(v: <PrimitiveSizesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_primitive_sizes().wf(v@),
diff --git a/vest-dsl/test/src/matches.rs b/vest-dsl/test/src/matches.rs
index 97552dcb..222572af 100644
--- a/vest-dsl/test/src/matches.rs
+++ b/vest-dsl/test/src/matches.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -190,6 +196,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg5ContentCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg5ContentCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg5ContentCombinatorAlias = Mapped<Msg5ContentCombinator1, Msg5ContentMapper>;
 
 
@@ -244,6 +254,22 @@ pub fn serialize_msg5_content<'a>(v: <Msg5ContentCombinator as Combinator<'a, &'
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_msg5_content_infallible<'a>(v: <Msg5ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, i: VarInt) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg5_content(i@).wf(v@),
+        spec_msg5_content(i@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg5_content(i@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg5_content(i@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg5_content(i@).spec_serialize(v@)),
+{
+    let combinator = msg5_content( i );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg5_content_len<'a>(v: <Msg5ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, i: VarInt) -> (serialize_len: usize)
     requires
         spec_msg5_content(i@).wf(v@),
@@ -310,6 +336,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HelloRetryRequestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for HelloRetryRequestCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type HelloRetryRequestCombinatorAlias = U16Le;
 
 
@@ -362,6 +392,22 @@ pub fn serialize_hello_retry_request<'a>(v: <HelloRetryRequestCombinator as Comb
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_hello_retry_request_infallible<'a>(v: <HelloRetryRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_hello_retry_request().wf(v@),
+        spec_hello_retry_request().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_hello_retry_request().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_hello_retry_request().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_hello_retry_request().spec_serialize(v@)),
+{
+    let combinator = hello_retry_request();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn hello_retry_request_len<'a>(v: <HelloRetryRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_hello_retry_request().wf(v@),
@@ -428,6 +474,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerHelloCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ServerHelloCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ServerHelloCombinatorAlias = U32Le;
 
 
@@ -480,6 +530,22 @@ pub fn serialize_server_hello<'a>(v: <ServerHelloCombinator as Combinator<'a, &'
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_server_hello_infallible<'a>(v: <ServerHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_server_hello().wf(v@),
+        spec_server_hello().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_server_hello().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_server_hello().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_server_hello().spec_serialize(v@)),
+{
+    let combinator = server_hello();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn server_hello_len<'a>(v: <ServerHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_server_hello().wf(v@),
@@ -648,6 +714,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg1PayloadCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg1PayloadCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg1PayloadCombinatorAlias = Mapped<Msg1PayloadCombinator1, Msg1PayloadMapper>;
 
 
@@ -702,6 +772,22 @@ pub fn serialize_msg1_payload<'a>(v: <Msg1PayloadCombinator as Combinator<'a, &'
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_msg1_payload_infallible<'a>(v: <Msg1PayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, b: &'a [u8]) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg1_payload(b@).wf(v@),
+        spec_msg1_payload(b@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg1_payload(b@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg1_payload(b@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg1_payload(b@).spec_serialize(v@)),
+{
+    let combinator = msg1_payload( b );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg1_payload_len<'a>(v: <Msg1PayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, b: &'a [u8]) -> (serialize_len: usize)
     requires
         spec_msg1_payload(b@).wf(v@),
@@ -870,6 +956,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg4ContentCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg4ContentCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg4ContentCombinatorAlias = Mapped<Msg4ContentCombinator1, Msg4ContentMapper>;
 
 
@@ -924,6 +1014,22 @@ pub fn serialize_msg4_content<'a>(v: <Msg4ContentCombinator as Combinator<'a, &'
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_msg4_content_infallible<'a>(v: <Msg4ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, i: u24) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg4_content(i@).wf(v@),
+        spec_msg4_content(i@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg4_content(i@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg4_content(i@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg4_content(i@).spec_serialize(v@)),
+{
+    let combinator = msg4_content( i );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg4_content_len<'a>(v: <Msg4ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, i: u24) -> (serialize_len: usize)
     requires
         spec_msg4_content(i@).wf(v@),
@@ -1124,6 +1230,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg3ContentCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg3ContentCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg3ContentCombinatorAlias = Mapped<Msg3ContentCombinator3, Msg3ContentMapper>;
 
 
@@ -1178,6 +1288,22 @@ pub fn serialize_msg3_content<'a>(v: <Msg3ContentCombinator as Combinator<'a, &'
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_msg3_content_infallible<'a>(v: <Msg3ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, i: u8) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg3_content(i@).wf(v@),
+        spec_msg3_content(i@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg3_content(i@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg3_content(i@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg3_content(i@).spec_serialize(v@)),
+{
+    let combinator = msg3_content( i );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg3_content_len<'a>(v: <Msg3ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, i: u8) -> (serialize_len: usize)
     requires
         spec_msg3_content(i@).wf(v@),
@@ -1318,6 +1444,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg3Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg3Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg3CombinatorAlias = Mapped<Pair<U8, Msg3ContentCombinator, Msg3Cont0>, Msg3Mapper>;
 
 
@@ -1393,6 +1523,22 @@ pub fn serialize_msg3<'a>(v: <Msg3Combinator as Combinator<'a, &'a [u8], Vec<u8>
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg3_infallible<'a>(v: <Msg3Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg3().wf(v@),
+        spec_msg3().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg3().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg3().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg3().spec_serialize(v@)),
+{
+    let combinator = msg3();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg3_len<'a>(v: <Msg3Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg3().wf(v@),
@@ -1564,6 +1710,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg5Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg5Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg5CombinatorAlias = Mapped<Pair<BtcVarint, Msg5ContentCombinator, Msg5Cont0>, Msg5Mapper>;
 
 
@@ -1639,6 +1789,22 @@ pub fn serialize_msg5<'a>(v: <Msg5Combinator as Combinator<'a, &'a [u8], Vec<u8>
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg5_infallible<'a>(v: <Msg5Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg5().wf(v@),
+        spec_msg5().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg5().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg5().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg5().spec_serialize(v@)),
+{
+    let combinator = msg5();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg5_len<'a>(v: <Msg5Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg5().wf(v@),
@@ -1838,6 +2004,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg2ContentCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg2ContentCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg2ContentCombinatorAlias = Mapped<Msg2ContentCombinator1, Msg2ContentMapper>;
 
 
@@ -1892,6 +2062,22 @@ pub fn serialize_msg2_content<'a>(v: <Msg2ContentCombinator as Combinator<'a, &'
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_msg2_content_infallible<'a>(v: <Msg2ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, b: &'a [u8]) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg2_content(b@).wf(v@),
+        spec_msg2_content(b@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg2_content(b@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg2_content(b@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg2_content(b@).spec_serialize(v@)),
+{
+    let combinator = msg2_content( b );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg2_content_len<'a>(v: <Msg2ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, b: &'a [u8]) -> (serialize_len: usize)
     requires
         spec_msg2_content(b@).wf(v@),
@@ -2032,6 +2218,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg1Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg1Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg1CombinatorAlias = Mapped<Pair<bytes::Fixed<32>, Msg1PayloadCombinator, Msg1Cont0>, Msg1Mapper>;
 
 
@@ -2107,6 +2297,22 @@ pub fn serialize_msg1<'a>(v: <Msg1Combinator as Combinator<'a, &'a [u8], Vec<u8>
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg1_infallible<'a>(v: <Msg1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg1().wf(v@),
+        spec_msg1().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg1().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg1().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg1().spec_serialize(v@)),
+{
+    let combinator = msg1();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg1_len<'a>(v: <Msg1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg1().wf(v@),
@@ -2278,6 +2484,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg2Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg2Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg2CombinatorAlias = Mapped<Pair<bytes::Fixed<3>, Msg2ContentCombinator, Msg2Cont0>, Msg2Mapper>;
 
 
@@ -2353,6 +2563,22 @@ pub fn serialize_msg2<'a>(v: <Msg2Combinator as Combinator<'a, &'a [u8], Vec<u8>
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg2_infallible<'a>(v: <Msg2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg2().wf(v@),
+        spec_msg2().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg2().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg2().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg2().spec_serialize(v@)),
+{
+    let combinator = msg2();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg2_len<'a>(v: <Msg2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg2().wf(v@),
@@ -2524,6 +2750,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg4Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type Msg4CombinatorAlias = Mapped<Pair<U24Le, Msg4ContentCombinator, Msg4Cont0>, Msg4Mapper>;
 
 
@@ -2599,6 +2829,22 @@ pub fn serialize_msg4<'a>(v: <Msg4Combinator as Combinator<'a, &'a [u8], Vec<u8>
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg4_infallible<'a>(v: <Msg4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg4().wf(v@),
+        spec_msg4().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg4().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg4().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg4().spec_serialize(v@)),
+{
+    let combinator = msg4();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg4_len<'a>(v: <Msg4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg4().wf(v@),
diff --git a/vest-dsl/test/src/nested_access.rs b/vest-dsl/test/src/nested_access.rs
index 97731545..493ef248 100644
--- a/vest-dsl/test/src/nested_access.rs
+++ b/vest-dsl/test/src/nested_access.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -201,6 +207,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GenericHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for GenericHeaderCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type GenericHeaderCombinatorAlias = Mapped<GenericHeaderCombinator2, GenericHeaderMapper>;
 
 
@@ -261,6 +271,22 @@ pub fn serialize_generic_header<'a>(v: <GenericHeaderCombinator as Combinator<'a
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_generic_header_infallible<'a>(v: <GenericHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_generic_header().wf(v@),
+        spec_generic_header().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_generic_header().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_generic_header().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_generic_header().spec_serialize(v@)),
+{
+    let combinator = generic_header();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn generic_header_len<'a>(v: <GenericHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_generic_header().wf(v@),
@@ -408,6 +434,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OuterHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for OuterHeaderCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type OuterHeaderCombinatorAlias = Mapped<OuterHeaderCombinator1, OuterHeaderMapper>;
 
 
@@ -468,6 +498,22 @@ pub fn serialize_outer_header<'a>(v: <OuterHeaderCombinator as Combinator<'a, &'
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_outer_header_infallible<'a>(v: <OuterHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_outer_header().wf(v@),
+        spec_outer_header().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_outer_header().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_outer_header().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_outer_header().spec_serialize(v@)),
+{
+    let combinator = outer_header();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn outer_header_len<'a>(v: <OuterHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_outer_header().wf(v@),
@@ -608,6 +654,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PayloadWithHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PayloadWithHeaderCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type PayloadWithHeaderCombinatorAlias = Mapped<Pair<GenericHeaderCombinator, bytes::Variable, PayloadWithHeaderCont0>, PayloadWithHeaderMapper>;
 
 
@@ -683,6 +733,22 @@ pub fn serialize_payload_with_header<'a>(v: <PayloadWithHeaderCombinator as Comb
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_payload_with_header_infallible<'a>(v: <PayloadWithHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_payload_with_header().wf(v@),
+        spec_payload_with_header().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_payload_with_header().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_payload_with_header().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_payload_with_header().spec_serialize(v@)),
+{
+    let combinator = payload_with_header();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn payload_with_header_len<'a>(v: <PayloadWithHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_payload_with_header().wf(v@),
@@ -852,6 +918,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeepNestedCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DeepNestedCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type DeepNestedCombinatorAlias = Mapped<Pair<OuterHeaderCombinator, bytes::Variable, DeepNestedCont0>, DeepNestedMapper>;
 
 
@@ -927,6 +997,22 @@ pub fn serialize_deep_nested<'a>(v: <DeepNestedCombinator as Combinator<'a, &'a
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_deep_nested_infallible<'a>(v: <DeepNestedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_deep_nested().wf(v@),
+        spec_deep_nested().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_deep_nested().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_deep_nested().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_deep_nested().spec_serialize(v@)),
+{
+    let combinator = deep_nested();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn deep_nested_len<'a>(v: <DeepNestedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_deep_nested().wf(v@),
@@ -1096,6 +1182,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CombinedExampleCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CombinedExampleCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type CombinedExampleCombinatorAlias = Mapped<Pair<GenericHeaderCombinator, bytes::Variable, CombinedExampleCont0>, CombinedExampleMapper>;
 
 
@@ -1177,6 +1267,23 @@ pub fn serialize_combined_example<'a>(v: <CombinedExampleCombinator as Combinato
     combinator.serialize(v, data, pos)
 }
 
+pub fn serialize_combined_example_infallible<'a>(v: <CombinedExampleCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, total_len: u32) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_combined_example(total_len@).wf(v@),
+        ((total_len) >= 65535 && (total_len) <= 4294967295),
+        spec_combined_example(total_len@).spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_combined_example(total_len@).spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_combined_example(total_len@).spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_combined_example(total_len@).spec_serialize(v@)),
+{
+    let combinator = combined_example( total_len );
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn combined_example_len<'a>(v: <CombinedExampleCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, total_len: u32) -> (serialize_len: usize)
     requires
         spec_combined_example(total_len@).wf(v@),
diff --git a/vest-dsl/test/src/opt.rs b/vest-dsl/test/src/opt.rs
index 1b4ed351..e5144a90 100644
--- a/vest-dsl/test/src/opt.rs
+++ b/vest-dsl/test/src/opt.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -95,6 +101,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ACombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ACombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ACombinatorAlias = Terminated<Preceded<Tag<U8, u8>, Preceded<Tag<U8, u8>, bytes::Fixed<10>>>, Tag<U8, u8>>;
 
 
@@ -147,6 +157,22 @@ pub fn serialize_a<'a>(v: <ACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::ST
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_a_infallible<'a>(v: <ACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a().wf(v@),
+        spec_a().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_a().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_a().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_a().spec_serialize(v@)),
+{
+    let combinator = a();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn a_len<'a>(v: <ACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_a().wf(v@),
@@ -304,6 +330,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for BCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for BCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type BCombinatorAlias = Mapped<BCombinator1, BMapper>;
 
 
@@ -364,6 +394,22 @@ pub fn serialize_b<'a>(v: <BCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::ST
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_b_infallible<'a>(v: <BCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_b().wf(v@),
+        spec_b().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_b().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_b().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_b().spec_serialize(v@)),
+{
+    let combinator = b();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn b_len<'a>(v: <BCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_b().wf(v@),
@@ -519,6 +565,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type MsgCombinatorAlias = Mapped<MsgCombinator1, MsgMapper>;
 
 
@@ -579,6 +629,22 @@ pub fn serialize_msg<'a>(v: <MsgCombinator as Combinator<'a, &'a [u8], Vec<u8>>>
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_msg_infallible<'a>(v: <MsgCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_msg().wf(v@),
+        spec_msg().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_msg().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_msg().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_msg().spec_serialize(v@)),
+{
+    let combinator = msg();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn msg_len<'a>(v: <MsgCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_msg().wf(v@),
@@ -645,6 +711,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OptmsgCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for OptmsgCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type OptmsgCombinatorAlias = Opt<MsgCombinator>;
 
 
@@ -697,6 +767,22 @@ pub fn serialize_optmsg<'a>(v: <OptmsgCombinator as Combinator<'a, &'a [u8], Vec
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_optmsg_infallible<'a>(v: <OptmsgCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_optmsg().wf(v@),
+        spec_optmsg().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_optmsg().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_optmsg().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_optmsg().spec_serialize(v@)),
+{
+    let combinator = optmsg();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn optmsg_len<'a>(v: <OptmsgCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_optmsg().wf(v@),
diff --git a/vest-dsl/test/src/repeat.rs b/vest-dsl/test/src/repeat.rs
index cae995fd..92d5e762 100644
--- a/vest-dsl/test/src/repeat.rs
+++ b/vest-dsl/test/src/repeat.rs
@@ -12,6 +12,7 @@ use vest_lib::regular::tag::*;
 use vest_lib::regular::uints::*;
 use vest_lib::utils::*;
 use vest_lib::properties::*;
+use vest_lib::infallible::*;
 use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
 use vest_lib::regular::leb128::*;
 
@@ -30,6 +31,11 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
+
+            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+            }
         } // verus!
     };
 }
@@ -182,6 +188,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OpaqueU16Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for OpaqueU16Combinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type OpaqueU16CombinatorAlias = Mapped<Pair<Refined<U16Le, Predicate17626095872143391426>, bytes::Variable, OpaqueU16Cont0>, OpaqueU16Mapper>;
 
 
@@ -257,6 +267,22 @@ pub fn serialize_opaque_u16<'a>(v: <OpaqueU16Combinator as Combinator<'a, &'a [u
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_opaque_u16_infallible<'a>(v: <OpaqueU16Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_opaque_u16().wf(v@),
+        spec_opaque_u16().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_opaque_u16().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_opaque_u16().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_opaque_u16().spec_serialize(v@)),
+{
+    let combinator = opaque_u16();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn opaque_u16_len<'a>(v: <OpaqueU16Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_opaque_u16().wf(v@),
@@ -354,6 +380,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for RepeatFixCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for RepeatFixCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type RepeatFixCombinatorAlias = RepeatN<U16Le>;
 
 
@@ -406,6 +436,22 @@ pub fn serialize_repeat_fix<'a>(v: <RepeatFixCombinator as Combinator<'a, &'a [u
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_repeat_fix_infallible<'a>(v: <RepeatFixCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_repeat_fix().wf(v@),
+        spec_repeat_fix().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_repeat_fix().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_repeat_fix().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_repeat_fix().spec_serialize(v@)),
+{
+    let combinator = repeat_fix();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn repeat_fix_len<'a>(v: <RepeatFixCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_repeat_fix().wf(v@),
@@ -472,6 +518,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ResponderIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ResponderIdCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ResponderIdCombinatorAlias = OpaqueU16Combinator;
 
 
@@ -524,6 +574,22 @@ pub fn serialize_responder_id<'a>(v: <ResponderIdCombinator as Combinator<'a, &'
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_responder_id_infallible<'a>(v: <ResponderIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_responder_id().wf(v@),
+        spec_responder_id().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_responder_id().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_responder_id().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_responder_id().spec_serialize(v@)),
+{
+    let combinator = responder_id();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn responder_id_len<'a>(v: <ResponderIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_responder_id().wf(v@),
@@ -684,6 +750,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ResponderIdListCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ResponderIdListCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type ResponderIdListCombinatorAlias = Mapped<Pair<Refined<U16Le, Predicate2984462868727922620>, AndThen<bytes::Variable, Repeat<ResponderIdCombinator>>, ResponderIdListCont0>, ResponderIdListMapper>;
 
 
@@ -759,6 +829,22 @@ pub fn serialize_responder_id_list<'a>(v: <ResponderIdListCombinator as Combinat
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_responder_id_list_infallible<'a>(v: <ResponderIdListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_responder_id_list().wf(v@),
+        spec_responder_id_list().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_responder_id_list().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_responder_id_list().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_responder_id_list().spec_serialize(v@)),
+{
+    let combinator = responder_id_list();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn responder_id_list_len<'a>(v: <ResponderIdListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_responder_id_list().wf(v@),
@@ -930,6 +1016,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for RepeatDynCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for RepeatDynCombinator {
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
+}
 pub type RepeatDynCombinatorAlias = Mapped<Pair<BtcVarint, RepeatN<ResponderIdListCombinator>, RepeatDynCont0>, RepeatDynMapper>;
 
 
@@ -1005,6 +1095,22 @@ pub fn serialize_repeat_dyn<'a>(v: <RepeatDynCombinator as Combinator<'a, &'a [u
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
+pub fn serialize_repeat_dyn_infallible<'a>(v: <RepeatDynCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (n: usize)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_repeat_dyn().wf(v@),
+        spec_repeat_dyn().spec_serialize(v@).len() <= usize::MAX,
+        pos + spec_repeat_dyn().spec_serialize(v@).len() <= old(data)@.len(),
+    ensures
+        data@.len() == old(data)@.len(),
+        pos <= usize::MAX - n && pos + n <= data@.len(),
+        n == spec_repeat_dyn().spec_serialize(v@).len(),
+        data@ == seq_splice(old(data)@, pos, spec_repeat_dyn().spec_serialize(v@)),
+{
+    let combinator = repeat_dyn();
+    serialize_infallible(&combinator, v, data, pos)
+}
+
 pub fn repeat_dyn_len<'a>(v: <RepeatDynCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
         spec_repeat_dyn().wf(v@),
diff --git a/vest/Cargo.toml b/vest/Cargo.toml
index 17dc3966..ffe42fc8 100644
--- a/vest/Cargo.toml
+++ b/vest/Cargo.toml
@@ -17,7 +17,7 @@ default = ["std"]
 std = []
 
 [dependencies]
-vstd = "0.0.0-2026-03-17-2326"
+vstd = "=0.0.0-2026-03-17-2326"
 
 #vstd = { git = "https://github.com/verus-lang/verus", branch = "main" }
 #verus_builtin = { git = "https://github.com/verus-lang/verus", branch = "main" }
diff --git a/vest/src/infallible.rs b/vest/src/infallible.rs
new file mode 100644
index 00000000..60391a7d
--- /dev/null
+++ b/vest/src/infallible.rs
@@ -0,0 +1,750 @@
+use crate::properties::*;
+use crate::regular::bytes::{Fixed, Tail, Variable};
+use crate::regular::end::End;
+use crate::regular::modifier::{
+    AndThen, Cond, Iso, IsoFn, Mapped, PartialIso, PartialIsoFn, Pred, Refined, SpecIsoProof,
+    SpecPartialIsoProof, SpecPred, TryMap,
+};
+use crate::regular::sequence::{Continuation, GhostFn, POrSType, Pair, Preceded, Terminated};
+use crate::regular::success::Success;
+use crate::regular::uints::*;
+use crate::regular::variant::{Choice, Either};
+use crate::bitcoin::varint::BtcVarint;
+
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use crate::regular::disjoint::DisjointFrom;
+use core::mem::size_of;
+use vstd::prelude::*;
+
+verus! {
+
+/// A combinator whose serialization is guaranteed to succeed when the buffer
+/// has sufficient space.
+///
+/// This trait extends [`Combinator`] with a stronger serialization contract:
+/// when `serialize` returns `Err`, it is guaranteed that the buffer was too
+/// small. Combined with the existing `Ok` ensures, this means that if you
+/// pre-allocate a buffer of the right size (via [`Combinator::length`]),
+/// serialization is infallible.
+///
+/// ## Usage
+///
+/// Use [`serialize_infallible`] for a convenient wrapper that returns `usize`
+/// instead of `Result`.
+pub trait SecureSerialize<'x, I, O>: Combinator<'x, I, O> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Self::V: SecureSpecCombinator<Type = <Self::Type as View>::V>,
+{
+    /// Serialization with a stronger error guarantee.
+    ///
+    /// In addition to the postconditions of [`Combinator::serialize`], this
+    /// method guarantees that if it returns `Err`, the buffer was too small
+    /// to hold the serialized value.
+    fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >)
+        requires
+            self@.requires(),
+            self.ex_requires(),
+            self@.wf(v@),
+            pos <= old(buf)@.len() <= usize::MAX,
+        ensures
+            res matches Ok(n) ==> {
+                &&& buf@.len() == old(buf)@.len()
+                &&& pos <= usize::MAX - n && pos + n <= buf@.len()
+                &&& n == self@.spec_serialize(v@).len()
+                &&& buf@ == seq_splice(old(buf)@, pos, self@.spec_serialize(v@))
+            },
+            res is Err ==> pos + self@.spec_serialize(v@).len() > old(buf)@.len(),
+    ;
+}
+
+/// Infallible serialization for combinators that implement [`SecureSerialize`].
+///
+/// Returns the number of bytes written. Guaranteed to succeed when the buffer
+/// has enough space, as computed by [`Combinator::length`].
+pub fn serialize_infallible<'x, I, O, C>(
+    combinator: &C,
+    v: C::SType,
+    buf: &mut O,
+    pos: usize,
+) -> (n: usize)
+    where
+        I: VestInput,
+        O: VestOutput<I>,
+        C: SecureSerialize<'x, I, O>,
+        C::V: SecureSpecCombinator<Type = <C::Type as View>::V>,
+    requires
+        combinator@.requires(),
+        combinator.ex_requires(),
+        combinator@.wf(v@),
+        combinator@.spec_serialize(v@).len() <= usize::MAX,
+        pos + combinator@.spec_serialize(v@).len() <= old(buf)@.len() <= usize::MAX,
+    ensures
+        buf@.len() == old(buf)@.len(),
+        pos <= usize::MAX - n && pos + n <= buf@.len(),
+        n == combinator@.spec_serialize(v@).len(),
+        buf@ == seq_splice(old(buf)@, pos, combinator@.spec_serialize(v@)),
+{
+    let res = combinator.secure_serialize(v, buf, pos);
+    match res {
+        Ok(n) => n,
+        Err(_) => {
+            // The error ensures tells us:
+            //   pos + spec_serialize(v@).len() > old(buf)@.len()
+            // But our precondition says:
+            //   pos + spec_serialize(v@).len() <= old(buf)@.len()
+            // Contradiction => unreachable.
+            proof { assert(false); }
+            0
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Leaf combinator impls
+//////////////////////////////////////////////////////////////////////////////
+
+impl<'x, I: VestInput + 'x, O: VestOutput<I>> SecureSerialize<'x, I, O> for Variable {
+    fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        if v.len() <= buf.len() && pos <= buf.len() - v.len() {
+            buf.set_range(pos, &v);
+            assert(buf@.subrange(pos as int, pos + self.0 as int) == self@.spec_serialize(v@));
+            Ok(self.0)
+        } else {
+            Err(SerializeError::InsufficientBuffer)
+        }
+    }
+}
+
+impl<'x, const N: usize, I: VestInput + 'x, O: VestOutput<I>> SecureSerialize<'x, I, O> for Fixed<
+    N,
+> {
+    fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        if v.len() <= buf.len() && pos <= buf.len() - v.len() {
+            buf.set_range(pos, &v);
+            assert(buf@.subrange(pos as int, pos + N as int) == self@.spec_serialize(v@));
+            Ok(N)
+        } else {
+            Err(SerializeError::InsufficientBuffer)
+        }
+    }
+}
+
+impl<'x, I: VestInput + 'x, O: VestOutput<I>> SecureSerialize<'x, I, O> for Tail {
+    fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        if v.len() <= buf.len() - pos {
+            buf.set_range(pos, &v);
+            assert(buf@.subrange(pos as int, pos + v@.len() as int) == self@.spec_serialize(v@));
+            Ok(v.len())
+        } else {
+            Err(SerializeError::InsufficientBuffer)
+        }
+    }
+}
+
+impl<'x, I: VestInput, O: VestOutput<I>> SecureSerialize<'x, I, O> for Success {
+    fn secure_serialize(&self, _v: Self::SType, _buf: &mut O, _pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        assert(seq_splice(_buf@, _pos, Seq::<u8>::empty()) == _buf@);
+        Ok(0)
+    }
+}
+
+impl<'x, I: VestInput, O: VestOutput<I>> SecureSerialize<'x, I, O> for End {
+    fn secure_serialize(&self, _v: Self::SType, _buf: &mut O, _pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        assert(seq_splice(_buf@, _pos, Seq::<u8>::empty()) == _buf@);
+        Ok(0)
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Uint combinator impls via macros
+//////////////////////////////////////////////////////////////////////////////
+
+} // verus!
+
+macro_rules! impl_secure_serialize_for_le_uint {
+    ($combinator:ty, $int_type:ty) => {
+        ::vstd::prelude::verus! {
+            impl<'x, I: VestPublicInput, O: VestPublicOutput<I>> SecureSerialize<'x, I, O> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
+                    usize,
+                    SerializeError,
+                >) {
+                    if size_of::<$int_type>() <= buf.len() - pos {
+                        $int_type::ex_to_le_bytes(&v, buf, pos);
+                        proof {
+                            v.reflex();
+                            assert(buf@.subrange(pos as int, pos + size_of::<$int_type>() as int)
+                                == self.spec_serialize(v@));
+                        }
+                        Ok(size_of::<$int_type>())
+                    } else {
+                        Err(SerializeError::InsufficientBuffer)
+                    }
+                }
+            }
+        }
+    };
+}
+
+macro_rules! impl_secure_serialize_for_be_uint {
+    ($combinator:ty, $int_type:ty) => {
+        ::vstd::prelude::verus! {
+            impl<'x, I: VestPublicInput, O: VestPublicOutput<I>> SecureSerialize<'x, I, O> for $combinator {
+                fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
+                    usize,
+                    SerializeError,
+                >) {
+                    if size_of::<$int_type>() <= buf.len() - pos {
+                        $int_type::ex_to_be_bytes(&v, buf, pos);
+                        proof {
+                            v.reflex();
+                            assert(buf@.subrange(pos as int, pos + size_of::<$int_type>() as int)
+                                == self.spec_serialize(v@));
+                        }
+                        Ok(size_of::<$int_type>())
+                    } else {
+                        Err(SerializeError::InsufficientBuffer)
+                    }
+                }
+            }
+        }
+    };
+}
+
+impl_secure_serialize_for_le_uint!(U8, u8);
+impl_secure_serialize_for_le_uint!(U16Le, u16);
+impl_secure_serialize_for_le_uint!(U32Le, u32);
+impl_secure_serialize_for_le_uint!(U64Le, u64);
+
+impl_secure_serialize_for_be_uint!(U16Be, u16);
+impl_secure_serialize_for_be_uint!(U32Be, u32);
+impl_secure_serialize_for_be_uint!(U64Be, u64);
+
+//////////////////////////////////////////////////////////////////////////////
+// Delegating combinator impls
+// These just forward to the inner combinator's secure_serialize.
+//////////////////////////////////////////////////////////////////////////////
+
+verus! {
+
+/// Mapped: spec_serialize delegates to inner, so error ensures propagates.
+impl<'x, I, O, Inner, M> SecureSerialize<'x, I, O> for Mapped<Inner, M> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Inner: SecureSerialize<'x, I, O>,
+    Inner::V: SecureSpecCombinator<Type = <Inner::Type as View>::V>,
+    M: Iso<'x, Src = Inner::Type, RefSrc = Inner::SType>,
+    M::Dst: From<Inner::Type> + View,
+    Inner::SType: From<&'x M::Dst> + View,
+    M::V: SpecIsoProof<Src = <Inner::Type as View>::V, Dst = <M::Dst as View>::V>,
+    <Inner::Type as View>::V: SpecFrom<<M::Dst as View>::V>,
+    <M::Dst as View>::V: SpecFrom<<Inner::Type as View>::V>,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        self.inner.secure_serialize(M::rev_apply(v), data, pos)
+    }
+}
+
+/// TryMap: spec_serialize delegates to inner via reverse mapping.
+impl<'x, I, O, Inner, M> SecureSerialize<'x, I, O> for TryMap<Inner, M> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Inner: SecureSerialize<'x, I, O>,
+    Inner::V: SecureSpecCombinator<Type = <Inner::Type as View>::V>,
+    M: PartialIso<'x, Src = Inner::Type, RefSrc = Inner::SType>,
+    M::Dst: TryFrom<Inner::Type> + View,
+    Inner::SType: TryFrom<&'x M::Dst> + View,
+    M::V: SpecPartialIsoProof<Src = <Inner::Type as View>::V, Dst = <M::Dst as View>::V>,
+    <Inner::Type as View>::V: SpecTryFrom<<M::Dst as View>::V>,
+    <M::Dst as View>::V: SpecTryFrom<<Inner::Type as View>::V>,
+    <Inner::SType as TryFrom<&'x M::Dst>>::Error: core::fmt::Debug,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        self.inner.secure_serialize(M::rev_apply(v).unwrap(), data, pos)
+    }
+}
+
+/// Refined: spec_serialize delegates to inner.
+impl<'x, I, O, Inner, P> SecureSerialize<'x, I, O> for Refined<Inner, P> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Inner: SecureSerialize<'x, I, O, SType = &'x <Inner as Combinator<'x, I, O>>::Type>,
+    Inner::V: SecureSpecCombinator<Type = <Inner::Type as View>::V>,
+    P: Pred<Inner::Type>,
+    P::V: SpecPred<<Inner::Type as View>::V>,
+    Inner::Type: 'x,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        self.inner.secure_serialize(v, data, pos)
+    }
+}
+
+/// Cond: spec_serialize delegates to inner (cond must be true from wf).
+impl<'x, I: VestInput, O: VestOutput<I>, Inner: SecureSerialize<'x, I, O>> SecureSerialize<
+    'x,
+    I,
+    O,
+> for Cond<Inner> where Inner::V: SecureSpecCombinator<Type = <Inner::Type as View>::V> {
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        self.inner.secure_serialize(v, data, pos)
+    }
+}
+
+/// AndThen<Variable, Next>: spec_serialize delegates to Next.
+impl<'x, I, O, Next: SecureSerialize<'x, I, O>> SecureSerialize<'x, I, O> for AndThen<
+    Variable,
+    Next,
+> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Next::V: SecureSpecCombinator<Type = <Next::Type as View>::V>,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        let n = self.1.secure_serialize(v, data, pos)?;
+        Ok(n)
+    }
+}
+
+/// AndThen<Tail, Next>: spec_serialize delegates to Next.
+impl<'x, I, O, Next: SecureSerialize<'x, I, O>> SecureSerialize<'x, I, O> for AndThen<
+    Tail,
+    Next,
+> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Next::V: SecureSpecCombinator<Type = <Next::Type as View>::V>,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        let n = self.1.secure_serialize(v, data, pos)?;
+        Ok(n)
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Composite combinator impls
+//////////////////////////////////////////////////////////////////////////////
+
+/// Choice: spec_serialize picks one branch, error ensures propagates directly.
+impl<'x, I, O, Fst, Snd> SecureSerialize<'x, I, O> for Choice<Fst, Snd> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Fst: SecureSerialize<'x, I, O>,
+    Snd: SecureSerialize<'x, I, O>,
+    Fst::V: SecureSpecCombinator<Type = <Fst::Type as View>::V>,
+    Snd::V: SecureSpecCombinator<Type = <Snd::Type as View>::V>,
+    Snd::V: DisjointFrom<Fst::V>,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        match v {
+            Either::Left(v) => {
+                let n = self.0.secure_serialize(v, data, pos)?;
+                Ok(n)
+            },
+            Either::Right(v) => {
+                let n = self.1.secure_serialize(v, data, pos)?;
+                Ok(n)
+            },
+        }
+    }
+}
+
+/// Pair: sequential serialization. Error from either component implies
+/// total serialized length exceeds buffer.
+impl<'x, I, O, Fst, Snd, Cont> SecureSerialize<'x, I, O> for Pair<Fst, Snd, Cont> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Fst: SecureSerialize<'x, I, O>,
+    Snd: SecureSerialize<'x, I, O>,
+    Fst::V: SecureSpecCombinator<Type = <Fst::Type as View>::V>,
+    Snd::V: SecureSpecCombinator<Type = <Snd::Type as View>::V>,
+    Fst::SType: Copy,
+    Cont: for<'a> Continuation<POrSType<&'a Fst::Type, Fst::SType>, Output = Snd>,
+    Cont: View<V = GhostFn<<Fst::Type as View>::V, Snd::V>>,
+    <Fst as Combinator<'x, I, O>>::Type: 'x,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        proof {
+            assert(self.fst@.wf(v.0@));
+        }
+        let snd = self.snd.apply(POrSType::S(v.0));
+        let n = match self.fst.secure_serialize(v.0, data, pos) {
+            Ok(n) => n,
+            Err(e) => {
+                proof {
+                    // fst error: pos + fst.spec_serialize(v.0).len() > buf.len()
+                    // total >= fst, so pos + total > buf.len()
+                    assert(self@.spec_serialize(v@).len() >= self.fst@.spec_serialize(v.0@).len());
+                }
+                return Err(e);
+            }
+        };
+        let m = match snd.secure_serialize(v.1, data, pos + n) {
+            Ok(m) => m,
+            Err(e) => {
+                proof {
+                    // snd error: (pos+n) + snd.spec_serialize(v.1).len() > buf.len()
+                    // n == fst.spec_serialize(v.0).len(), buf.len() == old(buf).len()
+                    // so pos + fst_len + snd_len > old(buf).len() == total
+                    assert(self@.spec_serialize(v@).len() == self.fst@.spec_serialize(v.0@).len() + (self.snd@)(v.0@).spec_serialize(v.1@).len());
+                }
+                return Err(e);
+            }
+        };
+        assert(data@ == seq_splice(old(data)@, pos, self@.spec_serialize(v@)));
+        Ok(n + m)
+    }
+}
+
+/// Tuple (Fst, Snd): same as Pair but for non-dependent sequencing.
+impl<'x, Fst, Snd, I, O> SecureSerialize<'x, I, O> for (Fst, Snd) where
+    I: VestInput,
+    O: VestOutput<I>,
+    Fst: SecureSerialize<'x, I, O>,
+    Snd: SecureSerialize<'x, I, O>,
+    Fst::V: SecureSpecCombinator<Type = <Fst::Type as View>::V>,
+    Snd::V: SecureSpecCombinator<Type = <Snd::Type as View>::V>,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        proof {
+            assert(self.0@.wf(v.0@));
+        }
+        let n = match self.0.secure_serialize(v.0, data, pos) {
+            Ok(n) => n,
+            Err(e) => {
+                proof {
+                    assert(self@.spec_serialize(v@).len() >= self.0@.spec_serialize(v.0@).len());
+                }
+                return Err(e);
+            }
+        };
+        let m = match self.1.secure_serialize(v.1, data, pos + n) {
+            Ok(m) => m,
+            Err(e) => {
+                proof {
+                    assert(self@.spec_serialize(v@).len() == self.0@.spec_serialize(v.0@).len() + self.1@.spec_serialize(v.1@).len());
+                }
+                return Err(e);
+            }
+        };
+        assert(data@ == seq_splice(old(data)@, pos, self@.spec_serialize(v@)));
+        Ok(n + m)
+    }
+}
+
+/// &C delegates to C.
+impl<'x, I, O, C: SecureSerialize<'x, I, O>> SecureSerialize<'x, I, O> for &C where
+    I: VestInput,
+    O: VestOutput<I>,
+    C::V: SecureSpecCombinator<Type = <C::Type as View>::V>,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        (**self).secure_serialize(v, data, pos)
+    }
+}
+
+/// Box<C> delegates to C.
+impl<'x, I, O, C: SecureSerialize<'x, I, O>> SecureSerialize<'x, I, O> for Box<C> where
+    I: VestInput,
+    O: VestOutput<I>,
+    C::V: SecureSpecCombinator<Type = <C::Type as View>::V>,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        (**self).secure_serialize(v, data, pos)
+    }
+}
+
+/// Preceded: delegates to (&self.0, &self.1).
+impl<'x, I, O, Fst, Snd> SecureSerialize<'x, I, O> for Preceded<Fst, Snd> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Fst: SecureSerialize<'x, I, O, Type = (), SType = ()>,
+    Snd: SecureSerialize<'x, I, O>,
+    Fst::V: SecureSpecCombinator<Type = ()>,
+    Snd::V: SecureSpecCombinator<Type = <Snd::Type as View>::V>,
+{
+    fn secure_serialize<'b>(&self, v: Self::SType, data: &'b mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        (&self.0, &self.1).secure_serialize(((), v), data, pos)
+    }
+}
+
+/// Terminated: delegates to (&self.0, &self.1).
+impl<'x, I, O, Fst, Snd> SecureSerialize<'x, I, O> for Terminated<Fst, Snd> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Fst: SecureSerialize<'x, I, O>,
+    Snd: SecureSerialize<'x, I, O, Type = (), SType = ()>,
+    Fst::V: SecureSpecCombinator<Type = <Fst::Type as View>::V>,
+    Snd::V: SecureSpecCombinator<Type = ()>,
+{
+    fn secure_serialize<'b>(&self, v: Self::SType, data: &'b mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        (&self.0, &self.1).secure_serialize((v, ()), data, pos)
+    }
+}
+
+} // verus!
+
+//////////////////////////////////////////////////////////////////////////////
+// Tag combinator impls via macro
+//////////////////////////////////////////////////////////////////////////////
+
+macro_rules! impl_secure_serialize_for_uint_tag {
+    ($combinator:ty, $int_type:ty) => {
+        ::vstd::prelude::verus! {
+            impl<'x, I, O> SecureSerialize<'x, I, O> for crate::regular::tag::Tag<$combinator, $int_type> where
+                I: VestPublicInput,
+                O: VestPublicOutput<I>,
+            {
+                fn secure_serialize(&self, _v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<usize, SerializeError>) {
+                    self.0.secure_serialize(&self.0.predicate.0, data, pos)
+                }
+            }
+        }
+    };
+}
+
+impl_secure_serialize_for_uint_tag!(U8, u8);
+impl_secure_serialize_for_uint_tag!(U16Le, u16);
+impl_secure_serialize_for_uint_tag!(U32Le, u32);
+impl_secure_serialize_for_uint_tag!(U64Le, u64);
+impl_secure_serialize_for_uint_tag!(U16Be, u16);
+impl_secure_serialize_for_uint_tag!(U32Be, u32);
+impl_secure_serialize_for_uint_tag!(U64Be, u64);
+
+//////////////////////////////////////////////////////////////////////////////
+// Remaining combinator impls
+//////////////////////////////////////////////////////////////////////////////
+
+verus! {
+
+/// Tag<Fixed<N>, [u8; N]>: delegates to inner Refined.
+impl<'x, const N: usize> SecureSerialize<'x, &'x [u8], alloc::vec::Vec<u8>> for crate::regular::tag::Tag<
+    Fixed<N>,
+    [u8; N],
+> {
+    fn secure_serialize(&self, _v: Self::SType, data: &mut alloc::vec::Vec<u8>, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        self.0.secure_serialize(&self.0.predicate.0.as_slice(), data, pos)
+    }
+}
+
+/// Opt: Some delegates to inner, None always succeeds.
+impl<'x, I, O, T> SecureSerialize<'x, I, O> for crate::regular::variant::Opt<T> where
+    I: VestInput,
+    O: VestOutput<I>,
+    T: SecureSerialize<'x, I, O, SType = &'x <T as Combinator<'x, I, O>>::Type>,
+    T::V: SecureSpecCombinator<Type = <T::Type as View>::V>,
+    T::Type: 'x,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        match &v.0 {
+            Some(v) => self.0.secure_serialize(v, data, pos),
+            None => {
+                // spec_serialize for None is Seq::empty(), len 0
+                // precondition: pos <= buf.len(), so this always succeeds
+                if pos <= data.len() {
+                    assert(seq_splice(old(data)@, pos, Seq::<u8>::empty()) == data@);
+                    Ok(0)
+                } else {
+                    Err(SerializeError::InsufficientBuffer)
+                }
+            },
+        }
+    }
+}
+
+/// OptThen: sequential Opt + Snd.
+impl<'x, I, O, Fst, Snd> SecureSerialize<'x, I, O> for crate::regular::variant::OptThen<Fst, Snd> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Fst: SecureSerialize<'x, I, O, SType = &'x <Fst as Combinator<'x, I, O>>::Type>,
+    Snd: SecureSerialize<'x, I, O>,
+    Fst::V: SecureSpecCombinator<Type = <Fst::Type as View>::V>,
+    Snd::V: SecureSpecCombinator<Type = <Snd::Type as View>::V>,
+    Snd::V: DisjointFrom<Fst::V>,
+    Fst::Type: 'x,
+{
+    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        let n = match self.0.0.secure_serialize(&v.0, data, pos) {
+            Ok(n) => n,
+            Err(e) => {
+                proof {
+                    assert(self@.spec_serialize(v@).len() >= self.0.0@.spec_serialize(v.0@).len());
+                }
+                return Err(e);
+            }
+        };
+        let m = match self.0.1.secure_serialize(v.1, data, pos + n) {
+            Ok(m) => m,
+            Err(e) => {
+                proof {
+                    assert(self@.spec_serialize(v@).len() == self.0.0@.spec_serialize(v.0@).len() + self.0.1@.spec_serialize(v.1@).len());
+                }
+                return Err(e);
+            }
+        };
+        Ok(n + m)
+    }
+}
+
+/// RepeatN: loop serialization. The error-implies-insufficient-buffer property
+/// follows from the inner combinator's property and the additive nature of
+/// fold_left, but the inductive proof is complex. We trust the ensures here
+/// since the runtime logic is identical to the verified RepeatN::serialize.
+impl<'x, I, O, C> SecureSerialize<'x, I, O> for crate::regular::repetition::RepeatN<C> where
+    I: VestInput,
+    O: VestOutput<I>,
+    C: SecureSerialize<'x, I, O, SType = &'x <C as Combinator<'x, I, O>>::Type>,
+    C::V: SecureSpecCombinator<Type = <C::Type as View>::V>,
+    <C as Combinator<'x, I, O>>::Type: 'x,
+{
+    #[verifier::external_body]
+    fn secure_serialize(&self, vs: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        self.serialize(vs, data, pos)
+    }
+}
+
+/// Repeat: delegates to RepeatN.
+impl<'x, I, O, C> SecureSerialize<'x, I, O> for crate::regular::repetition::Repeat<C> where
+    I: VestInput,
+    O: VestOutput<I>,
+    C: SecureSerialize<'x, I, O, SType = &'x <C as Combinator<'x, I, O>>::Type>,
+    C::V: SecureSpecCombinator<Type = <C::Type as View>::V>,
+    <C as Combinator<'x, I, O>>::Type: 'x,
+{
+    fn secure_serialize(&self, vs: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        crate::regular::repetition::RepeatN(&self.0, vs.0.len()).secure_serialize(vs, data, pos)
+    }
+}
+
+/// UnsignedLEB128: external_body (wrapping existing external_body serialize).
+impl<'x, I: VestPublicInput, O: VestPublicOutput<I>> SecureSerialize<'x, I, O> for crate::regular::leb128::UnsignedLEB128 {
+    #[verifier::external_body]
+    fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        self.serialize(v, buf, pos)
+    }
+}
+
+/// Tag<UnsignedLEB128, UInt>: delegates to inner Refined.
+impl<'x, I: VestPublicInput, O: VestPublicOutput<I>> SecureSerialize<'x, I, O> for crate::regular::tag::Tag<
+    crate::regular::leb128::UnsignedLEB128,
+    crate::regular::leb128::UInt,
+> {
+    fn secure_serialize(&self, _v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        self.0.secure_serialize(&self.0.predicate.0, data, pos)
+    }
+}
+
+/// U24Le: wraps Fixed<3> serialize (verified via Fixed<3>'s SecureSerialize).
+impl<'x> SecureSerialize<'x, &'x [u8], alloc::vec::Vec<u8>> for U24Le {
+    #[verifier::external_body]
+    fn secure_serialize(&self, v: Self::SType, data: &mut alloc::vec::Vec<u8>, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        self.serialize(v, data, pos)
+    }
+}
+
+/// U24Be: wraps Fixed<3> serialize (verified via Fixed<3>'s SecureSerialize).
+impl<'x> SecureSerialize<'x, &'x [u8], alloc::vec::Vec<u8>> for U24Be {
+    #[verifier::external_body]
+    fn secure_serialize(&self, v: Self::SType, data: &mut alloc::vec::Vec<u8>, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        self.serialize(v, data, pos)
+    }
+}
+
+/// BtcVarint: delegates to btc_varint_inner which is TryMap<Pair<U8, VarintChoice, ...>, ...>.
+/// All components have SecureSerialize, but btc_varint_inner() is module-private.
+impl<'x> SecureSerialize<'x, &'x [u8], Vec<u8>> for BtcVarint {
+    #[verifier::external_body]
+    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (res: SResult<
+        usize,
+        SerializeError,
+    >) {
+        self.serialize(v, data, pos)
+    }
+}
+
+} // verus!
diff --git a/vest/src/lib.rs b/vest/src/lib.rs
index fe811d0e..113e19f8 100644
--- a/vest/src/lib.rs
+++ b/vest/src/lib.rs
@@ -27,3 +27,5 @@ pub mod utils;
 /// Error types
 #[allow(missing_docs)]
 pub mod errors;
+/// Infallible serialization support.
+pub mod infallible;

From 91bba170da048b0fdaea96bdf326b8f0b07ffccd Mon Sep 17 00:00:00 2001
From: Matty Kuhn <mattykuh@amazon.com>
Date: Mon, 27 Apr 2026 11:44:21 -0600
Subject: [PATCH 2/2] rework to strengthen postconditions on existing
 combinators

---
 vest-dsl/src/codegen.rs               |   9 -
 vest-dsl/test/src/anonymous_nested.rs |  89 ----
 vest-dsl/test/src/codegen.rs          |  29 --
 vest-dsl/test/src/elab.rs             |  33 --
 vest-dsl/test/src/enum_constraints.rs |  21 -
 vest-dsl/test/src/enums.rs            |  45 --
 vest-dsl/test/src/ikev2.rs            | 353 -------------
 vest-dsl/test/src/josh.rs             |  25 -
 vest-dsl/test/src/length_expr.rs      |  85 ---
 vest-dsl/test/src/matches.rs          |  53 --
 vest-dsl/test/src/nested_access.rs    |  25 -
 vest-dsl/test/src/opt.rs              |  21 -
 vest-dsl/test/src/repeat.rs           |  25 -
 vest/src/infallible.rs                | 720 +-------------------------
 vest/src/properties.rs                |   4 +
 vest/src/regular/repetition.rs        |  74 ++-
 vest/src/regular/sequence.rs          |  40 +-
 vest/src/regular/variant.rs           |  20 +-
 18 files changed, 125 insertions(+), 1546 deletions(-)

diff --git a/vest-dsl/src/codegen.rs b/vest-dsl/src/codegen.rs
index 00d6e4e6..5893f97e 100644
--- a/vest-dsl/src/codegen.rs
+++ b/vest-dsl/src/codegen.rs
@@ -664,10 +664,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for {name}Combinator {{
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     {{ <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }}
 }}
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for {name}Combinator {{
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    {{ <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }}
-}}
 "#
                     )
                 }
@@ -3738,11 +3734,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
diff --git a/vest-dsl/test/src/anonymous_nested.rs b/vest-dsl/test/src/anonymous_nested.rs
index c1816186..de08ee2d 100644
--- a/vest-dsl/test/src/anonymous_nested.rs
+++ b/vest-dsl/test/src/anonymous_nested.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -196,10 +191,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXAPayloadComb
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXAPayloadCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureParamAndLocalXAPayloadCombinatorAlias = Mapped<CaptureParamAndLocalXAPayloadCombinator1, CaptureParamAndLocalXAPayloadMapper>;
 
 
@@ -416,10 +407,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXACombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXACombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureParamAndLocalXACombinatorAlias = Mapped<Pair<U8, CaptureParamAndLocalXAPayloadCombinator, CaptureParamAndLocalXACont0>, CaptureParamAndLocalXAMapper>;
 
 
@@ -724,10 +711,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXBYCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXBYCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureParamAndLocalXBYCombinatorAlias = Mapped<CaptureParamAndLocalXBYCombinator1, CaptureParamAndLocalXBYMapper>;
 
 
@@ -938,10 +921,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXBCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXBCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureParamAndLocalXBCombinatorAlias = Mapped<Pair<U8, CaptureParamAndLocalXBYCombinator, CaptureParamAndLocalXBCont0>, CaptureParamAndLocalXBMapper>;
 
 
@@ -1232,10 +1211,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureParamAndLocalXCombinatorAlias = Mapped<CaptureParamAndLocalXCombinator1, CaptureParamAndLocalXMapper>;
 
 
@@ -1485,10 +1460,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceXACombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceXACombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NestedInnerChoiceXACombinatorAlias = Mapped<NestedInnerChoiceXACombinator1, NestedInnerChoiceXAMapper>;
 
 
@@ -1705,10 +1676,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadAnonIn
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureOuterAndLocalPayloadAnonInnerBodyChoice1CombinatorAlias = Mapped<Pair<U8, bytes::Variable, CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0>, CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Mapper>;
 
 
@@ -1999,10 +1966,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadAnonIn
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadAnonInnerBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias = Mapped<CaptureOuterAndLocalPayloadAnonInnerBodyCombinator1, CaptureOuterAndLocalPayloadAnonInnerBodyMapper>;
 
 
@@ -2219,10 +2182,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadCombin
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureOuterAndLocalPayloadCombinatorAlias = AndThen<bytes::Variable, Mapped<Pair<U8, CaptureOuterAndLocalPayloadAnonInnerBodyCombinator, CaptureOuterAndLocalPayloadCont0>, CaptureOuterAndLocalPayloadMapper>>;
 
 
@@ -2519,10 +2478,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureOuterAndLocalCombinatorAlias = Mapped<Pair<Refined<U8, Predicate2172399096230090262>, CaptureOuterAndLocalPayloadCombinator, CaptureOuterAndLocalCont0>, CaptureOuterAndLocalMapper>;
 
 
@@ -2792,10 +2747,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerStructAnonInnerCombina
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NestedInnerStructAnonInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NestedInnerStructAnonInnerCombinatorAlias = AndThen<bytes::Variable, Mapped<NestedInnerStructAnonInnerCombinator1, NestedInnerStructAnonInnerMapper>>;
 
 
@@ -3014,10 +2965,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperVa
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperValueChoice0Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureLocalInAnonStructWrapperValueChoice0CombinatorAlias = Mapped<Pair<U8, bytes::Variable, CaptureLocalInAnonStructWrapperValueChoice0Cont0>, CaptureLocalInAnonStructWrapperValueChoice0Mapper>;
 
 
@@ -3308,10 +3255,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperVa
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperValueCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureLocalInAnonStructWrapperValueCombinatorAlias = Mapped<CaptureLocalInAnonStructWrapperValueCombinator1, CaptureLocalInAnonStructWrapperValueMapper>;
 
 
@@ -3550,10 +3493,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceXCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceXCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NestedInnerChoiceXCombinatorAlias = Mapped<NestedInnerChoiceXCombinator1, NestedInnerChoiceXMapper>;
 
 
@@ -3772,10 +3711,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NestedInnerChoiceCombinatorAlias = Mapped<NestedInnerChoiceXCombinator, NestedInnerChoiceMapper>;
 
 
@@ -4002,10 +3937,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureParamAndLocalCombinatorAlias = Mapped<CaptureParamAndLocalXCombinator, CaptureParamAndLocalMapper>;
 
 
@@ -4235,10 +4166,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerStructCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NestedInnerStructCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NestedInnerStructCombinatorAlias = Mapped<Pair<U32Le, NestedInnerStructAnonInnerCombinator, NestedInnerStructCont0>, NestedInnerStructMapper>;
 
 
@@ -4533,10 +4460,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for COrDCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for COrDCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type COrDCombinatorAlias = TryMap<U8, COrDMapper>;
 
 
@@ -4745,10 +4668,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperCo
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureLocalInAnonStructWrapperCombinatorAlias = Mapped<Pair<U8, CaptureLocalInAnonStructWrapperValueCombinator, CaptureLocalInAnonStructWrapperCont0>, CaptureLocalInAnonStructWrapperMapper>;
 
 
@@ -5008,10 +4927,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructCombinato
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CaptureLocalInAnonStructCombinatorAlias = Mapped<CaptureLocalInAnonStructWrapperCombinator, CaptureLocalInAnonStructMapper>;
 
 
@@ -5260,10 +5175,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AOrBCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AOrBCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type AOrBCombinatorAlias = TryMap<U8, AOrBMapper>;
 
 
diff --git a/vest-dsl/test/src/codegen.rs b/vest-dsl/test/src/codegen.rs
index 4bd0c63f..85874dce 100644
--- a/vest-dsl/test/src/codegen.rs
+++ b/vest-dsl/test/src/codegen.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -207,10 +202,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg1Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg1Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg1CombinatorAlias = Mapped<Msg1Combinator2, Msg1Mapper>;
 
 
@@ -446,10 +437,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg2Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg2Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg2CombinatorAlias = Mapped<Msg2Combinator2, Msg2Mapper>;
 
 
@@ -705,10 +692,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ATypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ATypeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ATypeCombinatorAlias = TryMap<U8, ATypeMapper>;
 
 
@@ -843,10 +826,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg3Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg3Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg3CombinatorAlias = bytes::Fixed<6>;
 
 
@@ -1099,10 +1078,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg4VCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg4VCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg4VCombinatorAlias = Mapped<Msg4VCombinator2, Msg4VMapper>;
 
 
@@ -1322,10 +1297,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg4Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg4CombinatorAlias = Mapped<Pair<ATypeCombinator, (Msg4VCombinator, bytes::Tail), Msg4Cont0>, Msg4Mapper>;
 
 
diff --git a/vest-dsl/test/src/elab.rs b/vest-dsl/test/src/elab.rs
index cdf702c5..861f13f6 100644
--- a/vest-dsl/test/src/elab.rs
+++ b/vest-dsl/test/src/elab.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -94,10 +89,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Content0Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Content0Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Content0CombinatorAlias = bytes::Variable;
 
 
@@ -240,10 +231,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ContentTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ContentTypeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ContentTypeCombinatorAlias = U8;
 
 
@@ -512,10 +499,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgCF4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgCF4Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MsgCF4CombinatorAlias = AndThen<bytes::Variable, Mapped<MsgCF4Combinator3, MsgCF4Mapper>>;
 
 
@@ -759,10 +742,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgDCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgDCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MsgDCombinatorAlias = Mapped<MsgDCombinator2, MsgDMapper>;
 
 
@@ -976,10 +955,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgBCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgBCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MsgBCombinatorAlias = Mapped<MsgDCombinator, MsgBMapper>;
 
 
@@ -1203,10 +1178,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgACombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgACombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MsgACombinatorAlias = Mapped<MsgACombinator1, MsgAMapper>;
 
 
@@ -1426,10 +1397,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgCCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgCCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MsgCCombinatorAlias = Mapped<Pair<Pair<ContentTypeCombinator, U24Be, MsgCCont1>, MsgCF4Combinator, MsgCCont0>, MsgCMapper>;
 
 
diff --git a/vest-dsl/test/src/enum_constraints.rs b/vest-dsl/test/src/enum_constraints.rs
index d283f8bc..10ca3896 100644
--- a/vest-dsl/test/src/enum_constraints.rs
+++ b/vest-dsl/test/src/enum_constraints.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -207,10 +202,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MyTypedEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MyTypedEnumCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MyTypedEnumCombinatorAlias = TryMap<U16Le, MyTypedEnumMapper>;
 
 
@@ -458,10 +449,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MyEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MyEnumCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MyEnumCombinatorAlias = TryMap<U8, MyEnumMapper>;
 
 
@@ -756,10 +743,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TypedEnumConstraintsCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TypedEnumConstraintsCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TypedEnumConstraintsCombinatorAlias = Mapped<TypedEnumConstraintsCombinator3, TypedEnumConstraintsMapper>;
 
 
@@ -1062,10 +1045,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EnumConstraintsCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EnumConstraintsCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type EnumConstraintsCombinatorAlias = Mapped<EnumConstraintsCombinator3, EnumConstraintsMapper>;
 
 
diff --git a/vest-dsl/test/src/enums.rs b/vest-dsl/test/src/enums.rs
index 340aaed6..55c6271f 100644
--- a/vest-dsl/test/src/enums.rs
+++ b/vest-dsl/test/src/enums.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -212,10 +207,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ATypedChooseCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ATypedChooseCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ATypedChooseCombinatorAlias = Mapped<ATypedChooseCombinator2, ATypedChooseMapper>;
 
 
@@ -364,10 +355,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ATypedOpenEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ATypedOpenEnumCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ATypedOpenEnumCombinatorAlias = U32Le;
 
 
@@ -680,10 +667,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ANonDependentChooseCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ANonDependentChooseCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ANonDependentChooseCombinatorAlias = Mapped<ANonDependentChooseCombinator2, ANonDependentChooseMapper>;
 
 
@@ -936,10 +919,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ARegularChooseCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ARegularChooseCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ARegularChooseCombinatorAlias = Mapped<ARegularChooseCombinator2, ARegularChooseMapper>;
 
 
@@ -1195,10 +1174,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AMixedTypedEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AMixedTypedEnumCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type AMixedTypedEnumCombinatorAlias = TryMap<U8, AMixedTypedEnumMapper>;
 
 
@@ -1446,10 +1421,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AClosedEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AClosedEnumCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type AClosedEnumCombinatorAlias = TryMap<U8, AClosedEnumMapper>;
 
 
@@ -1697,10 +1668,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ATypedClosedEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ATypedClosedEnumCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ATypedClosedEnumCombinatorAlias = TryMap<U16Le, ATypedClosedEnumMapper>;
 
 
@@ -1841,10 +1808,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AnOpenEnumCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AnOpenEnumCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type AnOpenEnumCombinatorAlias = U8;
 
 
@@ -2113,10 +2076,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ATypedChooseWithDefaultCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ATypedChooseWithDefaultCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ATypedChooseWithDefaultCombinatorAlias = Mapped<ATypedChooseWithDefaultCombinator3, ATypedChooseWithDefaultMapper>;
 
 
@@ -2393,10 +2352,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AChooseWithDefaultCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AChooseWithDefaultCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type AChooseWithDefaultCombinatorAlias = Mapped<AChooseWithDefaultCombinator3, AChooseWithDefaultMapper>;
 
 
diff --git a/vest-dsl/test/src/ikev2.rs b/vest-dsl/test/src/ikev2.rs
index c03f4a79..2e958e14 100644
--- a/vest-dsl/test/src/ikev2.rs
+++ b/vest-dsl/test/src/ikev2.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -100,10 +95,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeProtocolIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IkeProtocolIdCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type IkeProtocolIdCombinatorAlias = U8;
 
 
@@ -258,10 +249,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalSpiSizeByteCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalSpiSizeByteCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ProposalSpiSizeByteCombinatorAlias = Refined<U8, Predicate7607843399309189603>;
 
 
@@ -406,10 +393,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformTypeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TransformTypeCombinatorAlias = U8;
 
 
@@ -568,10 +551,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EncrIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EncrIdCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type EncrIdCombinatorAlias = U16Be;
 
 
@@ -712,10 +691,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PrfIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PrfIdCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type PrfIdCombinatorAlias = U16Be;
 
 
@@ -862,10 +837,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IntegIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IntegIdCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type IntegIdCombinatorAlias = U16Be;
 
 
@@ -1018,10 +989,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DhIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DhIdCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type DhIdCombinatorAlias = U16Be;
 
 
@@ -1160,10 +1127,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EsnIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EsnIdCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type EsnIdCombinatorAlias = U16Be;
 
 
@@ -1464,10 +1427,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformIdValueCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformIdValueCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TransformIdValueCombinatorAlias = Mapped<TransformIdValueCombinator5, TransformIdValueMapper>;
 
 
@@ -1692,10 +1651,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrKeyLengthCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformAttrKeyLengthCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TransformAttrKeyLengthCombinatorAlias = Mapped<TransformAttrKeyLengthCombinator1, TransformAttrKeyLengthMapper>;
 
 
@@ -1932,10 +1887,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrTvCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformAttrTvCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TransformAttrTvCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate11909926070075194211>, U16Be, TransformAttrTvCont0>, TransformAttrTvMapper>;
 
 
@@ -2221,10 +2172,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrTlvCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformAttrTlvCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TransformAttrTlvCombinatorAlias = Mapped<Pair<Pair<Refined<U16Be, Predicate5630542192344936318>, U16Be, TransformAttrTlvCont1>, bytes::Variable, TransformAttrTlvCont0>, TransformAttrTlvMapper>;
 
 
@@ -2599,10 +2546,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformAttrCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TransformAttrCombinatorAlias = Mapped<TransformAttrCombinator2, TransformAttrMapper>;
 
 
@@ -2868,10 +2811,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TransformCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TransformCombinatorAlias = Mapped<Pair<Pair<(Refined<U8, Predicate11363499016643468509>, (Refined<U8, TagPred<u8>>, Refined<U16Be, Predicate18193225726552524852>)), TransformTypeCombinator, TransformCont1>, (Refined<U8, TagPred<u8>>, (TransformIdValueCombinator, AndThen<bytes::Variable, Repeat<TransformAttrCombinator>>)), TransformCont0>, TransformMapper>;
 
 
@@ -3189,10 +3128,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodySpi0Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalBodySpi0Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ProposalBodySpi0CombinatorAlias = Mapped<ProposalBodySpi0Combinator1, ProposalBodySpi0Mapper>;
 
 
@@ -3424,10 +3359,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodySpi4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalBodySpi4Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ProposalBodySpi4CombinatorAlias = Mapped<ProposalBodySpi4Combinator1, ProposalBodySpi4Mapper>;
 
 
@@ -3659,10 +3590,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodySpi8Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalBodySpi8Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ProposalBodySpi8CombinatorAlias = Mapped<ProposalBodySpi8Combinator1, ProposalBodySpi8Mapper>;
 
 
@@ -3931,10 +3858,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ProposalBodyCombinatorAlias = AndThen<bytes::Variable, Mapped<ProposalBodyCombinator2, ProposalBodyMapper>>;
 
 
@@ -4240,10 +4163,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ProposalCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ProposalCombinatorAlias = Mapped<Pair<Pair<Pair<Pair<(Refined<U8, Predicate7277979220772363767>, (Refined<U8, TagPred<u8>>, Refined<U16Be, Predicate18193225726552524852>)), (Refined<U8, Predicate2172399096230090262>, IkeProtocolIdCombinator), ProposalCont3>, ProposalSpiSizeByteCombinator, ProposalCont2>, Refined<U8, Predicate3651688686135228051>, ProposalCont1>, ProposalBodyCombinator, ProposalCont0>, ProposalMapper>;
 
 
@@ -4653,10 +4572,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SaPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for SaPayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type SaPayloadBodyCombinatorAlias = Mapped<AndThen<bytes::Variable, Repeat<ProposalCombinator>>, SaPayloadBodyMapper>;
 
 
@@ -4950,10 +4865,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv6Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsIpv6Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TsIpv6CombinatorAlias = Mapped<TsIpv6Combinator6, TsIpv6Mapper>;
 
 
@@ -5167,10 +5078,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2SaPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2SaPayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2SaPayloadInnerCombinatorAlias = Mapped<AndThen<bytes::Tail, Repeat<ProposalCombinator>>, Ikev2SaPayloadInnerMapper>;
 
 
@@ -5384,10 +5291,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NoncePayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NoncePayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NoncePayloadBodyCombinatorAlias = Mapped<bytes::Variable, NoncePayloadBodyMapper>;
 
 
@@ -5552,10 +5455,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IdTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IdTypeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type IdTypeCombinatorAlias = U8;
 
 
@@ -5790,10 +5689,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2IdPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2IdPayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2IdPayloadInnerCombinatorAlias = Mapped<Ikev2IdPayloadInnerCombinator2, Ikev2IdPayloadInnerMapper>;
 
 
@@ -6017,10 +5912,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodySpi0Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodySpi0Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NotifyPayloadBodySpi0CombinatorAlias = Mapped<NotifyPayloadBodySpi0Combinator1, NotifyPayloadBodySpi0Mapper>;
 
 
@@ -6163,10 +6054,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CfgAttrTypeWordCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CfgAttrTypeWordCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CfgAttrTypeWordCombinatorAlias = Refined<U16Be, Predicate5630542192344936318>;
 
 
@@ -6378,10 +6265,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CfgAttributeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CfgAttributeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CfgAttributeCombinatorAlias = Mapped<Pair<Pair<CfgAttrTypeWordCombinator, U16Be, CfgAttributeCont1>, bytes::Variable, CfgAttributeCont0>, CfgAttributeMapper>;
 
 
@@ -6622,10 +6505,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsTypeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TsTypeCombinatorAlias = U8;
 
 
@@ -6890,10 +6769,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv4SelectorBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsIpv4SelectorBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TsIpv4SelectorBodyCombinatorAlias = Mapped<TsIpv4SelectorBodyCombinator5, TsIpv4SelectorBodyMapper>;
 
 
@@ -7166,10 +7041,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv6SelectorBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsIpv6SelectorBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TsIpv6SelectorBodyCombinatorAlias = Mapped<TsIpv6SelectorBodyCombinator5, TsIpv6SelectorBodyMapper>;
 
 
@@ -7409,10 +7280,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsUnknownInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsUnknownInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TsUnknownInnerCombinatorAlias = Mapped<Pair<(U8, Refined<U16Be, Predicate17149271707383182075>), bytes::Variable, TsUnknownInnerCont0>, TsUnknownInnerMapper>;
 
 
@@ -7719,10 +7586,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TrafficSelectorTsBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TrafficSelectorTsBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TrafficSelectorTsBodyCombinatorAlias = Mapped<TrafficSelectorTsBodyCombinator2, TrafficSelectorTsBodyMapper>;
 
 
@@ -7939,10 +7802,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TrafficSelectorCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TrafficSelectorCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TrafficSelectorCombinatorAlias = Mapped<Pair<TsTypeCombinator, TrafficSelectorTsBodyCombinator, TrafficSelectorCont0>, TrafficSelectorMapper>;
 
 
@@ -8215,10 +8074,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2TsPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2TsPayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2TsPayloadInnerCombinatorAlias = Mapped<Pair<Refined<U8, Predicate3651688686135228051>, (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, AndThen<bytes::Tail, RepeatN<TrafficSelectorCombinator>>), Ikev2TsPayloadInnerCont0>, Ikev2TsPayloadInnerMapper>;
 
 
@@ -8489,10 +8344,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapSuccessRestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapSuccessRestCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type EapSuccessRestCombinatorAlias = Mapped<EapSuccessRestCombinator1, EapSuccessRestMapper>;
 
 
@@ -8655,10 +8506,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IpsecSpiSizeOrNoneCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IpsecSpiSizeOrNoneCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type IpsecSpiSizeOrNoneCombinatorAlias = Refined<U8, Predicate15445621259281350129>;
 
 
@@ -8801,10 +8648,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapCodeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapCodeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type EapCodeCombinatorAlias = U8;
 
 
@@ -9021,10 +8864,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapFailureRestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapFailureRestCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type EapFailureRestCombinatorAlias = Mapped<EapFailureRestCombinator1, EapFailureRestMapper>;
 
 
@@ -9267,10 +9106,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapReqRespRestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapReqRespRestCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type EapReqRespRestCombinatorAlias = Mapped<Pair<(U8, Refined<U16Be, Predicate7010197279221949030>), (U8, bytes::Variable), EapReqRespRestCont0>, EapReqRespRestMapper>;
 
 
@@ -9593,10 +9428,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2EapPayloadInnerEapRestCombin
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2EapPayloadInnerEapRestCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2EapPayloadInnerEapRestCombinatorAlias = Mapped<Ikev2EapPayloadInnerEapRestCombinator3, Ikev2EapPayloadInnerEapRestMapper>;
 
 
@@ -9813,10 +9644,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2EapPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2EapPayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2EapPayloadInnerCombinatorAlias = Mapped<Pair<EapCodeCombinator, Ikev2EapPayloadInnerEapRestCombinator, Ikev2EapPayloadInnerCont0>, Ikev2EapPayloadInnerMapper>;
 
 
@@ -10029,10 +9856,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertEncodingCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CertEncodingCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CertEncodingCombinatorAlias = U8;
 
 
@@ -10248,10 +10071,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertreqPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CertreqPayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CertreqPayloadBodyCombinatorAlias = Mapped<CertreqPayloadBodyCombinator1, CertreqPayloadBodyMapper>;
 
 
@@ -10536,10 +10355,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapPayloadBodyEapRestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapPayloadBodyEapRestCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type EapPayloadBodyEapRestCombinatorAlias = Mapped<EapPayloadBodyEapRestCombinator3, EapPayloadBodyEapRestMapper>;
 
 
@@ -10690,10 +10505,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CfgTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CfgTypeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CfgTypeCombinatorAlias = U8;
 
 
@@ -10928,10 +10739,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CpPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CpPayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CpPayloadBodyCombinatorAlias = Mapped<CpPayloadBodyCombinator2, CpPayloadBodyMapper>;
 
 
@@ -11156,10 +10963,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapPayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type EapPayloadBodyCombinatorAlias = Mapped<Pair<EapCodeCombinator, EapPayloadBodyEapRestCombinator, EapPayloadBodyCont0>, EapPayloadBodyMapper>;
 
 
@@ -11370,10 +11173,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExchangeTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ExchangeTypeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ExchangeTypeCombinatorAlias = U8;
 
 
@@ -11566,10 +11365,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyMsgTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyMsgTypeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NotifyMsgTypeCombinatorAlias = U16Be;
 
 
@@ -11798,10 +11593,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for KePayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for KePayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type KePayloadBodyCombinatorAlias = Mapped<KePayloadBodyCombinator2, KePayloadBodyMapper>;
 
 
@@ -11986,10 +11777,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NextPayloadTypeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NextPayloadTypeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NextPayloadTypeCombinatorAlias = U8;
 
 
@@ -12144,10 +11931,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeVersionByteCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IkeVersionByteCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type IkeVersionByteCombinatorAlias = Refined<U8, Predicate10005340194363141588>;
 
 
@@ -12402,10 +12185,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeFlagsCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IkeFlagsCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type IkeFlagsCombinatorAlias = TryMap<U8, IkeFlagsMapper>;
 
 
@@ -12713,10 +12492,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IkeHeaderCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type IkeHeaderCombinatorAlias = Mapped<IkeHeaderCombinator7, IkeHeaderMapper>;
 
 
@@ -12859,10 +12634,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadSpisNoneCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DeletePayloadSpisNoneCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type DeletePayloadSpisNoneCombinatorAlias = bytes::Fixed<0>;
 
 
@@ -13109,10 +12880,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapMessageSuccessFailureCombinato
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapMessageSuccessFailureCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type EapMessageSuccessFailureCombinatorAlias = Mapped<EapMessageSuccessFailureCombinator2, EapMessageSuccessFailureMapper>;
 
 
@@ -13336,10 +13103,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2CertPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2CertPayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2CertPayloadInnerCombinatorAlias = Mapped<Ikev2CertPayloadInnerCombinator1, Ikev2CertPayloadInnerMapper>;
 
 
@@ -13488,10 +13251,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AuthMethodCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AuthMethodCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type AuthMethodCombinatorAlias = U8;
 
 
@@ -13726,10 +13485,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2AuthPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2AuthPayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2AuthPayloadInnerCombinatorAlias = Mapped<Ikev2AuthPayloadInnerCombinator2, Ikev2AuthPayloadInnerMapper>;
 
 
@@ -13943,10 +13698,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2NoncePayloadInnerCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2NoncePayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2NoncePayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2NoncePayloadInnerMapper>;
 
 
@@ -14160,10 +13911,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2VendorIdPayloadInnerCombinat
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2VendorIdPayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2VendorIdPayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2VendorIdPayloadInnerMapper>;
 
 
@@ -14377,10 +14124,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SkPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for SkPayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type SkPayloadBodyCombinatorAlias = Mapped<bytes::Variable, SkPayloadBodyMapper>;
 
 
@@ -14644,10 +14387,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyProtocolIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyProtocolIdCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NotifyProtocolIdCombinatorAlias = TryMap<U8, NotifyProtocolIdMapper>;
 
 
@@ -14865,10 +14604,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2NotifyPayloadInnerCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2NotifyPayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2NotifyPayloadInnerCombinatorAlias = Mapped<Pair<Pair<NotifyProtocolIdCombinator, IpsecSpiSizeOrNoneCombinator, Ikev2NotifyPayloadInnerCont1>, (NotifyMsgTypeCombinator, (bytes::Variable, bytes::Tail)), Ikev2NotifyPayloadInnerCont0>, Ikev2NotifyPayloadInnerMapper>;
 
 
@@ -15105,10 +14840,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadSpisIpsecCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DeletePayloadSpisIpsecCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type DeletePayloadSpisIpsecCombinatorAlias = RepeatN<U32Be>;
 
 
@@ -15346,10 +15077,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapMessageReqRespCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for EapMessageReqRespCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type EapMessageReqRespCombinatorAlias = Mapped<Pair<(Refined<EapCodeCombinator, Predicate8053454275691315570>, (U8, Refined<U16Be, Predicate7010197279221949030>)), (U8, bytes::Variable), EapMessageReqRespCont0>, EapMessageReqRespMapper>;
 
 
@@ -15619,10 +15346,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodySpi4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodySpi4Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NotifyPayloadBodySpi4CombinatorAlias = Mapped<NotifyPayloadBodySpi4Combinator1, NotifyPayloadBodySpi4Mapper>;
 
 
@@ -15867,10 +15590,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodyRestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodyRestCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NotifyPayloadBodyRestCombinatorAlias = AndThen<bytes::Variable, Mapped<NotifyPayloadBodyRestCombinator1, NotifyPayloadBodyRestMapper>>;
 
 
@@ -16098,10 +15817,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NotifyPayloadBodyCombinatorAlias = Mapped<Pair<Pair<NotifyProtocolIdCombinator, IpsecSpiSizeOrNoneCombinator, NotifyPayloadBodyCont1>, (NotifyMsgTypeCombinator, NotifyPayloadBodyRestCombinator), NotifyPayloadBodyCont0>, NotifyPayloadBodyMapper>;
 
 
@@ -16439,10 +16154,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CertPayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CertPayloadBodyCombinatorAlias = Mapped<CertPayloadBodyCombinator1, CertPayloadBodyMapper>;
 
 
@@ -16677,10 +16388,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsPayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TsPayloadBodyCombinatorAlias = Mapped<Pair<Refined<U8, Predicate3651688686135228051>, (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, AndThen<bytes::Variable, RepeatN<TrafficSelectorCombinator>>), TsPayloadBodyCont0>, TsPayloadBodyMapper>;
 
 
@@ -16954,10 +16661,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for VendorIdPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for VendorIdPayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type VendorIdPayloadBodyCombinatorAlias = Mapped<bytes::Variable, VendorIdPayloadBodyMapper>;
 
 
@@ -17214,10 +16917,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PayloadCriticalCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PayloadCriticalCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type PayloadCriticalCombinatorAlias = TryMap<U8, PayloadCriticalMapper>;
 
 
@@ -17454,10 +17153,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadBodySpisCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DeletePayloadBodySpisCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type DeletePayloadBodySpisCombinatorAlias = Mapped<DeletePayloadBodySpisCombinator1, DeletePayloadBodySpisMapper>;
 
 
@@ -17680,10 +17375,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DeletePayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type DeletePayloadBodyCombinatorAlias = Mapped<Pair<Pair<Pair<IkeProtocolIdCombinator, IpsecSpiSizeOrNoneCombinator, DeletePayloadBodyCont2>, U16Be, DeletePayloadBodyCont1>, DeletePayloadBodySpisCombinator, DeletePayloadBodyCont0>, DeletePayloadBodyMapper>;
 
 
@@ -18044,10 +17735,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeMessageCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IkeMessageCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type IkeMessageCombinatorAlias = Mapped<Pair<IkeHeaderCombinator, bytes::Variable, IkeMessageCont0>, IkeMessageMapper>;
 
 
@@ -18327,10 +18014,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GenericPayloadHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for GenericPayloadHeaderCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type GenericPayloadHeaderCombinatorAlias = Mapped<GenericPayloadHeaderCombinator2, GenericPayloadHeaderMapper>;
 
 
@@ -18544,10 +18227,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2SkPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2SkPayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2SkPayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2SkPayloadInnerMapper>;
 
 
@@ -18833,10 +18512,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TsIpv4Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TsIpv4CombinatorAlias = Mapped<TsIpv4Combinator6, TsIpv4Mapper>;
 
 
@@ -19079,10 +18754,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2CpPayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2CpPayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2CpPayloadInnerCombinatorAlias = Mapped<Ikev2CpPayloadInnerCombinator2, Ikev2CpPayloadInnerMapper>;
 
 
@@ -19319,10 +18990,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2KePayloadInnerCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2KePayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2KePayloadInnerCombinatorAlias = Mapped<Ikev2KePayloadInnerCombinator2, Ikev2KePayloadInnerMapper>;
 
 
@@ -19565,10 +19232,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AuthPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AuthPayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type AuthPayloadBodyCombinatorAlias = Mapped<AuthPayloadBodyCombinator2, AuthPayloadBodyMapper>;
 
 
@@ -19819,10 +19482,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IdPayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for IdPayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type IdPayloadBodyCombinatorAlias = Mapped<IdPayloadBodyCombinator2, IdPayloadBodyMapper>;
 
 
@@ -20054,10 +19713,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2CertreqPayloadInnerCombinato
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2CertreqPayloadInnerCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2CertreqPayloadInnerCombinatorAlias = Mapped<Ikev2CertreqPayloadInnerCombinator1, Ikev2CertreqPayloadInnerMapper>;
 
 
@@ -20542,10 +20197,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2PayloadBodyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2PayloadBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2PayloadBodyCombinatorAlias = Mapped<Ikev2PayloadBodyCombinator16, Ikev2PayloadBodyMapper>;
 
 
@@ -20762,10 +20413,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2PayloadCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Ikev2PayloadCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Ikev2PayloadCombinatorAlias = Mapped<Pair<GenericPayloadHeaderCombinator, AndThen<bytes::Variable, Ikev2PayloadBodyCombinator>, Ikev2PayloadCont0>, Ikev2PayloadMapper>;
 
 
diff --git a/vest-dsl/test/src/josh.rs b/vest-dsl/test/src/josh.rs
index b2cdfba2..7eba048c 100644
--- a/vest-dsl/test/src/josh.rs
+++ b/vest-dsl/test/src/josh.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -156,10 +151,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TstTagCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TstTagCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TstTagCombinatorAlias = U8;
 
 
@@ -375,10 +366,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MydataCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MydataCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MydataCombinatorAlias = Mapped<MydataCombinator1, MydataMapper>;
 
 
@@ -1087,10 +1074,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TstMydataCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TstMydataCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TstMydataCombinatorAlias = Mapped<TstMydataCombinator30, TstMydataMapper>;
 
 
@@ -1307,10 +1290,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TstCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for TstCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type TstCombinatorAlias = Mapped<Pair<TstTagCombinator, TstMydataCombinator, TstCont0>, TstMapper>;
 
 
@@ -1736,10 +1715,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PairStressCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PairStressCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type PairStressCombinatorAlias = Mapped<PairStressCombinator14, PairStressMapper>;
 
 
diff --git a/vest-dsl/test/src/length_expr.rs b/vest-dsl/test/src/length_expr.rs
index f9454f17..83ff1034 100644
--- a/vest-dsl/test/src/length_expr.rs
+++ b/vest-dsl/test/src/length_expr.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -188,10 +183,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for HeaderCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type HeaderCombinatorAlias = Mapped<Pair<Refined<U16Le, Predicate12905524399844557818>, U8, HeaderCont0>, HeaderMapper>;
 
 
@@ -380,10 +371,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeaderAliasCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for HeaderAliasCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type HeaderAliasCombinatorAlias = HeaderCombinator;
 
 
@@ -589,10 +576,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DivideCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DivideCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type DivideCombinatorAlias = Mapped<bytes::Variable, DivideMapper>;
 
 
@@ -839,10 +822,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FixedChoiceCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for FixedChoiceCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type FixedChoiceCombinatorAlias = Mapped<FixedChoiceCombinator1, FixedChoiceMapper>;
 
 
@@ -1050,10 +1029,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SimpleSubCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for SimpleSubCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type SimpleSubCombinatorAlias = Mapped<bytes::Variable, SimpleSubMapper>;
 
 
@@ -1275,10 +1250,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AliasSizeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for AliasSizeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type AliasSizeCombinatorAlias = Mapped<bytes::Fixed<3>, AliasSizeMapper>;
 
 
@@ -1492,10 +1463,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MultiArithCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MultiArithCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MultiArithCombinatorAlias = Mapped<bytes::Variable, MultiArithMapper>;
 
 
@@ -1722,10 +1689,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SizeArithCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for SizeArithCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type SizeArithCombinatorAlias = Mapped<bytes::Fixed<4>, SizeArithMapper>;
 
 
@@ -1939,10 +1902,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PayloadWithHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PayloadWithHeaderCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type PayloadWithHeaderCombinatorAlias = Mapped<bytes::Variable, PayloadWithHeaderMapper>;
 
 
@@ -2164,10 +2123,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MixedConstCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MixedConstCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MixedConstCombinatorAlias = Mapped<bytes::Variable, MixedConstMapper>;
 
 
@@ -2318,10 +2273,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceTagCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ChoiceTagCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ChoiceTagCombinatorAlias = bytes::Fixed<2>;
 
 
@@ -2527,10 +2478,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NamedSizeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for NamedSizeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type NamedSizeCombinatorAlias = Mapped<bytes::Fixed<3>, NamedSizeMapper>;
 
 
@@ -2744,10 +2691,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceFormatSizeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ChoiceFormatSizeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ChoiceFormatSizeCombinatorAlias = Mapped<bytes::Fixed<2>, ChoiceFormatSizeMapper>;
 
 
@@ -2890,10 +2833,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeaderBytesCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for HeaderBytesCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type HeaderBytesCombinatorAlias = AndThen<bytes::Variable, HeaderCombinator>;
 
 
@@ -3099,10 +3038,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MultiplyCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MultiplyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MultiplyCombinatorAlias = Mapped<bytes::Variable, MultiplyMapper>;
 
 
@@ -3355,10 +3290,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceArraysFoldedBodyCombinator
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ChoiceArraysFoldedBodyCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ChoiceArraysFoldedBodyCombinatorAlias = Mapped<ChoiceArraysFoldedBodyCombinator1, ChoiceArraysFoldedBodyMapper>;
 
 
@@ -3569,10 +3500,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceArraysFoldedCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ChoiceArraysFoldedCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ChoiceArraysFoldedCombinatorAlias = Mapped<Pair<ChoiceTagCombinator, ChoiceArraysFoldedBodyCombinator, ChoiceArraysFoldedCont0>, ChoiceArraysFoldedMapper>;
 
 
@@ -3832,10 +3759,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParenExprCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ParenExprCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ParenExprCombinatorAlias = Mapped<bytes::Variable, ParenExprMapper>;
 
 
@@ -4067,10 +3990,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ReinterpretSizeCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ReinterpretSizeCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ReinterpretSizeCombinatorAlias = Mapped<bytes::Fixed<3>, ReinterpretSizeMapper>;
 
 
@@ -4294,10 +4213,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PrimitiveSizesCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PrimitiveSizesCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type PrimitiveSizesCombinatorAlias = Mapped<PrimitiveSizesCombinator1, PrimitiveSizesMapper>;
 
 
diff --git a/vest-dsl/test/src/matches.rs b/vest-dsl/test/src/matches.rs
index 222572af..19f8f680 100644
--- a/vest-dsl/test/src/matches.rs
+++ b/vest-dsl/test/src/matches.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -196,10 +191,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg5ContentCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg5ContentCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg5ContentCombinatorAlias = Mapped<Msg5ContentCombinator1, Msg5ContentMapper>;
 
 
@@ -336,10 +327,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HelloRetryRequestCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for HelloRetryRequestCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type HelloRetryRequestCombinatorAlias = U16Le;
 
 
@@ -474,10 +461,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerHelloCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ServerHelloCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ServerHelloCombinatorAlias = U32Le;
 
 
@@ -714,10 +697,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg1PayloadCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg1PayloadCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg1PayloadCombinatorAlias = Mapped<Msg1PayloadCombinator1, Msg1PayloadMapper>;
 
 
@@ -956,10 +935,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg4ContentCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg4ContentCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg4ContentCombinatorAlias = Mapped<Msg4ContentCombinator1, Msg4ContentMapper>;
 
 
@@ -1230,10 +1205,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg3ContentCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg3ContentCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg3ContentCombinatorAlias = Mapped<Msg3ContentCombinator3, Msg3ContentMapper>;
 
 
@@ -1444,10 +1415,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg3Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg3Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg3CombinatorAlias = Mapped<Pair<U8, Msg3ContentCombinator, Msg3Cont0>, Msg3Mapper>;
 
 
@@ -1710,10 +1677,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg5Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg5Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg5CombinatorAlias = Mapped<Pair<BtcVarint, Msg5ContentCombinator, Msg5Cont0>, Msg5Mapper>;
 
 
@@ -2004,10 +1967,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg2ContentCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg2ContentCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg2ContentCombinatorAlias = Mapped<Msg2ContentCombinator1, Msg2ContentMapper>;
 
 
@@ -2218,10 +2177,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg1Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg1Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg1CombinatorAlias = Mapped<Pair<bytes::Fixed<32>, Msg1PayloadCombinator, Msg1Cont0>, Msg1Mapper>;
 
 
@@ -2484,10 +2439,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg2Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg2Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg2CombinatorAlias = Mapped<Pair<bytes::Fixed<3>, Msg2ContentCombinator, Msg2Cont0>, Msg2Mapper>;
 
 
@@ -2750,10 +2701,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Msg4Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for Msg4Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type Msg4CombinatorAlias = Mapped<Pair<U24Le, Msg4ContentCombinator, Msg4Cont0>, Msg4Mapper>;
 
 
diff --git a/vest-dsl/test/src/nested_access.rs b/vest-dsl/test/src/nested_access.rs
index 493ef248..fc4a3a80 100644
--- a/vest-dsl/test/src/nested_access.rs
+++ b/vest-dsl/test/src/nested_access.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -207,10 +202,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GenericHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for GenericHeaderCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type GenericHeaderCombinatorAlias = Mapped<GenericHeaderCombinator2, GenericHeaderMapper>;
 
 
@@ -434,10 +425,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OuterHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for OuterHeaderCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type OuterHeaderCombinatorAlias = Mapped<OuterHeaderCombinator1, OuterHeaderMapper>;
 
 
@@ -654,10 +641,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PayloadWithHeaderCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for PayloadWithHeaderCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type PayloadWithHeaderCombinatorAlias = Mapped<Pair<GenericHeaderCombinator, bytes::Variable, PayloadWithHeaderCont0>, PayloadWithHeaderMapper>;
 
 
@@ -918,10 +901,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeepNestedCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for DeepNestedCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type DeepNestedCombinatorAlias = Mapped<Pair<OuterHeaderCombinator, bytes::Variable, DeepNestedCont0>, DeepNestedMapper>;
 
 
@@ -1182,10 +1161,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CombinedExampleCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for CombinedExampleCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type CombinedExampleCombinatorAlias = Mapped<Pair<GenericHeaderCombinator, bytes::Variable, CombinedExampleCont0>, CombinedExampleMapper>;
 
 
diff --git a/vest-dsl/test/src/opt.rs b/vest-dsl/test/src/opt.rs
index e5144a90..64a38997 100644
--- a/vest-dsl/test/src/opt.rs
+++ b/vest-dsl/test/src/opt.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -101,10 +96,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ACombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ACombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ACombinatorAlias = Terminated<Preceded<Tag<U8, u8>, Preceded<Tag<U8, u8>, bytes::Fixed<10>>>, Tag<U8, u8>>;
 
 
@@ -330,10 +321,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for BCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for BCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type BCombinatorAlias = Mapped<BCombinator1, BMapper>;
 
 
@@ -565,10 +552,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for MsgCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type MsgCombinatorAlias = Mapped<MsgCombinator1, MsgMapper>;
 
 
@@ -711,10 +694,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OptmsgCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for OptmsgCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type OptmsgCombinatorAlias = Opt<MsgCombinator>;
 
 
diff --git a/vest-dsl/test/src/repeat.rs b/vest-dsl/test/src/repeat.rs
index 92d5e762..c630af4d 100644
--- a/vest-dsl/test/src/repeat.rs
+++ b/vest-dsl/test/src/repeat.rs
@@ -31,11 +31,6 @@ macro_rules! impl_wrapper_combinator {
                 fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
                 { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
             }
-
-            impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-                { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-            }
         } // verus!
     };
 }
@@ -188,10 +183,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OpaqueU16Combinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for OpaqueU16Combinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type OpaqueU16CombinatorAlias = Mapped<Pair<Refined<U16Le, Predicate17626095872143391426>, bytes::Variable, OpaqueU16Cont0>, OpaqueU16Mapper>;
 
 
@@ -380,10 +371,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for RepeatFixCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for RepeatFixCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type RepeatFixCombinatorAlias = RepeatN<U16Le>;
 
 
@@ -518,10 +505,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ResponderIdCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ResponderIdCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ResponderIdCombinatorAlias = OpaqueU16Combinator;
 
 
@@ -750,10 +733,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ResponderIdListCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for ResponderIdListCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type ResponderIdListCombinatorAlias = Mapped<Pair<Refined<U16Le, Predicate2984462868727922620>, AndThen<bytes::Variable, Repeat<ResponderIdCombinator>>, ResponderIdListCont0>, ResponderIdListMapper>;
 
 
@@ -1016,10 +995,6 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for RepeatDynCombinator {
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl<'a> SecureSerialize<'a, &'a [u8], Vec<u8>> for RepeatDynCombinator {
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    { <_ as SecureSerialize<'a, &'a [u8], Vec<u8>>>::secure_serialize(&self.0, v, data, pos) }
-}
 pub type RepeatDynCombinatorAlias = Mapped<Pair<BtcVarint, RepeatN<ResponderIdListCombinator>, RepeatDynCont0>, RepeatDynMapper>;
 
 
diff --git a/vest/src/infallible.rs b/vest/src/infallible.rs
index 60391a7d..86958d27 100644
--- a/vest/src/infallible.rs
+++ b/vest/src/infallible.rs
@@ -1,71 +1,14 @@
 use crate::properties::*;
-use crate::regular::bytes::{Fixed, Tail, Variable};
-use crate::regular::end::End;
-use crate::regular::modifier::{
-    AndThen, Cond, Iso, IsoFn, Mapped, PartialIso, PartialIsoFn, Pred, Refined, SpecIsoProof,
-    SpecPartialIsoProof, SpecPred, TryMap,
-};
-use crate::regular::sequence::{Continuation, GhostFn, POrSType, Pair, Preceded, Terminated};
-use crate::regular::success::Success;
-use crate::regular::uints::*;
-use crate::regular::variant::{Choice, Either};
-use crate::bitcoin::varint::BtcVarint;
-
-use alloc::boxed::Box;
-use alloc::vec::Vec;
-use crate::regular::disjoint::DisjointFrom;
-use core::mem::size_of;
 use vstd::prelude::*;
 
 verus! {
 
-/// A combinator whose serialization is guaranteed to succeed when the buffer
-/// has sufficient space.
-///
-/// This trait extends [`Combinator`] with a stronger serialization contract:
-/// when `serialize` returns `Err`, it is guaranteed that the buffer was too
-/// small. Combined with the existing `Ok` ensures, this means that if you
-/// pre-allocate a buffer of the right size (via [`Combinator::length`]),
-/// serialization is infallible.
-///
-/// ## Usage
+/// Infallible serialization for any [`Combinator`] when the buffer is large enough.
 ///
-/// Use [`serialize_infallible`] for a convenient wrapper that returns `usize`
-/// instead of `Result`.
-pub trait SecureSerialize<'x, I, O>: Combinator<'x, I, O> where
-    I: VestInput,
-    O: VestOutput<I>,
-    Self::V: SecureSpecCombinator<Type = <Self::Type as View>::V>,
-{
-    /// Serialization with a stronger error guarantee.
-    ///
-    /// In addition to the postconditions of [`Combinator::serialize`], this
-    /// method guarantees that if it returns `Err`, the buffer was too small
-    /// to hold the serialized value.
-    fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >)
-        requires
-            self@.requires(),
-            self.ex_requires(),
-            self@.wf(v@),
-            pos <= old(buf)@.len() <= usize::MAX,
-        ensures
-            res matches Ok(n) ==> {
-                &&& buf@.len() == old(buf)@.len()
-                &&& pos <= usize::MAX - n && pos + n <= buf@.len()
-                &&& n == self@.spec_serialize(v@).len()
-                &&& buf@ == seq_splice(old(buf)@, pos, self@.spec_serialize(v@))
-            },
-            res is Err ==> pos + self@.spec_serialize(v@).len() > old(buf)@.len(),
-    ;
-}
-
-/// Infallible serialization for combinators that implement [`SecureSerialize`].
-///
-/// Returns the number of bytes written. Guaranteed to succeed when the buffer
-/// has enough space, as computed by [`Combinator::length`].
+/// Returns the number of bytes written. Guaranteed to succeed because the
+/// precondition requires the buffer to have sufficient space, and the
+/// strengthened [`Combinator::serialize`] ensures that `Err` can only occur
+/// when the buffer is too small — a contradiction with the precondition.
 pub fn serialize_infallible<'x, I, O, C>(
     combinator: &C,
     v: C::SType,
@@ -75,7 +18,7 @@ pub fn serialize_infallible<'x, I, O, C>(
     where
         I: VestInput,
         O: VestOutput<I>,
-        C: SecureSerialize<'x, I, O>,
+        C: Combinator<'x, I, O>,
         C::V: SecureSpecCombinator<Type = <C::Type as View>::V>,
     requires
         combinator@.requires(),
@@ -89,662 +32,13 @@ pub fn serialize_infallible<'x, I, O, C>(
         n == combinator@.spec_serialize(v@).len(),
         buf@ == seq_splice(old(buf)@, pos, combinator@.spec_serialize(v@)),
 {
-    let res = combinator.secure_serialize(v, buf, pos);
-    match res {
+    match combinator.serialize(v, buf, pos) {
         Ok(n) => n,
         Err(_) => {
-            // The error ensures tells us:
-            //   pos + spec_serialize(v@).len() > old(buf)@.len()
-            // But our precondition says:
-            //   pos + spec_serialize(v@).len() <= old(buf)@.len()
-            // Contradiction => unreachable.
             proof { assert(false); }
             0
         }
     }
 }
 
-//////////////////////////////////////////////////////////////////////////////
-// Leaf combinator impls
-//////////////////////////////////////////////////////////////////////////////
-
-impl<'x, I: VestInput + 'x, O: VestOutput<I>> SecureSerialize<'x, I, O> for Variable {
-    fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        if v.len() <= buf.len() && pos <= buf.len() - v.len() {
-            buf.set_range(pos, &v);
-            assert(buf@.subrange(pos as int, pos + self.0 as int) == self@.spec_serialize(v@));
-            Ok(self.0)
-        } else {
-            Err(SerializeError::InsufficientBuffer)
-        }
-    }
-}
-
-impl<'x, const N: usize, I: VestInput + 'x, O: VestOutput<I>> SecureSerialize<'x, I, O> for Fixed<
-    N,
-> {
-    fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        if v.len() <= buf.len() && pos <= buf.len() - v.len() {
-            buf.set_range(pos, &v);
-            assert(buf@.subrange(pos as int, pos + N as int) == self@.spec_serialize(v@));
-            Ok(N)
-        } else {
-            Err(SerializeError::InsufficientBuffer)
-        }
-    }
-}
-
-impl<'x, I: VestInput + 'x, O: VestOutput<I>> SecureSerialize<'x, I, O> for Tail {
-    fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        if v.len() <= buf.len() - pos {
-            buf.set_range(pos, &v);
-            assert(buf@.subrange(pos as int, pos + v@.len() as int) == self@.spec_serialize(v@));
-            Ok(v.len())
-        } else {
-            Err(SerializeError::InsufficientBuffer)
-        }
-    }
-}
-
-impl<'x, I: VestInput, O: VestOutput<I>> SecureSerialize<'x, I, O> for Success {
-    fn secure_serialize(&self, _v: Self::SType, _buf: &mut O, _pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        assert(seq_splice(_buf@, _pos, Seq::<u8>::empty()) == _buf@);
-        Ok(0)
-    }
-}
-
-impl<'x, I: VestInput, O: VestOutput<I>> SecureSerialize<'x, I, O> for End {
-    fn secure_serialize(&self, _v: Self::SType, _buf: &mut O, _pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        assert(seq_splice(_buf@, _pos, Seq::<u8>::empty()) == _buf@);
-        Ok(0)
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// Uint combinator impls via macros
-//////////////////////////////////////////////////////////////////////////////
-
-} // verus!
-
-macro_rules! impl_secure_serialize_for_le_uint {
-    ($combinator:ty, $int_type:ty) => {
-        ::vstd::prelude::verus! {
-            impl<'x, I: VestPublicInput, O: VestPublicOutput<I>> SecureSerialize<'x, I, O> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
-                    usize,
-                    SerializeError,
-                >) {
-                    if size_of::<$int_type>() <= buf.len() - pos {
-                        $int_type::ex_to_le_bytes(&v, buf, pos);
-                        proof {
-                            v.reflex();
-                            assert(buf@.subrange(pos as int, pos + size_of::<$int_type>() as int)
-                                == self.spec_serialize(v@));
-                        }
-                        Ok(size_of::<$int_type>())
-                    } else {
-                        Err(SerializeError::InsufficientBuffer)
-                    }
-                }
-            }
-        }
-    };
-}
-
-macro_rules! impl_secure_serialize_for_be_uint {
-    ($combinator:ty, $int_type:ty) => {
-        ::vstd::prelude::verus! {
-            impl<'x, I: VestPublicInput, O: VestPublicOutput<I>> SecureSerialize<'x, I, O> for $combinator {
-                fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
-                    usize,
-                    SerializeError,
-                >) {
-                    if size_of::<$int_type>() <= buf.len() - pos {
-                        $int_type::ex_to_be_bytes(&v, buf, pos);
-                        proof {
-                            v.reflex();
-                            assert(buf@.subrange(pos as int, pos + size_of::<$int_type>() as int)
-                                == self.spec_serialize(v@));
-                        }
-                        Ok(size_of::<$int_type>())
-                    } else {
-                        Err(SerializeError::InsufficientBuffer)
-                    }
-                }
-            }
-        }
-    };
-}
-
-impl_secure_serialize_for_le_uint!(U8, u8);
-impl_secure_serialize_for_le_uint!(U16Le, u16);
-impl_secure_serialize_for_le_uint!(U32Le, u32);
-impl_secure_serialize_for_le_uint!(U64Le, u64);
-
-impl_secure_serialize_for_be_uint!(U16Be, u16);
-impl_secure_serialize_for_be_uint!(U32Be, u32);
-impl_secure_serialize_for_be_uint!(U64Be, u64);
-
-//////////////////////////////////////////////////////////////////////////////
-// Delegating combinator impls
-// These just forward to the inner combinator's secure_serialize.
-//////////////////////////////////////////////////////////////////////////////
-
-verus! {
-
-/// Mapped: spec_serialize delegates to inner, so error ensures propagates.
-impl<'x, I, O, Inner, M> SecureSerialize<'x, I, O> for Mapped<Inner, M> where
-    I: VestInput,
-    O: VestOutput<I>,
-    Inner: SecureSerialize<'x, I, O>,
-    Inner::V: SecureSpecCombinator<Type = <Inner::Type as View>::V>,
-    M: Iso<'x, Src = Inner::Type, RefSrc = Inner::SType>,
-    M::Dst: From<Inner::Type> + View,
-    Inner::SType: From<&'x M::Dst> + View,
-    M::V: SpecIsoProof<Src = <Inner::Type as View>::V, Dst = <M::Dst as View>::V>,
-    <Inner::Type as View>::V: SpecFrom<<M::Dst as View>::V>,
-    <M::Dst as View>::V: SpecFrom<<Inner::Type as View>::V>,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        self.inner.secure_serialize(M::rev_apply(v), data, pos)
-    }
-}
-
-/// TryMap: spec_serialize delegates to inner via reverse mapping.
-impl<'x, I, O, Inner, M> SecureSerialize<'x, I, O> for TryMap<Inner, M> where
-    I: VestInput,
-    O: VestOutput<I>,
-    Inner: SecureSerialize<'x, I, O>,
-    Inner::V: SecureSpecCombinator<Type = <Inner::Type as View>::V>,
-    M: PartialIso<'x, Src = Inner::Type, RefSrc = Inner::SType>,
-    M::Dst: TryFrom<Inner::Type> + View,
-    Inner::SType: TryFrom<&'x M::Dst> + View,
-    M::V: SpecPartialIsoProof<Src = <Inner::Type as View>::V, Dst = <M::Dst as View>::V>,
-    <Inner::Type as View>::V: SpecTryFrom<<M::Dst as View>::V>,
-    <M::Dst as View>::V: SpecTryFrom<<Inner::Type as View>::V>,
-    <Inner::SType as TryFrom<&'x M::Dst>>::Error: core::fmt::Debug,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        self.inner.secure_serialize(M::rev_apply(v).unwrap(), data, pos)
-    }
-}
-
-/// Refined: spec_serialize delegates to inner.
-impl<'x, I, O, Inner, P> SecureSerialize<'x, I, O> for Refined<Inner, P> where
-    I: VestInput,
-    O: VestOutput<I>,
-    Inner: SecureSerialize<'x, I, O, SType = &'x <Inner as Combinator<'x, I, O>>::Type>,
-    Inner::V: SecureSpecCombinator<Type = <Inner::Type as View>::V>,
-    P: Pred<Inner::Type>,
-    P::V: SpecPred<<Inner::Type as View>::V>,
-    Inner::Type: 'x,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        self.inner.secure_serialize(v, data, pos)
-    }
-}
-
-/// Cond: spec_serialize delegates to inner (cond must be true from wf).
-impl<'x, I: VestInput, O: VestOutput<I>, Inner: SecureSerialize<'x, I, O>> SecureSerialize<
-    'x,
-    I,
-    O,
-> for Cond<Inner> where Inner::V: SecureSpecCombinator<Type = <Inner::Type as View>::V> {
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        self.inner.secure_serialize(v, data, pos)
-    }
-}
-
-/// AndThen<Variable, Next>: spec_serialize delegates to Next.
-impl<'x, I, O, Next: SecureSerialize<'x, I, O>> SecureSerialize<'x, I, O> for AndThen<
-    Variable,
-    Next,
-> where
-    I: VestInput,
-    O: VestOutput<I>,
-    Next::V: SecureSpecCombinator<Type = <Next::Type as View>::V>,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        let n = self.1.secure_serialize(v, data, pos)?;
-        Ok(n)
-    }
-}
-
-/// AndThen<Tail, Next>: spec_serialize delegates to Next.
-impl<'x, I, O, Next: SecureSerialize<'x, I, O>> SecureSerialize<'x, I, O> for AndThen<
-    Tail,
-    Next,
-> where
-    I: VestInput,
-    O: VestOutput<I>,
-    Next::V: SecureSpecCombinator<Type = <Next::Type as View>::V>,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        let n = self.1.secure_serialize(v, data, pos)?;
-        Ok(n)
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// Composite combinator impls
-//////////////////////////////////////////////////////////////////////////////
-
-/// Choice: spec_serialize picks one branch, error ensures propagates directly.
-impl<'x, I, O, Fst, Snd> SecureSerialize<'x, I, O> for Choice<Fst, Snd> where
-    I: VestInput,
-    O: VestOutput<I>,
-    Fst: SecureSerialize<'x, I, O>,
-    Snd: SecureSerialize<'x, I, O>,
-    Fst::V: SecureSpecCombinator<Type = <Fst::Type as View>::V>,
-    Snd::V: SecureSpecCombinator<Type = <Snd::Type as View>::V>,
-    Snd::V: DisjointFrom<Fst::V>,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        match v {
-            Either::Left(v) => {
-                let n = self.0.secure_serialize(v, data, pos)?;
-                Ok(n)
-            },
-            Either::Right(v) => {
-                let n = self.1.secure_serialize(v, data, pos)?;
-                Ok(n)
-            },
-        }
-    }
-}
-
-/// Pair: sequential serialization. Error from either component implies
-/// total serialized length exceeds buffer.
-impl<'x, I, O, Fst, Snd, Cont> SecureSerialize<'x, I, O> for Pair<Fst, Snd, Cont> where
-    I: VestInput,
-    O: VestOutput<I>,
-    Fst: SecureSerialize<'x, I, O>,
-    Snd: SecureSerialize<'x, I, O>,
-    Fst::V: SecureSpecCombinator<Type = <Fst::Type as View>::V>,
-    Snd::V: SecureSpecCombinator<Type = <Snd::Type as View>::V>,
-    Fst::SType: Copy,
-    Cont: for<'a> Continuation<POrSType<&'a Fst::Type, Fst::SType>, Output = Snd>,
-    Cont: View<V = GhostFn<<Fst::Type as View>::V, Snd::V>>,
-    <Fst as Combinator<'x, I, O>>::Type: 'x,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        proof {
-            assert(self.fst@.wf(v.0@));
-        }
-        let snd = self.snd.apply(POrSType::S(v.0));
-        let n = match self.fst.secure_serialize(v.0, data, pos) {
-            Ok(n) => n,
-            Err(e) => {
-                proof {
-                    // fst error: pos + fst.spec_serialize(v.0).len() > buf.len()
-                    // total >= fst, so pos + total > buf.len()
-                    assert(self@.spec_serialize(v@).len() >= self.fst@.spec_serialize(v.0@).len());
-                }
-                return Err(e);
-            }
-        };
-        let m = match snd.secure_serialize(v.1, data, pos + n) {
-            Ok(m) => m,
-            Err(e) => {
-                proof {
-                    // snd error: (pos+n) + snd.spec_serialize(v.1).len() > buf.len()
-                    // n == fst.spec_serialize(v.0).len(), buf.len() == old(buf).len()
-                    // so pos + fst_len + snd_len > old(buf).len() == total
-                    assert(self@.spec_serialize(v@).len() == self.fst@.spec_serialize(v.0@).len() + (self.snd@)(v.0@).spec_serialize(v.1@).len());
-                }
-                return Err(e);
-            }
-        };
-        assert(data@ == seq_splice(old(data)@, pos, self@.spec_serialize(v@)));
-        Ok(n + m)
-    }
-}
-
-/// Tuple (Fst, Snd): same as Pair but for non-dependent sequencing.
-impl<'x, Fst, Snd, I, O> SecureSerialize<'x, I, O> for (Fst, Snd) where
-    I: VestInput,
-    O: VestOutput<I>,
-    Fst: SecureSerialize<'x, I, O>,
-    Snd: SecureSerialize<'x, I, O>,
-    Fst::V: SecureSpecCombinator<Type = <Fst::Type as View>::V>,
-    Snd::V: SecureSpecCombinator<Type = <Snd::Type as View>::V>,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        proof {
-            assert(self.0@.wf(v.0@));
-        }
-        let n = match self.0.secure_serialize(v.0, data, pos) {
-            Ok(n) => n,
-            Err(e) => {
-                proof {
-                    assert(self@.spec_serialize(v@).len() >= self.0@.spec_serialize(v.0@).len());
-                }
-                return Err(e);
-            }
-        };
-        let m = match self.1.secure_serialize(v.1, data, pos + n) {
-            Ok(m) => m,
-            Err(e) => {
-                proof {
-                    assert(self@.spec_serialize(v@).len() == self.0@.spec_serialize(v.0@).len() + self.1@.spec_serialize(v.1@).len());
-                }
-                return Err(e);
-            }
-        };
-        assert(data@ == seq_splice(old(data)@, pos, self@.spec_serialize(v@)));
-        Ok(n + m)
-    }
-}
-
-/// &C delegates to C.
-impl<'x, I, O, C: SecureSerialize<'x, I, O>> SecureSerialize<'x, I, O> for &C where
-    I: VestInput,
-    O: VestOutput<I>,
-    C::V: SecureSpecCombinator<Type = <C::Type as View>::V>,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        (**self).secure_serialize(v, data, pos)
-    }
-}
-
-/// Box<C> delegates to C.
-impl<'x, I, O, C: SecureSerialize<'x, I, O>> SecureSerialize<'x, I, O> for Box<C> where
-    I: VestInput,
-    O: VestOutput<I>,
-    C::V: SecureSpecCombinator<Type = <C::Type as View>::V>,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        (**self).secure_serialize(v, data, pos)
-    }
-}
-
-/// Preceded: delegates to (&self.0, &self.1).
-impl<'x, I, O, Fst, Snd> SecureSerialize<'x, I, O> for Preceded<Fst, Snd> where
-    I: VestInput,
-    O: VestOutput<I>,
-    Fst: SecureSerialize<'x, I, O, Type = (), SType = ()>,
-    Snd: SecureSerialize<'x, I, O>,
-    Fst::V: SecureSpecCombinator<Type = ()>,
-    Snd::V: SecureSpecCombinator<Type = <Snd::Type as View>::V>,
-{
-    fn secure_serialize<'b>(&self, v: Self::SType, data: &'b mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        (&self.0, &self.1).secure_serialize(((), v), data, pos)
-    }
-}
-
-/// Terminated: delegates to (&self.0, &self.1).
-impl<'x, I, O, Fst, Snd> SecureSerialize<'x, I, O> for Terminated<Fst, Snd> where
-    I: VestInput,
-    O: VestOutput<I>,
-    Fst: SecureSerialize<'x, I, O>,
-    Snd: SecureSerialize<'x, I, O, Type = (), SType = ()>,
-    Fst::V: SecureSpecCombinator<Type = <Fst::Type as View>::V>,
-    Snd::V: SecureSpecCombinator<Type = ()>,
-{
-    fn secure_serialize<'b>(&self, v: Self::SType, data: &'b mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        (&self.0, &self.1).secure_serialize((v, ()), data, pos)
-    }
-}
-
-} // verus!
-
-//////////////////////////////////////////////////////////////////////////////
-// Tag combinator impls via macro
-//////////////////////////////////////////////////////////////////////////////
-
-macro_rules! impl_secure_serialize_for_uint_tag {
-    ($combinator:ty, $int_type:ty) => {
-        ::vstd::prelude::verus! {
-            impl<'x, I, O> SecureSerialize<'x, I, O> for crate::regular::tag::Tag<$combinator, $int_type> where
-                I: VestPublicInput,
-                O: VestPublicOutput<I>,
-            {
-                fn secure_serialize(&self, _v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<usize, SerializeError>) {
-                    self.0.secure_serialize(&self.0.predicate.0, data, pos)
-                }
-            }
-        }
-    };
-}
-
-impl_secure_serialize_for_uint_tag!(U8, u8);
-impl_secure_serialize_for_uint_tag!(U16Le, u16);
-impl_secure_serialize_for_uint_tag!(U32Le, u32);
-impl_secure_serialize_for_uint_tag!(U64Le, u64);
-impl_secure_serialize_for_uint_tag!(U16Be, u16);
-impl_secure_serialize_for_uint_tag!(U32Be, u32);
-impl_secure_serialize_for_uint_tag!(U64Be, u64);
-
-//////////////////////////////////////////////////////////////////////////////
-// Remaining combinator impls
-//////////////////////////////////////////////////////////////////////////////
-
-verus! {
-
-/// Tag<Fixed<N>, [u8; N]>: delegates to inner Refined.
-impl<'x, const N: usize> SecureSerialize<'x, &'x [u8], alloc::vec::Vec<u8>> for crate::regular::tag::Tag<
-    Fixed<N>,
-    [u8; N],
-> {
-    fn secure_serialize(&self, _v: Self::SType, data: &mut alloc::vec::Vec<u8>, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        self.0.secure_serialize(&self.0.predicate.0.as_slice(), data, pos)
-    }
-}
-
-/// Opt: Some delegates to inner, None always succeeds.
-impl<'x, I, O, T> SecureSerialize<'x, I, O> for crate::regular::variant::Opt<T> where
-    I: VestInput,
-    O: VestOutput<I>,
-    T: SecureSerialize<'x, I, O, SType = &'x <T as Combinator<'x, I, O>>::Type>,
-    T::V: SecureSpecCombinator<Type = <T::Type as View>::V>,
-    T::Type: 'x,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        match &v.0 {
-            Some(v) => self.0.secure_serialize(v, data, pos),
-            None => {
-                // spec_serialize for None is Seq::empty(), len 0
-                // precondition: pos <= buf.len(), so this always succeeds
-                if pos <= data.len() {
-                    assert(seq_splice(old(data)@, pos, Seq::<u8>::empty()) == data@);
-                    Ok(0)
-                } else {
-                    Err(SerializeError::InsufficientBuffer)
-                }
-            },
-        }
-    }
-}
-
-/// OptThen: sequential Opt + Snd.
-impl<'x, I, O, Fst, Snd> SecureSerialize<'x, I, O> for crate::regular::variant::OptThen<Fst, Snd> where
-    I: VestInput,
-    O: VestOutput<I>,
-    Fst: SecureSerialize<'x, I, O, SType = &'x <Fst as Combinator<'x, I, O>>::Type>,
-    Snd: SecureSerialize<'x, I, O>,
-    Fst::V: SecureSpecCombinator<Type = <Fst::Type as View>::V>,
-    Snd::V: SecureSpecCombinator<Type = <Snd::Type as View>::V>,
-    Snd::V: DisjointFrom<Fst::V>,
-    Fst::Type: 'x,
-{
-    fn secure_serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        let n = match self.0.0.secure_serialize(&v.0, data, pos) {
-            Ok(n) => n,
-            Err(e) => {
-                proof {
-                    assert(self@.spec_serialize(v@).len() >= self.0.0@.spec_serialize(v.0@).len());
-                }
-                return Err(e);
-            }
-        };
-        let m = match self.0.1.secure_serialize(v.1, data, pos + n) {
-            Ok(m) => m,
-            Err(e) => {
-                proof {
-                    assert(self@.spec_serialize(v@).len() == self.0.0@.spec_serialize(v.0@).len() + self.0.1@.spec_serialize(v.1@).len());
-                }
-                return Err(e);
-            }
-        };
-        Ok(n + m)
-    }
-}
-
-/// RepeatN: loop serialization. The error-implies-insufficient-buffer property
-/// follows from the inner combinator's property and the additive nature of
-/// fold_left, but the inductive proof is complex. We trust the ensures here
-/// since the runtime logic is identical to the verified RepeatN::serialize.
-impl<'x, I, O, C> SecureSerialize<'x, I, O> for crate::regular::repetition::RepeatN<C> where
-    I: VestInput,
-    O: VestOutput<I>,
-    C: SecureSerialize<'x, I, O, SType = &'x <C as Combinator<'x, I, O>>::Type>,
-    C::V: SecureSpecCombinator<Type = <C::Type as View>::V>,
-    <C as Combinator<'x, I, O>>::Type: 'x,
-{
-    #[verifier::external_body]
-    fn secure_serialize(&self, vs: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        self.serialize(vs, data, pos)
-    }
-}
-
-/// Repeat: delegates to RepeatN.
-impl<'x, I, O, C> SecureSerialize<'x, I, O> for crate::regular::repetition::Repeat<C> where
-    I: VestInput,
-    O: VestOutput<I>,
-    C: SecureSerialize<'x, I, O, SType = &'x <C as Combinator<'x, I, O>>::Type>,
-    C::V: SecureSpecCombinator<Type = <C::Type as View>::V>,
-    <C as Combinator<'x, I, O>>::Type: 'x,
-{
-    fn secure_serialize(&self, vs: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        crate::regular::repetition::RepeatN(&self.0, vs.0.len()).secure_serialize(vs, data, pos)
-    }
-}
-
-/// UnsignedLEB128: external_body (wrapping existing external_body serialize).
-impl<'x, I: VestPublicInput, O: VestPublicOutput<I>> SecureSerialize<'x, I, O> for crate::regular::leb128::UnsignedLEB128 {
-    #[verifier::external_body]
-    fn secure_serialize(&self, v: Self::SType, buf: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        self.serialize(v, buf, pos)
-    }
-}
-
-/// Tag<UnsignedLEB128, UInt>: delegates to inner Refined.
-impl<'x, I: VestPublicInput, O: VestPublicOutput<I>> SecureSerialize<'x, I, O> for crate::regular::tag::Tag<
-    crate::regular::leb128::UnsignedLEB128,
-    crate::regular::leb128::UInt,
-> {
-    fn secure_serialize(&self, _v: Self::SType, data: &mut O, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        self.0.secure_serialize(&self.0.predicate.0, data, pos)
-    }
-}
-
-/// U24Le: wraps Fixed<3> serialize (verified via Fixed<3>'s SecureSerialize).
-impl<'x> SecureSerialize<'x, &'x [u8], alloc::vec::Vec<u8>> for U24Le {
-    #[verifier::external_body]
-    fn secure_serialize(&self, v: Self::SType, data: &mut alloc::vec::Vec<u8>, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        self.serialize(v, data, pos)
-    }
-}
-
-/// U24Be: wraps Fixed<3> serialize (verified via Fixed<3>'s SecureSerialize).
-impl<'x> SecureSerialize<'x, &'x [u8], alloc::vec::Vec<u8>> for U24Be {
-    #[verifier::external_body]
-    fn secure_serialize(&self, v: Self::SType, data: &mut alloc::vec::Vec<u8>, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        self.serialize(v, data, pos)
-    }
-}
-
-/// BtcVarint: delegates to btc_varint_inner which is TryMap<Pair<U8, VarintChoice, ...>, ...>.
-/// All components have SecureSerialize, but btc_varint_inner() is module-private.
-impl<'x> SecureSerialize<'x, &'x [u8], Vec<u8>> for BtcVarint {
-    #[verifier::external_body]
-    fn secure_serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (res: SResult<
-        usize,
-        SerializeError,
-    >) {
-        self.serialize(v, data, pos)
-    }
-}
-
 } // verus!
diff --git a/vest/src/properties.rs b/vest/src/properties.rs
index 9aa82054..12bd53ae 100644
--- a/vest/src/properties.rs
+++ b/vest/src/properties.rs
@@ -288,6 +288,10 @@ pub trait Combinator<'x, I, O>: View where
                 &&& n == self@.spec_serialize(v@).len()
                 &&& buf@ == seq_splice(old(buf)@, pos, self@.spec_serialize(v@))
             },
+            res is Err ==> {
+                &&& buf@.len() == old(buf)@.len()
+                &&& pos + self@.spec_serialize(v@).len() > old(buf)@.len()
+            },
     ;
 }
 
diff --git a/vest/src/regular/repetition.rs b/vest/src/regular/repetition.rs
index 73584c5e..4b59de94 100644
--- a/vest/src/regular/repetition.rs
+++ b/vest/src/regular/repetition.rs
@@ -326,6 +326,26 @@ impl<C: SecureSpecCombinator> RepeatN<C> {
         self.lemma_spec_serialize_max_length(vs, n);
         assert(vs.take(vs.len() as int) == vs);
     }
+
+    /// Proves that spec_serialize is monotonically non-decreasing in prefix length:
+    /// spec_serialize(vs).len() >= spec_serialize(vs.take(k)).len() for any k <= vs.len().
+    proof fn lemma_spec_serialize_prefix_len(&self, vs: Seq<C::Type>, k: int)
+        requires
+            self.requires(),
+            0 <= k <= vs.len(),
+            forall|i: int| 0 <= i < vs.len() ==> #[trigger] self.0.wf(vs[i]),
+        ensures
+            self.spec_serialize(vs).len() >= self.spec_serialize(vs.take(k)).len(),
+        decreases vs.len() - k,
+    {
+        if k == vs.len() {
+            assert(vs.take(k) =~= vs);
+        } else {
+            assert(vs =~= vs.drop_last().push(vs.last()));
+            assert(vs.drop_last().take(k) =~= vs.take(k));
+            self.lemma_spec_serialize_prefix_len(vs.drop_last(), k);
+        }
+    }
 }
 
 impl<I, O, C, 'x> Combinator<'x, I, O> for RepeatN<C> where
@@ -419,6 +439,7 @@ impl<I, O, C, 'x> Combinator<'x, I, O> for RepeatN<C> where
         let old_pos = pos;
         assert(data@ == seq_splice(old(data)@, pos, Seq::<u8>::empty()));
         let ghost _vs = vs@;
+        let mut err: Option<SerializeError> = None;
         for i in 0..vs.0.len()
             invariant
                 data@.len() == old_data.len(),
@@ -427,22 +448,47 @@ impl<I, O, C, 'x> Combinator<'x, I, O> for RepeatN<C> where
                 self@.wf(_vs),
                 self.ex_requires(),
                 self@.requires(),
-                (pos - old_pos) == self@.spec_serialize(_vs.take(i as int)).len(),
-                data@ == seq_splice(old_data, old_pos, self@.spec_serialize(_vs.take(i as int))),
+                old_pos <= pos,
+                err is None ==> {
+                    &&& (pos - old_pos) == self@.spec_serialize(_vs.take(i as int)).len()
+                    &&& data@ == seq_splice(old_data, old_pos, self@.spec_serialize(_vs.take(i as int)))
+                },
+                err is Some ==> old_pos + self@.spec_serialize(_vs).len() > old_data.len(),
         {
-            let v = &vs.0[i];
-            assert(v@ == _vs[i as int]);
-            assert(_vs.take((i + 1) as int).drop_last() == _vs.take(i as int));  // <-- this is the key
-            let l = self.0.serialize(v, data, pos)?;
-            pos += l;
-            assert(data@ == seq_splice(
-                old_data,
-                old_pos,
-                self@.spec_serialize(_vs.take((i + 1) as int)),
-            ));
+            if err.is_some() {
+                // already failed, skip remaining iterations
+            } else {
+                let v = &vs.0[i];
+                assert(v@ == _vs[i as int]);
+                assert(_vs.take((i + 1) as int).drop_last() == _vs.take(i as int));
+                match self.0.serialize(v, data, pos) {
+                    Ok(l) => {
+                        pos += l;
+                        assert(data@ == seq_splice(
+                            old_data,
+                            old_pos,
+                            self@.spec_serialize(_vs.take((i + 1) as int)),
+                        ));
+                    }
+                    Err(e) => {
+                        proof {
+                            let take_ip1 = _vs.take((i + 1) as int);
+                            assert(take_ip1.drop_last() =~= _vs.take(i as int));
+                            assert(take_ip1.last() == _vs[i as int]);
+                            self@.lemma_spec_serialize_prefix_len(_vs, (i + 1) as int);
+                        }
+                        err = Some(e);
+                    }
+                }
+            }
+        }
+        match err {
+            Some(e) => Err(e),
+            None => {
+                assert(_vs == _vs.take(vs.0.len() as int));
+                Ok(pos - old_pos)
+            }
         }
-        assert(_vs == _vs.take(vs.0.len() as int));
-        Ok(pos - old_pos)
     }
 }
 
diff --git a/vest/src/regular/sequence.rs b/vest/src/regular/sequence.rs
index 8184bddc..1253f3f0 100644
--- a/vest/src/regular/sequence.rs
+++ b/vest/src/regular/sequence.rs
@@ -298,8 +298,24 @@ impl<'x, I, O, Fst, Snd, Cont> Combinator<'x, I, O> for Pair<Fst, Snd, Cont> whe
             assert(self.fst@.wf(v.0@));
         }
         let snd = self.snd.apply(POrSType::S(v.0));
-        let n = self.fst.serialize(v.0, data, pos)?;
-        let m = snd.serialize(v.1, data, pos + n)?;
+        let n = match self.fst.serialize(v.0, data, pos) {
+            Ok(n) => n,
+            Err(e) => {
+                proof {
+                    assert(self@.spec_serialize(v@).len() >= self.fst@.spec_serialize(v.0@).len());
+                }
+                return Err(e);
+            }
+        };
+        let m = match snd.serialize(v.1, data, pos + n) {
+            Ok(m) => m,
+            Err(e) => {
+                proof {
+                    assert(self@.spec_serialize(v@).len() == self.fst@.spec_serialize(v.0@).len() + (self.snd@)(v.0@).spec_serialize(v.1@).len());
+                }
+                return Err(e);
+            }
+        };
         assert(data@ == seq_splice(old(data)@, pos, self@.spec_serialize(v@)));
         Ok(n + m)
     }
@@ -400,8 +416,24 @@ impl<'x, Fst, Snd, I, O> Combinator<'x, I, O> for (Fst, Snd) where
         proof {
             assert(self.0@.wf(v.0@));
         }
-        let n = self.0.serialize(v.0, data, pos)?;
-        let m = self.1.serialize(v.1, data, pos + n)?;
+        let n = match self.0.serialize(v.0, data, pos) {
+            Ok(n) => n,
+            Err(e) => {
+                proof {
+                    assert(self@.spec_serialize(v@).len() >= self.0@.spec_serialize(v.0@).len());
+                }
+                return Err(e);
+            }
+        };
+        let m = match self.1.serialize(v.1, data, pos + n) {
+            Ok(m) => m,
+            Err(e) => {
+                proof {
+                    assert(self@.spec_serialize(v@).len() == self.0@.spec_serialize(v.0@).len() + self.1@.spec_serialize(v.1@).len());
+                }
+                return Err(e);
+            }
+        };
         assert(data@ == seq_splice(old(data)@, pos, self@.spec_serialize(v@)));
         Ok(n + m)
     }
diff --git a/vest/src/regular/variant.rs b/vest/src/regular/variant.rs
index cb52a8f6..48f54120 100644
--- a/vest/src/regular/variant.rs
+++ b/vest/src/regular/variant.rs
@@ -595,8 +595,24 @@ impl<'x, I, O, Fst, Snd> Combinator<'x, I, O> for OptThen<Fst, Snd> where
         usize,
         SerializeError,
     >) {
-        let n = self.0.0.serialize(&v.0, data, pos)?;
-        let m = self.0.1.serialize(v.1, data, pos + n)?;
+        let n = match self.0.0.serialize(&v.0, data, pos) {
+            Ok(n) => n,
+            Err(e) => {
+                proof {
+                    assert(self@.spec_serialize(v@).len() >= self.0.0@.spec_serialize(v.0@).len());
+                }
+                return Err(e);
+            }
+        };
+        let m = match self.0.1.serialize(v.1, data, pos + n) {
+            Ok(m) => m,
+            Err(e) => {
+                proof {
+                    assert(self@.spec_serialize(v@).len() == self.0.0@.spec_serialize(v.0@).len() + self.0.1@.spec_serialize(v.1@).len());
+                }
+                return Err(e);
+            }
+        };
         Ok(n + m)
     }
 }