diff --git a/vest-dsl/bitcoin/src/vest_bitcoin.rs b/vest-dsl/bitcoin/src/vest_bitcoin.rs
index 73547cc8..e71d3452 100644
--- a/vest-dsl/bitcoin/src/vest_bitcoin.rs
+++ b/vest-dsl/bitcoin/src/vest_bitcoin.rs
@@ -35,71 +35,71 @@ macro_rules! impl_wrapper_combinator {
 }
 verus!{
 
-pub struct SpecOutpoint {
-    pub hash: Seq<u8>,
-    pub index: u32,
+pub struct SpecScript {
+    pub l: VarInt,
+    pub data: Seq<u8>,
 }
 
-pub type SpecOutpointInner = (Seq<u8>, u32);
+pub type SpecScriptInner = (VarInt, Seq<u8>);
 
 
-impl SpecFrom<SpecOutpoint> for SpecOutpointInner {
-    open spec fn spec_from(m: SpecOutpoint) -> SpecOutpointInner {
-        (m.hash, m.index)
+impl SpecFrom<SpecScript> for SpecScriptInner {
+    open spec fn spec_from(m: SpecScript) -> SpecScriptInner {
+        (m.l, m.data)
     }
 }
 
-impl SpecFrom<SpecOutpointInner> for SpecOutpoint {
-    open spec fn spec_from(m: SpecOutpointInner) -> SpecOutpoint {
-        let (hash, index) = m;
-        SpecOutpoint { hash, index }
+impl SpecFrom<SpecScriptInner> for SpecScript {
+    open spec fn spec_from(m: SpecScriptInner) -> SpecScript {
+        let (l, data) = m;
+        SpecScript { l, data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Outpoint<'a> {
-    pub hash: &'a [u8],
-    pub index: u32,
+pub struct Script<'a> {
+    pub l: VarInt,
+    pub data: &'a [u8],
 }
 
-impl View for Outpoint<'_> {
-    type V = SpecOutpoint;
+impl View for Script<'_> {
+    type V = SpecScript;
 
     open spec fn view(&self) -> Self::V {
-        SpecOutpoint {
-            hash: self.hash@,
-            index: self.index@,
+        SpecScript {
+            l: self.l@,
+            data: self.data@,
         }
     }
 }
-pub type OutpointInner<'a> = (&'a [u8], u32);
+pub type ScriptInner<'a> = (VarInt, &'a [u8]);
 
-pub type OutpointInnerRef<'a> = (&'a &'a [u8], &'a u32);
-impl<'a> From<&'a Outpoint<'a>> for OutpointInnerRef<'a> {
-    fn ex_from(m: &'a Outpoint) -> OutpointInnerRef<'a> {
-        (&m.hash, &m.index)
+pub type ScriptInnerRef<'a> = (&'a VarInt, &'a &'a [u8]);
+impl<'a> From<&'a Script<'a>> for ScriptInnerRef<'a> {
+    fn ex_from(m: &'a Script) -> ScriptInnerRef<'a> {
+        (&m.l, &m.data)
     }
 }
 
-impl<'a> From<OutpointInner<'a>> for Outpoint<'a> {
-    fn ex_from(m: OutpointInner) -> Outpoint {
-        let (hash, index) = m;
-        Outpoint { hash, index }
+impl<'a> From<ScriptInner<'a>> for Script<'a> {
+    fn ex_from(m: ScriptInner) -> Script {
+        let (l, data) = m;
+        Script { l, data }
     }
 }
 
-pub struct OutpointMapper;
-impl View for OutpointMapper {
+pub struct ScriptMapper;
+impl View for ScriptMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for OutpointMapper {
-    type Src = SpecOutpointInner;
-    type Dst = SpecOutpoint;
+impl SpecIso for ScriptMapper {
+    type Src = SpecScriptInner;
+    type Dst = SpecScript;
 }
-impl SpecIsoProof for OutpointMapper {
+impl SpecIsoProof for ScriptMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -107,206 +107,245 @@ impl SpecIsoProof for OutpointMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for OutpointMapper {
-    type Src = OutpointInner<'a>;
-    type Dst = Outpoint<'a>;
-    type RefSrc = OutpointInnerRef<'a>;
+impl<'a> Iso<'a> for ScriptMapper {
+    type Src = ScriptInner<'a>;
+    type Dst = Script<'a>;
+    type RefSrc = ScriptInnerRef<'a>;
 }
-type SpecOutpointCombinatorAlias1 = (bytes::Fixed<32>, U32Le);
-pub struct SpecOutpointCombinator(pub SpecOutpointCombinatorAlias);
 
-impl SpecCombinator for SpecOutpointCombinator {
-    type Type = SpecOutpoint;
+pub struct SpecScriptCombinator(pub SpecScriptCombinatorAlias);
+
+impl SpecCombinator for SpecScriptCombinator {
+    type Type = SpecScript;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOutpointCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOutpointCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecScriptCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecScriptCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOutpointCombinatorAlias = Mapped<SpecOutpointCombinatorAlias1, OutpointMapper>;
-type OutpointCombinatorAlias1 = (bytes::Fixed<32>, U32Le);
-pub struct OutpointCombinator1(pub OutpointCombinatorAlias1);
-impl View for OutpointCombinator1 {
-    type V = SpecOutpointCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(OutpointCombinator1, OutpointCombinatorAlias1);
+pub type SpecScriptCombinatorAlias = Mapped<SpecPair<BtcVarint, bytes::Variable>, ScriptMapper>;
 
-pub struct OutpointCombinator(pub OutpointCombinatorAlias);
+pub struct ScriptCombinator(pub ScriptCombinatorAlias);
 
-impl View for OutpointCombinator {
-    type V = SpecOutpointCombinator;
-    open spec fn view(&self) -> Self::V { SpecOutpointCombinator(self.0@) }
+impl View for ScriptCombinator {
+    type V = SpecScriptCombinator;
+    open spec fn view(&self) -> Self::V { SpecScriptCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OutpointCombinator {
-    type Type = Outpoint<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ScriptCombinator {
+    type Type = Script<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type OutpointCombinatorAlias = Mapped<OutpointCombinator1, OutpointMapper>;
+}
+pub type ScriptCombinatorAlias = Mapped<Pair<BtcVarint, bytes::Variable, ScriptCont0>, ScriptMapper>;
 
 
-pub open spec fn spec_outpoint() -> SpecOutpointCombinator {
-    SpecOutpointCombinator(
+pub open spec fn spec_script() -> SpecScriptCombinator {
+    SpecScriptCombinator(
     Mapped {
-        inner: (bytes::Fixed::<32>, U32Le),
-        mapper: OutpointMapper,
+        inner: Pair::spec_new(BtcVarint, |deps| spec_script_cont0(deps)),
+        mapper: ScriptMapper,
     })
 }
 
+pub open spec fn spec_script_cont0(deps: VarInt) -> bytes::Variable {
+    let l = deps;
+    bytes::Variable((usize::spec_from(l)) as usize)
+}
+
+impl View for ScriptCont0 {
+    type V = spec_fn(VarInt) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: VarInt| {
+            spec_script_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn outpoint<'a>() -> (o: OutpointCombinator)
-    ensures o@ == spec_outpoint(),
+pub fn script<'a>() -> (o: ScriptCombinator)
+    ensures o@ == spec_script(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = OutpointCombinator(
+    let combinator = ScriptCombinator(
     Mapped {
-        inner: OutpointCombinator1((bytes::Fixed::<32>, U32Le)),
-        mapper: OutpointMapper,
-    });
-    assert({
-        &&& combinator@ == spec_outpoint()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(BtcVarint, ScriptCont0),
+        mapper: ScriptMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_script()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_outpoint<'a>(input: &'a [u8]) -> (res: PResult<<OutpointCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_script<'a>(input: &'a [u8]) -> (res: PResult<<ScriptCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_outpoint().spec_parse(input@) == Some((n as int, v@)),
-        spec_outpoint().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_script().spec_parse(input@) == Some((n as int, v@)),
+        spec_script().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_outpoint().spec_parse(input@) is None,
-        spec_outpoint().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_script().spec_parse(input@) is None,
+        spec_script().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = outpoint();
+    let combinator = script();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_outpoint<'a>(v: <OutpointCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_script<'a>(v: <ScriptCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_outpoint().wf(v@),
+        spec_script().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_outpoint().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_outpoint().spec_serialize(v@))
+            &&& n == spec_script().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_script().spec_serialize(v@))
         },
 {
-    let combinator = outpoint();
+    let combinator = script();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn outpoint_len<'a>(v: <OutpointCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn script_len<'a>(v: <ScriptCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_outpoint().wf(v@),
-        spec_outpoint().spec_serialize(v@).len() <= usize::MAX,
+        spec_script().wf(v@),
+        spec_script().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_outpoint().spec_serialize(v@).len(),
+        serialize_len == spec_script().spec_serialize(v@).len(),
 {
-    let combinator = outpoint();
+    let combinator = script();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct ScriptCont0;
+type ScriptCont0Type<'a, 'b> = &'b VarInt;
+type ScriptCont0SType<'a, 'x> = &'x VarInt;
+type ScriptCont0Input<'a, 'b, 'x> = POrSType<ScriptCont0Type<'a, 'b>, ScriptCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ScriptCont0Input<'a, 'b, 'x>> for ScriptCont0 {
+    type Output = bytes::Variable;
+
+    open spec fn requires(&self, deps: ScriptCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (BtcVarint).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: ScriptCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_script_cont0(deps@)
+    }
+
+    fn apply(&self, deps: ScriptCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
+            }
+        }
+    }
+}
                 
 
-pub struct SpecScriptSig {
-    pub l: VarInt,
-    pub data: Seq<u8>,
+pub struct SpecTxout {
+    pub value: u64,
+    pub script_pubkey: SpecScript,
 }
 
-pub type SpecScriptSigInner = (VarInt, Seq<u8>);
+pub type SpecTxoutInner = (u64, SpecScript);
 
 
-impl SpecFrom<SpecScriptSig> for SpecScriptSigInner {
-    open spec fn spec_from(m: SpecScriptSig) -> SpecScriptSigInner {
-        (m.l, m.data)
+impl SpecFrom<SpecTxout> for SpecTxoutInner {
+    open spec fn spec_from(m: SpecTxout) -> SpecTxoutInner {
+        (m.value, m.script_pubkey)
     }
 }
 
-impl SpecFrom<SpecScriptSigInner> for SpecScriptSig {
-    open spec fn spec_from(m: SpecScriptSigInner) -> SpecScriptSig {
-        let (l, data) = m;
-        SpecScriptSig { l, data }
+impl SpecFrom<SpecTxoutInner> for SpecTxout {
+    open spec fn spec_from(m: SpecTxoutInner) -> SpecTxout {
+        let (value, script_pubkey) = m;
+        SpecTxout { value, script_pubkey }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ScriptSig<'a> {
-    pub l: VarInt,
-    pub data: &'a [u8],
+pub struct Txout<'a> {
+    pub value: u64,
+    pub script_pubkey: Script<'a>,
 }
 
-impl View for ScriptSig<'_> {
-    type V = SpecScriptSig;
+impl View for Txout<'_> {
+    type V = SpecTxout;
 
     open spec fn view(&self) -> Self::V {
-        SpecScriptSig {
-            l: self.l@,
-            data: self.data@,
+        SpecTxout {
+            value: self.value@,
+            script_pubkey: self.script_pubkey@,
         }
     }
 }
-pub type ScriptSigInner<'a> = (VarInt, &'a [u8]);
+pub type TxoutInner<'a> = (u64, Script<'a>);
 
-pub type ScriptSigInnerRef<'a> = (&'a VarInt, &'a &'a [u8]);
-impl<'a> From<&'a ScriptSig<'a>> for ScriptSigInnerRef<'a> {
-    fn ex_from(m: &'a ScriptSig) -> ScriptSigInnerRef<'a> {
-        (&m.l, &m.data)
+pub type TxoutInnerRef<'a> = (&'a u64, &'a Script<'a>);
+impl<'a> From<&'a Txout<'a>> for TxoutInnerRef<'a> {
+    fn ex_from(m: &'a Txout) -> TxoutInnerRef<'a> {
+        (&m.value, &m.script_pubkey)
     }
 }
 
-impl<'a> From<ScriptSigInner<'a>> for ScriptSig<'a> {
-    fn ex_from(m: ScriptSigInner) -> ScriptSig {
-        let (l, data) = m;
-        ScriptSig { l, data }
+impl<'a> From<TxoutInner<'a>> for Txout<'a> {
+    fn ex_from(m: TxoutInner) -> Txout {
+        let (value, script_pubkey) = m;
+        Txout { value, script_pubkey }
     }
 }
 
-pub struct ScriptSigMapper;
-impl View for ScriptSigMapper {
+pub struct TxoutMapper;
+impl View for TxoutMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ScriptSigMapper {
-    type Src = SpecScriptSigInner;
-    type Dst = SpecScriptSig;
+impl SpecIso for TxoutMapper {
+    type Src = SpecTxoutInner;
+    type Dst = SpecTxout;
 }
-impl SpecIsoProof for ScriptSigMapper {
+impl SpecIsoProof for TxoutMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -314,244 +353,206 @@ impl SpecIsoProof for ScriptSigMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ScriptSigMapper {
-    type Src = ScriptSigInner<'a>;
-    type Dst = ScriptSig<'a>;
-    type RefSrc = ScriptSigInnerRef<'a>;
+impl<'a> Iso<'a> for TxoutMapper {
+    type Src = TxoutInner<'a>;
+    type Dst = Txout<'a>;
+    type RefSrc = TxoutInnerRef<'a>;
 }
+type SpecTxoutCombinatorAlias1 = (U64Le, SpecScriptCombinator);
+pub struct SpecTxoutCombinator(pub SpecTxoutCombinatorAlias);
 
-pub struct SpecScriptSigCombinator(pub SpecScriptSigCombinatorAlias);
-
-impl SpecCombinator for SpecScriptSigCombinator {
-    type Type = SpecScriptSig;
+impl SpecCombinator for SpecTxoutCombinator {
+    type Type = SpecTxout;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecScriptSigCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecScriptSigCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTxoutCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTxoutCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecScriptSigCombinatorAlias = Mapped<SpecPair<BtcVarint, bytes::Variable>, ScriptSigMapper>;
+pub type SpecTxoutCombinatorAlias = Mapped<SpecTxoutCombinatorAlias1, TxoutMapper>;
+type TxoutCombinatorAlias1 = (U64Le, ScriptCombinator);
+pub struct TxoutCombinator1(pub TxoutCombinatorAlias1);
+impl View for TxoutCombinator1 {
+    type V = SpecTxoutCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TxoutCombinator1, TxoutCombinatorAlias1);
 
-pub struct ScriptSigCombinator(pub ScriptSigCombinatorAlias);
+pub struct TxoutCombinator(pub TxoutCombinatorAlias);
 
-impl View for ScriptSigCombinator {
-    type V = SpecScriptSigCombinator;
-    open spec fn view(&self) -> Self::V { SpecScriptSigCombinator(self.0@) }
+impl View for TxoutCombinator {
+    type V = SpecTxoutCombinator;
+    open spec fn view(&self) -> Self::V { SpecTxoutCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ScriptSigCombinator {
-    type Type = ScriptSig<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TxoutCombinator {
+    type Type = Txout<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ScriptSigCombinatorAlias = Mapped<Pair<BtcVarint, bytes::Variable, ScriptSigCont0>, ScriptSigMapper>;
+}
+pub type TxoutCombinatorAlias = Mapped<TxoutCombinator1, TxoutMapper>;
 
 
-pub open spec fn spec_script_sig() -> SpecScriptSigCombinator {
-    SpecScriptSigCombinator(
+pub open spec fn spec_txout() -> SpecTxoutCombinator {
+    SpecTxoutCombinator(
     Mapped {
-        inner: Pair::spec_new(BtcVarint, |deps| spec_script_sig_cont0(deps)),
-        mapper: ScriptSigMapper,
+        inner: (U64Le, spec_script()),
+        mapper: TxoutMapper,
     })
 }
 
-pub open spec fn spec_script_sig_cont0(deps: VarInt) -> bytes::Variable {
-    let l = deps;
-    bytes::Variable(l.spec_into())
-}
-
-impl View for ScriptSigCont0 {
-    type V = spec_fn(VarInt) -> bytes::Variable;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: VarInt| {
-            spec_script_sig_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn script_sig<'a>() -> (o: ScriptSigCombinator)
-    ensures o@ == spec_script_sig(),
+pub fn txout<'a>() -> (o: TxoutCombinator)
+    ensures o@ == spec_txout(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ScriptSigCombinator(
+    let combinator = TxoutCombinator(
     Mapped {
-        inner: Pair::new(BtcVarint, ScriptSigCont0),
-        mapper: ScriptSigMapper,
-    });
-    assert({
-        &&& combinator@ == spec_script_sig()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: TxoutCombinator1((U64Le, script())),
+        mapper: TxoutMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_txout()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_script_sig<'a>(input: &'a [u8]) -> (res: PResult<<ScriptSigCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_txout<'a>(input: &'a [u8]) -> (res: PResult<<TxoutCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_script_sig().spec_parse(input@) == Some((n as int, v@)),
-        spec_script_sig().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_txout().spec_parse(input@) == Some((n as int, v@)),
+        spec_txout().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_script_sig().spec_parse(input@) is None,
-        spec_script_sig().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_txout().spec_parse(input@) is None,
+        spec_txout().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = script_sig();
+    let combinator = txout();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_script_sig<'a>(v: <ScriptSigCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_txout<'a>(v: <TxoutCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_script_sig().wf(v@),
+        spec_txout().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_script_sig().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_script_sig().spec_serialize(v@))
+            &&& n == spec_txout().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_txout().spec_serialize(v@))
         },
 {
-    let combinator = script_sig();
+    let combinator = txout();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn script_sig_len<'a>(v: <ScriptSigCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn txout_len<'a>(v: <TxoutCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_script_sig().wf(v@),
-        spec_script_sig().spec_serialize(v@).len() <= usize::MAX,
+        spec_txout().wf(v@),
+        spec_txout().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_script_sig().spec_serialize(v@).len(),
+        serialize_len == spec_txout().spec_serialize(v@).len(),
 {
-    let combinator = script_sig();
+    let combinator = txout();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ScriptSigCont0;
-type ScriptSigCont0Type<'a, 'b> = &'b VarInt;
-type ScriptSigCont0SType<'a, 'x> = &'x VarInt;
-type ScriptSigCont0Input<'a, 'b, 'x> = POrSType<ScriptSigCont0Type<'a, 'b>, ScriptSigCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ScriptSigCont0Input<'a, 'b, 'x>> for ScriptSigCont0 {
-    type Output = bytes::Variable;
-
-    open spec fn requires(&self, deps: ScriptSigCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: ScriptSigCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_script_sig_cont0(deps@)
-    }
-
-    fn apply(&self, deps: ScriptSigCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                bytes::Variable(l.ex_into())
-            }
-        }
-    }
-}
                 
 
-pub struct SpecTxin {
-    pub previous_output: SpecOutpoint,
-    pub script_sig: SpecScriptSig,
-    pub sequence: u32,
+pub struct SpecOutpoint {
+    pub hash: Seq<u8>,
+    pub index: u32,
 }
 
-pub type SpecTxinInner = (SpecOutpoint, (SpecScriptSig, u32));
+pub type SpecOutpointInner = (Seq<u8>, u32);
 
 
-impl SpecFrom<SpecTxin> for SpecTxinInner {
-    open spec fn spec_from(m: SpecTxin) -> SpecTxinInner {
-        (m.previous_output, (m.script_sig, m.sequence))
+impl SpecFrom<SpecOutpoint> for SpecOutpointInner {
+    open spec fn spec_from(m: SpecOutpoint) -> SpecOutpointInner {
+        (m.hash, m.index)
     }
 }
 
-impl SpecFrom<SpecTxinInner> for SpecTxin {
-    open spec fn spec_from(m: SpecTxinInner) -> SpecTxin {
-        let (previous_output, (script_sig, sequence)) = m;
-        SpecTxin { previous_output, script_sig, sequence }
+impl SpecFrom<SpecOutpointInner> for SpecOutpoint {
+    open spec fn spec_from(m: SpecOutpointInner) -> SpecOutpoint {
+        let (hash, index) = m;
+        SpecOutpoint { hash, index }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Txin<'a> {
-    pub previous_output: Outpoint<'a>,
-    pub script_sig: ScriptSig<'a>,
-    pub sequence: u32,
+pub struct Outpoint<'a> {
+    pub hash: &'a [u8],
+    pub index: u32,
 }
 
-impl View for Txin<'_> {
-    type V = SpecTxin;
+impl View for Outpoint<'_> {
+    type V = SpecOutpoint;
 
     open spec fn view(&self) -> Self::V {
-        SpecTxin {
-            previous_output: self.previous_output@,
-            script_sig: self.script_sig@,
-            sequence: self.sequence@,
+        SpecOutpoint {
+            hash: self.hash@,
+            index: self.index@,
         }
     }
 }
-pub type TxinInner<'a> = (Outpoint<'a>, (ScriptSig<'a>, u32));
-
-pub type TxinInnerRef<'a> = (&'a Outpoint<'a>, (&'a ScriptSig<'a>, &'a u32));
-impl<'a> From<&'a Txin<'a>> for TxinInnerRef<'a> {
-    fn ex_from(m: &'a Txin) -> TxinInnerRef<'a> {
-        (&m.previous_output, (&m.script_sig, &m.sequence))
-    }
-}
+pub type OutpointInner<'a> = (&'a [u8], u32);
 
-impl<'a> From<TxinInner<'a>> for Txin<'a> {
-    fn ex_from(m: TxinInner) -> Txin {
-        let (previous_output, (script_sig, sequence)) = m;
-        Txin { previous_output, script_sig, sequence }
+pub type OutpointInnerRef<'a> = (&'a &'a [u8], &'a u32);
+impl<'a> From<&'a Outpoint<'a>> for OutpointInnerRef<'a> {
+    fn ex_from(m: &'a Outpoint) -> OutpointInnerRef<'a> {
+        (&m.hash, &m.index)
     }
 }
 
-pub struct TxinMapper;
-impl View for TxinMapper {
+impl<'a> From<OutpointInner<'a>> for Outpoint<'a> {
+    fn ex_from(m: OutpointInner) -> Outpoint {
+        let (hash, index) = m;
+        Outpoint { hash, index }
+    }
+}
+
+pub struct OutpointMapper;
+impl View for OutpointMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for TxinMapper {
-    type Src = SpecTxinInner;
-    type Dst = SpecTxin;
+impl SpecIso for OutpointMapper {
+    type Src = SpecOutpointInner;
+    type Dst = SpecOutpoint;
 }
-impl SpecIsoProof for TxinMapper {
+impl SpecIsoProof for OutpointMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -559,215 +560,206 @@ impl SpecIsoProof for TxinMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for TxinMapper {
-    type Src = TxinInner<'a>;
-    type Dst = Txin<'a>;
-    type RefSrc = TxinInnerRef<'a>;
+impl<'a> Iso<'a> for OutpointMapper {
+    type Src = OutpointInner<'a>;
+    type Dst = Outpoint<'a>;
+    type RefSrc = OutpointInnerRef<'a>;
 }
-type SpecTxinCombinatorAlias1 = (SpecScriptSigCombinator, U32Le);
-type SpecTxinCombinatorAlias2 = (SpecOutpointCombinator, SpecTxinCombinatorAlias1);
-pub struct SpecTxinCombinator(pub SpecTxinCombinatorAlias);
+type SpecOutpointCombinatorAlias1 = (bytes::Fixed<32>, U32Le);
+pub struct SpecOutpointCombinator(pub SpecOutpointCombinatorAlias);
 
-impl SpecCombinator for SpecTxinCombinator {
-    type Type = SpecTxin;
+impl SpecCombinator for SpecOutpointCombinator {
+    type Type = SpecOutpoint;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTxinCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTxinCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOutpointCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOutpointCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTxinCombinatorAlias = Mapped<SpecTxinCombinatorAlias2, TxinMapper>;
-type TxinCombinatorAlias1 = (ScriptSigCombinator, U32Le);
-type TxinCombinatorAlias2 = (OutpointCombinator, TxinCombinator1);
-pub struct TxinCombinator1(pub TxinCombinatorAlias1);
-impl View for TxinCombinator1 {
-    type V = SpecTxinCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(TxinCombinator1, TxinCombinatorAlias1);
-
-pub struct TxinCombinator2(pub TxinCombinatorAlias2);
-impl View for TxinCombinator2 {
-    type V = SpecTxinCombinatorAlias2;
+pub type SpecOutpointCombinatorAlias = Mapped<SpecOutpointCombinatorAlias1, OutpointMapper>;
+type OutpointCombinatorAlias1 = (bytes::Fixed<32>, U32Le);
+pub struct OutpointCombinator1(pub OutpointCombinatorAlias1);
+impl View for OutpointCombinator1 {
+    type V = SpecOutpointCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(TxinCombinator2, TxinCombinatorAlias2);
+impl_wrapper_combinator!(OutpointCombinator1, OutpointCombinatorAlias1);
 
-pub struct TxinCombinator(pub TxinCombinatorAlias);
+pub struct OutpointCombinator(pub OutpointCombinatorAlias);
 
-impl View for TxinCombinator {
-    type V = SpecTxinCombinator;
-    open spec fn view(&self) -> Self::V { SpecTxinCombinator(self.0@) }
+impl View for OutpointCombinator {
+    type V = SpecOutpointCombinator;
+    open spec fn view(&self) -> Self::V { SpecOutpointCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TxinCombinator {
-    type Type = Txin<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OutpointCombinator {
+    type Type = Outpoint<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TxinCombinatorAlias = Mapped<TxinCombinator2, TxinMapper>;
+}
+pub type OutpointCombinatorAlias = Mapped<OutpointCombinator1, OutpointMapper>;
 
 
-pub open spec fn spec_txin() -> SpecTxinCombinator {
-    SpecTxinCombinator(
+pub open spec fn spec_outpoint() -> SpecOutpointCombinator {
+    SpecOutpointCombinator(
     Mapped {
-        inner: (spec_outpoint(), (spec_script_sig(), U32Le)),
-        mapper: TxinMapper,
+        inner: (bytes::Fixed::<32>, U32Le),
+        mapper: OutpointMapper,
     })
 }
 
                 
-pub fn txin<'a>() -> (o: TxinCombinator)
-    ensures o@ == spec_txin(),
+pub fn outpoint<'a>() -> (o: OutpointCombinator)
+    ensures o@ == spec_outpoint(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = TxinCombinator(
+    let combinator = OutpointCombinator(
     Mapped {
-        inner: TxinCombinator2((outpoint(), TxinCombinator1((script_sig(), U32Le)))),
-        mapper: TxinMapper,
-    });
-    assert({
-        &&& combinator@ == spec_txin()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: OutpointCombinator1((bytes::Fixed::<32>, U32Le)),
+        mapper: OutpointMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_outpoint()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_txin<'a>(input: &'a [u8]) -> (res: PResult<<TxinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_outpoint<'a>(input: &'a [u8]) -> (res: PResult<<OutpointCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_txin().spec_parse(input@) == Some((n as int, v@)),
-        spec_txin().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_outpoint().spec_parse(input@) == Some((n as int, v@)),
+        spec_outpoint().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_txin().spec_parse(input@) is None,
-        spec_txin().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_outpoint().spec_parse(input@) is None,
+        spec_outpoint().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = txin();
+    let combinator = outpoint();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_txin<'a>(v: <TxinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_outpoint<'a>(v: <OutpointCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_txin().wf(v@),
+        spec_outpoint().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_txin().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_txin().spec_serialize(v@))
+            &&& n == spec_outpoint().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_outpoint().spec_serialize(v@))
         },
 {
-    let combinator = txin();
+    let combinator = outpoint();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn txin_len<'a>(v: <TxinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn outpoint_len<'a>(v: <OutpointCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_txin().wf(v@),
-        spec_txin().spec_serialize(v@).len() <= usize::MAX,
+        spec_outpoint().wf(v@),
+        spec_outpoint().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_txin().spec_serialize(v@).len(),
+        serialize_len == spec_outpoint().spec_serialize(v@).len(),
 {
-    let combinator = txin();
+    let combinator = outpoint();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecScript {
+pub struct SpecScriptSig {
     pub l: VarInt,
     pub data: Seq<u8>,
 }
 
-pub type SpecScriptInner = (VarInt, Seq<u8>);
+pub type SpecScriptSigInner = (VarInt, Seq<u8>);
 
 
-impl SpecFrom<SpecScript> for SpecScriptInner {
-    open spec fn spec_from(m: SpecScript) -> SpecScriptInner {
+impl SpecFrom<SpecScriptSig> for SpecScriptSigInner {
+    open spec fn spec_from(m: SpecScriptSig) -> SpecScriptSigInner {
         (m.l, m.data)
     }
 }
 
-impl SpecFrom<SpecScriptInner> for SpecScript {
-    open spec fn spec_from(m: SpecScriptInner) -> SpecScript {
+impl SpecFrom<SpecScriptSigInner> for SpecScriptSig {
+    open spec fn spec_from(m: SpecScriptSigInner) -> SpecScriptSig {
         let (l, data) = m;
-        SpecScript { l, data }
+        SpecScriptSig { l, data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Script<'a> {
+pub struct ScriptSig<'a> {
     pub l: VarInt,
     pub data: &'a [u8],
 }
 
-impl View for Script<'_> {
-    type V = SpecScript;
+impl View for ScriptSig<'_> {
+    type V = SpecScriptSig;
 
     open spec fn view(&self) -> Self::V {
-        SpecScript {
+        SpecScriptSig {
             l: self.l@,
             data: self.data@,
         }
     }
 }
-pub type ScriptInner<'a> = (VarInt, &'a [u8]);
+pub type ScriptSigInner<'a> = (VarInt, &'a [u8]);
 
-pub type ScriptInnerRef<'a> = (&'a VarInt, &'a &'a [u8]);
-impl<'a> From<&'a Script<'a>> for ScriptInnerRef<'a> {
-    fn ex_from(m: &'a Script) -> ScriptInnerRef<'a> {
+pub type ScriptSigInnerRef<'a> = (&'a VarInt, &'a &'a [u8]);
+impl<'a> From<&'a ScriptSig<'a>> for ScriptSigInnerRef<'a> {
+    fn ex_from(m: &'a ScriptSig) -> ScriptSigInnerRef<'a> {
         (&m.l, &m.data)
     }
 }
 
-impl<'a> From<ScriptInner<'a>> for Script<'a> {
-    fn ex_from(m: ScriptInner) -> Script {
+impl<'a> From<ScriptSigInner<'a>> for ScriptSig<'a> {
+    fn ex_from(m: ScriptSigInner) -> ScriptSig {
         let (l, data) = m;
-        Script { l, data }
+        ScriptSig { l, data }
     }
 }
 
-pub struct ScriptMapper;
-impl View for ScriptMapper {
+pub struct ScriptSigMapper;
+impl View for ScriptSigMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ScriptMapper {
-    type Src = SpecScriptInner;
-    type Dst = SpecScript;
+impl SpecIso for ScriptSigMapper {
+    type Src = SpecScriptSigInner;
+    type Dst = SpecScriptSig;
 }
-impl SpecIsoProof for ScriptMapper {
+impl SpecIsoProof for ScriptSigMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -775,241 +767,248 @@ impl SpecIsoProof for ScriptMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ScriptMapper {
-    type Src = ScriptInner<'a>;
-    type Dst = Script<'a>;
-    type RefSrc = ScriptInnerRef<'a>;
+impl<'a> Iso<'a> for ScriptSigMapper {
+    type Src = ScriptSigInner<'a>;
+    type Dst = ScriptSig<'a>;
+    type RefSrc = ScriptSigInnerRef<'a>;
 }
 
-pub struct SpecScriptCombinator(pub SpecScriptCombinatorAlias);
+pub struct SpecScriptSigCombinator(pub SpecScriptSigCombinatorAlias);
 
-impl SpecCombinator for SpecScriptCombinator {
-    type Type = SpecScript;
+impl SpecCombinator for SpecScriptSigCombinator {
+    type Type = SpecScriptSig;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecScriptCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecScriptCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecScriptSigCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecScriptSigCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecScriptCombinatorAlias = Mapped<SpecPair<BtcVarint, bytes::Variable>, ScriptMapper>;
+pub type SpecScriptSigCombinatorAlias = Mapped<SpecPair<BtcVarint, bytes::Variable>, ScriptSigMapper>;
 
-pub struct ScriptCombinator(pub ScriptCombinatorAlias);
+pub struct ScriptSigCombinator(pub ScriptSigCombinatorAlias);
 
-impl View for ScriptCombinator {
-    type V = SpecScriptCombinator;
-    open spec fn view(&self) -> Self::V { SpecScriptCombinator(self.0@) }
+impl View for ScriptSigCombinator {
+    type V = SpecScriptSigCombinator;
+    open spec fn view(&self) -> Self::V { SpecScriptSigCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ScriptCombinator {
-    type Type = Script<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ScriptSigCombinator {
+    type Type = ScriptSig<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ScriptCombinatorAlias = Mapped<Pair<BtcVarint, bytes::Variable, ScriptCont0>, ScriptMapper>;
+}
+pub type ScriptSigCombinatorAlias = Mapped<Pair<BtcVarint, bytes::Variable, ScriptSigCont0>, ScriptSigMapper>;
 
 
-pub open spec fn spec_script() -> SpecScriptCombinator {
-    SpecScriptCombinator(
+pub open spec fn spec_script_sig() -> SpecScriptSigCombinator {
+    SpecScriptSigCombinator(
     Mapped {
-        inner: Pair::spec_new(BtcVarint, |deps| spec_script_cont0(deps)),
-        mapper: ScriptMapper,
+        inner: Pair::spec_new(BtcVarint, |deps| spec_script_sig_cont0(deps)),
+        mapper: ScriptSigMapper,
     })
 }
 
-pub open spec fn spec_script_cont0(deps: VarInt) -> bytes::Variable {
+pub open spec fn spec_script_sig_cont0(deps: VarInt) -> bytes::Variable {
     let l = deps;
-    bytes::Variable(l.spec_into())
+    bytes::Variable((usize::spec_from(l)) as usize)
 }
 
-impl View for ScriptCont0 {
+impl View for ScriptSigCont0 {
     type V = spec_fn(VarInt) -> bytes::Variable;
 
     open spec fn view(&self) -> Self::V {
         |deps: VarInt| {
-            spec_script_cont0(deps)
+            spec_script_sig_cont0(deps)
         }
     }
 }
 
                 
-pub fn script<'a>() -> (o: ScriptCombinator)
-    ensures o@ == spec_script(),
+pub fn script_sig<'a>() -> (o: ScriptSigCombinator)
+    ensures o@ == spec_script_sig(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ScriptCombinator(
+    let combinator = ScriptSigCombinator(
     Mapped {
-        inner: Pair::new(BtcVarint, ScriptCont0),
-        mapper: ScriptMapper,
-    });
-    assert({
-        &&& combinator@ == spec_script()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(BtcVarint, ScriptSigCont0),
+        mapper: ScriptSigMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_script_sig()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_script<'a>(input: &'a [u8]) -> (res: PResult<<ScriptCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_script_sig<'a>(input: &'a [u8]) -> (res: PResult<<ScriptSigCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_script().spec_parse(input@) == Some((n as int, v@)),
-        spec_script().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_script_sig().spec_parse(input@) == Some((n as int, v@)),
+        spec_script_sig().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_script().spec_parse(input@) is None,
-        spec_script().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_script_sig().spec_parse(input@) is None,
+        spec_script_sig().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = script();
+    let combinator = script_sig();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_script<'a>(v: <ScriptCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_script_sig<'a>(v: <ScriptSigCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_script().wf(v@),
+        spec_script_sig().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_script().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_script().spec_serialize(v@))
+            &&& n == spec_script_sig().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_script_sig().spec_serialize(v@))
         },
 {
-    let combinator = script();
+    let combinator = script_sig();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn script_len<'a>(v: <ScriptCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn script_sig_len<'a>(v: <ScriptSigCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_script().wf(v@),
-        spec_script().spec_serialize(v@).len() <= usize::MAX,
+        spec_script_sig().wf(v@),
+        spec_script_sig().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_script().spec_serialize(v@).len(),
+        serialize_len == spec_script_sig().spec_serialize(v@).len(),
 {
-    let combinator = script();
+    let combinator = script_sig();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ScriptCont0;
-type ScriptCont0Type<'a, 'b> = &'b VarInt;
-type ScriptCont0SType<'a, 'x> = &'x VarInt;
-type ScriptCont0Input<'a, 'b, 'x> = POrSType<ScriptCont0Type<'a, 'b>, ScriptCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ScriptCont0Input<'a, 'b, 'x>> for ScriptCont0 {
+pub struct ScriptSigCont0;
+type ScriptSigCont0Type<'a, 'b> = &'b VarInt;
+type ScriptSigCont0SType<'a, 'x> = &'x VarInt;
+type ScriptSigCont0Input<'a, 'b, 'x> = POrSType<ScriptSigCont0Type<'a, 'b>, ScriptSigCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ScriptSigCont0Input<'a, 'b, 'x>> for ScriptSigCont0 {
     type Output = bytes::Variable;
 
-    open spec fn requires(&self, deps: ScriptCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: ScriptSigCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (BtcVarint).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: ScriptCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_script_cont0(deps@)
+    open spec fn ensures(&self, deps: ScriptSigCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_script_sig_cont0(deps@)
     }
 
-    fn apply(&self, deps: ScriptCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: ScriptSigCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                bytes::Variable(l.ex_into())
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
 
-pub struct SpecTxout {
-    pub value: u64,
-    pub script_pubkey: SpecScript,
+pub struct SpecTxin {
+    pub previous_output: SpecOutpoint,
+    pub script_sig: SpecScriptSig,
+    pub sequence: u32,
 }
 
-pub type SpecTxoutInner = (u64, SpecScript);
+pub type SpecTxinInner = (SpecOutpoint, (SpecScriptSig, u32));
 
 
-impl SpecFrom<SpecTxout> for SpecTxoutInner {
-    open spec fn spec_from(m: SpecTxout) -> SpecTxoutInner {
-        (m.value, m.script_pubkey)
+impl SpecFrom<SpecTxin> for SpecTxinInner {
+    open spec fn spec_from(m: SpecTxin) -> SpecTxinInner {
+        (m.previous_output, (m.script_sig, m.sequence))
     }
 }
 
-impl SpecFrom<SpecTxoutInner> for SpecTxout {
-    open spec fn spec_from(m: SpecTxoutInner) -> SpecTxout {
-        let (value, script_pubkey) = m;
-        SpecTxout { value, script_pubkey }
+impl SpecFrom<SpecTxinInner> for SpecTxin {
+    open spec fn spec_from(m: SpecTxinInner) -> SpecTxin {
+        let (previous_output, (script_sig, sequence)) = m;
+        SpecTxin { previous_output, script_sig, sequence }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Txout<'a> {
-    pub value: u64,
-    pub script_pubkey: Script<'a>,
+pub struct Txin<'a> {
+    pub previous_output: Outpoint<'a>,
+    pub script_sig: ScriptSig<'a>,
+    pub sequence: u32,
 }
 
-impl View for Txout<'_> {
-    type V = SpecTxout;
+impl View for Txin<'_> {
+    type V = SpecTxin;
 
     open spec fn view(&self) -> Self::V {
-        SpecTxout {
-            value: self.value@,
-            script_pubkey: self.script_pubkey@,
+        SpecTxin {
+            previous_output: self.previous_output@,
+            script_sig: self.script_sig@,
+            sequence: self.sequence@,
         }
     }
 }
-pub type TxoutInner<'a> = (u64, Script<'a>);
+pub type TxinInner<'a> = (Outpoint<'a>, (ScriptSig<'a>, u32));
 
-pub type TxoutInnerRef<'a> = (&'a u64, &'a Script<'a>);
-impl<'a> From<&'a Txout<'a>> for TxoutInnerRef<'a> {
-    fn ex_from(m: &'a Txout) -> TxoutInnerRef<'a> {
-        (&m.value, &m.script_pubkey)
+pub type TxinInnerRef<'a> = (&'a Outpoint<'a>, (&'a ScriptSig<'a>, &'a u32));
+impl<'a> From<&'a Txin<'a>> for TxinInnerRef<'a> {
+    fn ex_from(m: &'a Txin) -> TxinInnerRef<'a> {
+        (&m.previous_output, (&m.script_sig, &m.sequence))
     }
 }
 
-impl<'a> From<TxoutInner<'a>> for Txout<'a> {
-    fn ex_from(m: TxoutInner) -> Txout {
-        let (value, script_pubkey) = m;
-        Txout { value, script_pubkey }
+impl<'a> From<TxinInner<'a>> for Txin<'a> {
+    fn ex_from(m: TxinInner) -> Txin {
+        let (previous_output, (script_sig, sequence)) = m;
+        Txin { previous_output, script_sig, sequence }
     }
 }
 
-pub struct TxoutMapper;
-impl View for TxoutMapper {
+pub struct TxinMapper;
+impl View for TxinMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for TxoutMapper {
-    type Src = SpecTxoutInner;
-    type Dst = SpecTxout;
+impl SpecIso for TxinMapper {
+    type Src = SpecTxinInner;
+    type Dst = SpecTxin;
 }
-impl SpecIsoProof for TxoutMapper {
+impl SpecIsoProof for TxinMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -1017,136 +1016,145 @@ impl SpecIsoProof for TxoutMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for TxoutMapper {
-    type Src = TxoutInner<'a>;
-    type Dst = Txout<'a>;
-    type RefSrc = TxoutInnerRef<'a>;
+impl<'a> Iso<'a> for TxinMapper {
+    type Src = TxinInner<'a>;
+    type Dst = Txin<'a>;
+    type RefSrc = TxinInnerRef<'a>;
 }
-type SpecTxoutCombinatorAlias1 = (U64Le, SpecScriptCombinator);
-pub struct SpecTxoutCombinator(pub SpecTxoutCombinatorAlias);
+type SpecTxinCombinatorAlias1 = (SpecScriptSigCombinator, U32Le);
+type SpecTxinCombinatorAlias2 = (SpecOutpointCombinator, SpecTxinCombinatorAlias1);
+pub struct SpecTxinCombinator(pub SpecTxinCombinatorAlias);
 
-impl SpecCombinator for SpecTxoutCombinator {
-    type Type = SpecTxout;
+impl SpecCombinator for SpecTxinCombinator {
+    type Type = SpecTxin;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTxoutCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTxoutCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTxinCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTxinCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTxoutCombinatorAlias = Mapped<SpecTxoutCombinatorAlias1, TxoutMapper>;
-type TxoutCombinatorAlias1 = (U64Le, ScriptCombinator);
-pub struct TxoutCombinator1(pub TxoutCombinatorAlias1);
-impl View for TxoutCombinator1 {
-    type V = SpecTxoutCombinatorAlias1;
+pub type SpecTxinCombinatorAlias = Mapped<SpecTxinCombinatorAlias2, TxinMapper>;
+type TxinCombinatorAlias1 = (ScriptSigCombinator, U32Le);
+type TxinCombinatorAlias2 = (OutpointCombinator, TxinCombinator1);
+pub struct TxinCombinator1(pub TxinCombinatorAlias1);
+impl View for TxinCombinator1 {
+    type V = SpecTxinCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(TxoutCombinator1, TxoutCombinatorAlias1);
+impl_wrapper_combinator!(TxinCombinator1, TxinCombinatorAlias1);
 
-pub struct TxoutCombinator(pub TxoutCombinatorAlias);
+pub struct TxinCombinator2(pub TxinCombinatorAlias2);
+impl View for TxinCombinator2 {
+    type V = SpecTxinCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TxinCombinator2, TxinCombinatorAlias2);
 
-impl View for TxoutCombinator {
-    type V = SpecTxoutCombinator;
-    open spec fn view(&self) -> Self::V { SpecTxoutCombinator(self.0@) }
+pub struct TxinCombinator(pub TxinCombinatorAlias);
+
+impl View for TxinCombinator {
+    type V = SpecTxinCombinator;
+    open spec fn view(&self) -> Self::V { SpecTxinCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TxoutCombinator {
-    type Type = Txout<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TxinCombinator {
+    type Type = Txin<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TxoutCombinatorAlias = Mapped<TxoutCombinator1, TxoutMapper>;
+}
+pub type TxinCombinatorAlias = Mapped<TxinCombinator2, TxinMapper>;
 
 
-pub open spec fn spec_txout() -> SpecTxoutCombinator {
-    SpecTxoutCombinator(
+pub open spec fn spec_txin() -> SpecTxinCombinator {
+    SpecTxinCombinator(
     Mapped {
-        inner: (U64Le, spec_script()),
-        mapper: TxoutMapper,
+        inner: (spec_outpoint(), (spec_script_sig(), U32Le)),
+        mapper: TxinMapper,
     })
 }
 
                 
-pub fn txout<'a>() -> (o: TxoutCombinator)
-    ensures o@ == spec_txout(),
+pub fn txin<'a>() -> (o: TxinCombinator)
+    ensures o@ == spec_txin(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = TxoutCombinator(
+    let combinator = TxinCombinator(
     Mapped {
-        inner: TxoutCombinator1((U64Le, script())),
-        mapper: TxoutMapper,
-    });
-    assert({
-        &&& combinator@ == spec_txout()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: TxinCombinator2((outpoint(), TxinCombinator1((script_sig(), U32Le)))),
+        mapper: TxinMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_txin()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_txout<'a>(input: &'a [u8]) -> (res: PResult<<TxoutCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_txin<'a>(input: &'a [u8]) -> (res: PResult<<TxinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_txout().spec_parse(input@) == Some((n as int, v@)),
-        spec_txout().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_txin().spec_parse(input@) == Some((n as int, v@)),
+        spec_txin().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_txout().spec_parse(input@) is None,
-        spec_txout().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_txin().spec_parse(input@) is None,
+        spec_txin().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = txout();
+    let combinator = txin();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_txout<'a>(v: <TxoutCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_txin<'a>(v: <TxinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_txout().wf(v@),
+        spec_txin().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_txout().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_txout().spec_serialize(v@))
+            &&& n == spec_txin().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_txin().spec_serialize(v@))
         },
 {
-    let combinator = txout();
+    let combinator = txin();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn txout_len<'a>(v: <TxoutCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn txin_len<'a>(v: <TxinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_txout().wf(v@),
-        spec_txout().spec_serialize(v@).len() <= usize::MAX,
+        spec_txin().wf(v@),
+        spec_txin().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_txout().spec_serialize(v@).len(),
+        serialize_len == spec_txin().spec_serialize(v@).len(),
 {
-    let combinator = txout();
+    let combinator = txin();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
@@ -1238,13 +1246,13 @@ impl SpecCombinator for SpecWitnessComponentCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecWitnessComponentCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecWitnessComponentCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -1252,11 +1260,11 @@ impl SecureSpecCombinator for SpecWitnessComponentCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecWitnessComponentCombinatorAlias = Mapped<SpecPair<BtcVarint, bytes::Variable>, WitnessComponentMapper>;
@@ -1272,13 +1280,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for WitnessComponentCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type WitnessComponentCombinatorAlias = Mapped<Pair<BtcVarint, bytes::Variable, WitnessComponentCont0>, WitnessComponentMapper>;
 
 
@@ -1292,7 +1300,7 @@ pub open spec fn spec_witness_component() -> SpecWitnessComponentCombinator {
 
 pub open spec fn spec_witness_component_cont0(deps: VarInt) -> bytes::Variable {
     let l = deps;
-    bytes::Variable(l.spec_into())
+    bytes::Variable((usize::spec_from(l)) as usize)
 }
 
 impl View for WitnessComponentCont0 {
@@ -1316,11 +1324,11 @@ pub fn witness_component<'a>() -> (o: WitnessComponentCombinator)
         inner: Pair::new(BtcVarint, WitnessComponentCont0),
         mapper: WitnessComponentMapper,
     });
-    assert({
-        &&& combinator@ == spec_witness_component()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_witness_component()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -1372,22 +1380,26 @@ type WitnessComponentCont0Input<'a, 'b, 'x> = POrSType<WitnessComponentCont0Type
 impl<'a, 'b, 'x> Continuation<WitnessComponentCont0Input<'a, 'b, 'x>> for WitnessComponentCont0 {
     type Output = bytes::Variable;
 
-    open spec fn requires(&self, deps: WitnessComponentCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: WitnessComponentCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (BtcVarint).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: WitnessComponentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_witness_component_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_witness_component_cont0(deps@)
     }
 
     fn apply(&self, deps: WitnessComponentCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                bytes::Variable(l.ex_into())
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
         }
     }
@@ -1480,13 +1492,13 @@ impl SpecCombinator for SpecWitnessCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecWitnessCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecWitnessCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -1494,11 +1506,11 @@ impl SecureSpecCombinator for SpecWitnessCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecWitnessCombinatorAlias = Mapped<SpecPair<BtcVarint, RepeatN<SpecWitnessComponentCombinator>>, WitnessMapper>;
@@ -1514,13 +1526,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for WitnessCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type WitnessCombinatorAlias = Mapped<Pair<BtcVarint, RepeatN<WitnessComponentCombinator>, WitnessCont0>, WitnessMapper>;
 
 
@@ -1534,7 +1546,7 @@ pub open spec fn spec_witness() -> SpecWitnessCombinator {
 
 pub open spec fn spec_witness_cont0(deps: VarInt) -> RepeatN<SpecWitnessComponentCombinator> {
     let count = deps;
-    RepeatN(spec_witness_component(), count.spec_into())
+    RepeatN(spec_witness_component(), (usize::spec_from(count)) as usize)
 }
 
 impl View for WitnessCont0 {
@@ -1558,11 +1570,11 @@ pub fn witness<'a>() -> (o: WitnessCombinator)
         inner: Pair::new(BtcVarint, WitnessCont0),
         mapper: WitnessMapper,
     });
-    assert({
-        &&& combinator@ == spec_witness()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_witness()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -1614,22 +1626,26 @@ type WitnessCont0Input<'a, 'b, 'x> = POrSType<WitnessCont0Type<'a, 'b>, WitnessC
 impl<'a, 'b, 'x> Continuation<WitnessCont0Input<'a, 'b, 'x>> for WitnessCont0 {
     type Output = RepeatN<WitnessComponentCombinator>;
 
-    open spec fn requires(&self, deps: WitnessCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: WitnessCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (BtcVarint).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: WitnessCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_witness_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_witness_cont0(deps@)
     }
 
     fn apply(&self, deps: WitnessCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let count = *deps;
-                RepeatN(witness_component(), count.ex_into())
+                let count = deps;
+                let count = *count;
+                RepeatN(witness_component(), (usize::ex_from(count)) as usize)
             }
             POrSType::S(deps) => {
                 let count = deps;
                 let count = *count;
-                RepeatN(witness_component(), count.ex_into())
+                RepeatN(witness_component(), (usize::ex_from(count)) as usize)
             }
         }
     }
@@ -1743,13 +1759,13 @@ impl SpecCombinator for SpecLockTimeCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecLockTimeCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecLockTimeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -1757,11 +1773,11 @@ impl SecureSpecCombinator for SpecLockTimeCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecLockTimeCombinatorAlias = Mapped<SpecLockTimeCombinatorAlias1, LockTimeMapper>;
@@ -1824,13 +1840,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LockTimeCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type LockTimeCombinatorAlias = Mapped<LockTimeCombinator1, LockTimeMapper>;
 
 
@@ -1845,11 +1861,11 @@ pub fn lock_time<'a>() -> (o: LockTimeCombinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = LockTimeCombinator(Mapped { inner: LockTimeCombinator1(Choice::new(Refined { inner: U32Le, predicate: Predicate675963002568997194 }, Refined { inner: U32Le, predicate: Predicate3133141078119142300 })), mapper: LockTimeMapper });
-    assert({
-        &&& combinator@ == spec_lock_time()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_lock_time()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -1998,13 +2014,13 @@ impl SpecCombinator for SpecTxSegwitCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecTxSegwitCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecTxSegwitCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -2012,11 +2028,11 @@ impl SecureSpecCombinator for SpecTxSegwitCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecTxSegwitCombinatorAlias = Mapped<SpecPair<SpecPair<(Refined<U8, TagPred<u8>>, BtcVarint), (RepeatN<SpecTxinCombinator>, BtcVarint)>, (RepeatN<SpecTxoutCombinator>, (RepeatN<SpecWitnessCombinator>, SpecLockTimeCombinator))>, TxSegwitMapper>;
@@ -2032,13 +2048,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TxSegwitCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type TxSegwitCombinatorAlias = Mapped<Pair<Pair<(Refined<U8, TagPred<u8>>, BtcVarint), (RepeatN<TxinCombinator>, BtcVarint), TxSegwitCont1>, (RepeatN<TxoutCombinator>, (RepeatN<WitnessCombinator>, LockTimeCombinator)), TxSegwitCont0>, TxSegwitMapper>;
 
 
@@ -2052,7 +2068,7 @@ pub open spec fn spec_tx_segwit() -> SpecTxSegwitCombinator {
 
 pub open spec fn spec_tx_segwit_cont1(deps: (u8, VarInt)) -> (RepeatN<SpecTxinCombinator>, BtcVarint) {
     let (_, txin_count) = deps;
-    (RepeatN(spec_txin(), txin_count.spec_into()), BtcVarint)
+    (RepeatN(spec_txin(), (usize::spec_from(txin_count)) as usize), BtcVarint)
 }
 
 impl View for TxSegwitCont1 {
@@ -2067,7 +2083,7 @@ impl View for TxSegwitCont1 {
 
 pub open spec fn spec_tx_segwit_cont0(deps: ((u8, VarInt), (Seq<SpecTxin>, VarInt))) -> (RepeatN<SpecTxoutCombinator>, (RepeatN<SpecWitnessCombinator>, SpecLockTimeCombinator)) {
     let ((_, txin_count), (_, txout_count)) = deps;
-    (RepeatN(spec_txout(), txout_count.spec_into()), (RepeatN(spec_witness(), txin_count.spec_into()), spec_lock_time()))
+    (RepeatN(spec_txout(), (usize::spec_from(txout_count)) as usize), (RepeatN(spec_witness(), (usize::spec_from(txin_count)) as usize), spec_lock_time()))
 }
 
 impl View for TxSegwitCont0 {
@@ -2091,11 +2107,11 @@ pub fn tx_segwit<'a>() -> (o: TxSegwitCombinator)
         inner: Pair::new(Pair::new((Refined { inner: U8, predicate: TagPred(TXSEGWITFLAG_CONST) }, BtcVarint), TxSegwitCont1), TxSegwitCont0),
         mapper: TxSegwitMapper,
     });
-    assert({
-        &&& combinator@ == spec_tx_segwit()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_tx_segwit()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -2147,22 +2163,26 @@ type TxSegwitCont1Input<'a, 'b, 'x> = POrSType<TxSegwitCont1Type<'a, 'b>, TxSegw
 impl<'a, 'b, 'x> Continuation<TxSegwitCont1Input<'a, 'b, 'x>> for TxSegwitCont1 {
     type Output = (RepeatN<TxinCombinator>, BtcVarint);
 
-    open spec fn requires(&self, deps: TxSegwitCont1Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: TxSegwitCont1Input<'a, 'b, 'x>) -> bool {
+        &&& ((Refined { inner: U8, predicate: TagPred(TXSEGWITFLAG_CONST) }, BtcVarint)).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: TxSegwitCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_tx_segwit_cont1(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_tx_segwit_cont1(deps@)
     }
 
     fn apply(&self, deps: TxSegwitCont1Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let (_, txin_count) = *deps;
-                (RepeatN(txin(), txin_count.ex_into()), BtcVarint)
+                let (_, txin_count) = deps;
+                let txin_count = *txin_count;
+                (RepeatN(txin(), (usize::ex_from(txin_count)) as usize), BtcVarint)
             }
             POrSType::S(deps) => {
                 let (_, txin_count) = deps;
                 let txin_count = *txin_count;
-                (RepeatN(txin(), txin_count.ex_into()), BtcVarint)
+                (RepeatN(txin(), (usize::ex_from(txin_count)) as usize), BtcVarint)
             }
         }
     }
@@ -2174,22 +2194,28 @@ type TxSegwitCont0Input<'a, 'b, 'x> = POrSType<TxSegwitCont0Type<'a, 'b>, TxSegw
 impl<'a, 'b, 'x> Continuation<TxSegwitCont0Input<'a, 'b, 'x>> for TxSegwitCont0 {
     type Output = (RepeatN<TxoutCombinator>, (RepeatN<WitnessCombinator>, LockTimeCombinator));
 
-    open spec fn requires(&self, deps: TxSegwitCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: TxSegwitCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new((Refined { inner: U8, predicate: TagPred(TXSEGWITFLAG_CONST) }, BtcVarint), |deps| spec_tx_segwit_cont1(deps))).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: TxSegwitCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_tx_segwit_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_tx_segwit_cont0(deps@)
     }
 
     fn apply(&self, deps: TxSegwitCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let ((_, txin_count), (_, txout_count)) = *deps;
-                (RepeatN(txout(), txout_count.ex_into()), (RepeatN(witness(), txin_count.ex_into()), lock_time()))
+                let ((_, txin_count), (_, txout_count)) = deps;
+                let txin_count = *txin_count;
+                let txout_count = *txout_count;
+                (RepeatN(txout(), (usize::ex_from(txout_count)) as usize), (RepeatN(witness(), (usize::ex_from(txin_count)) as usize), lock_time()))
             }
             POrSType::S(deps) => {
                 let ((_, txin_count), (_, txout_count)) = deps;
-                let (txin_count, txout_count) = (*txin_count, *txout_count);
-                (RepeatN(txout(), txout_count.ex_into()), (RepeatN(witness(), txin_count.ex_into()), lock_time()))
+                let txin_count = *txin_count;
+                let txout_count = *txout_count;
+                (RepeatN(txout(), (usize::ex_from(txout_count)) as usize), (RepeatN(witness(), (usize::ex_from(txin_count)) as usize), lock_time()))
             }
         }
     }
@@ -2288,13 +2314,13 @@ impl SpecCombinator for SpecTxNonsegwitCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecTxNonsegwitCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecTxNonsegwitCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -2302,11 +2328,11 @@ impl SecureSpecCombinator for SpecTxNonsegwitCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecTxNonsegwitCombinatorAlias = Mapped<SpecPair<(RepeatN<SpecTxinCombinator>, BtcVarint), (RepeatN<SpecTxoutCombinator>, SpecLockTimeCombinator)>, TxNonsegwitMapper>;
@@ -2322,27 +2348,27 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TxNonsegwitCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type TxNonsegwitCombinatorAlias = Mapped<Pair<(RepeatN<TxinCombinator>, BtcVarint), (RepeatN<TxoutCombinator>, LockTimeCombinator), TxNonsegwitCont0>, TxNonsegwitMapper>;
 
 
 pub open spec fn spec_tx_nonsegwit(txin_count: VarInt) -> SpecTxNonsegwitCombinator {
     SpecTxNonsegwitCombinator(
     Mapped {
-        inner: Pair::spec_new((RepeatN(spec_txin(), txin_count.spec_into()), BtcVarint), |deps| spec_tx_nonsegwit_cont0(deps)),
+        inner: Pair::spec_new((RepeatN(spec_txin(), (usize::spec_from(txin_count)) as usize), BtcVarint), |deps| spec_tx_nonsegwit_cont0(txin_count, deps)),
         mapper: TxNonsegwitMapper,
     })
 }
 
-pub open spec fn spec_tx_nonsegwit_cont0(deps: (Seq<SpecTxin>, VarInt)) -> (RepeatN<SpecTxoutCombinator>, SpecLockTimeCombinator) {
+pub open spec fn spec_tx_nonsegwit_cont0(txin_count: VarInt, deps: (Seq<SpecTxin>, VarInt)) -> (RepeatN<SpecTxoutCombinator>, SpecLockTimeCombinator) {
     let (_, txout_count) = deps;
-    (RepeatN(spec_txout(), txout_count.spec_into()), spec_lock_time())
+    (RepeatN(spec_txout(), (usize::spec_from(txout_count)) as usize), spec_lock_time())
 }
 
 impl View for TxNonsegwitCont0 {
@@ -2350,32 +2376,34 @@ impl View for TxNonsegwitCont0 {
 
     open spec fn view(&self) -> Self::V {
         |deps: (Seq<SpecTxin>, VarInt)| {
-            spec_tx_nonsegwit_cont0(deps)
+            spec_tx_nonsegwit_cont0(self.txin_count@, deps)
         }
     }
 }
 
 pub fn tx_nonsegwit<'a>(txin_count: VarInt) -> (o: TxNonsegwitCombinator)
+
     ensures o@ == spec_tx_nonsegwit(txin_count@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = TxNonsegwitCombinator(
     Mapped {
-        inner: Pair::new((RepeatN(txin(), txin_count.ex_into()), BtcVarint), TxNonsegwitCont0),
+        inner: Pair::new((RepeatN(txin(), (usize::ex_from(txin_count)) as usize), BtcVarint), TxNonsegwitCont0 { txin_count }),
         mapper: TxNonsegwitMapper,
     });
-    assert({
-        &&& combinator@ == spec_tx_nonsegwit(txin_count@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_tx_nonsegwit(txin_count@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
 pub fn parse_tx_nonsegwit<'a>(input: &'a [u8], txin_count: VarInt) -> (res: PResult<<TxNonsegwitCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
         res matches Ok((n, v)) ==> spec_tx_nonsegwit(txin_count@).spec_parse(input@) == Some((n as int, v@)),
         spec_tx_nonsegwit(txin_count@).spec_parse(input@) matches Some((n, v))
@@ -2391,6 +2419,7 @@ pub fn serialize_tx_nonsegwit<'a>(v: <TxNonsegwitCombinator as Combinator<'a, &'
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_tx_nonsegwit(txin_count@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -2407,6 +2436,7 @@ pub fn tx_nonsegwit_len<'a>(v: <TxNonsegwitCombinator as Combinator<'a, &'a [u8]
     requires
         spec_tx_nonsegwit(txin_count@).wf(v@),
         spec_tx_nonsegwit(txin_count@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
         serialize_len == spec_tx_nonsegwit(txin_count@).spec_serialize(v@).len(),
 {
@@ -2414,29 +2444,38 @@ pub fn tx_nonsegwit_len<'a>(v: <TxNonsegwitCombinator as Combinator<'a, &'a [u8]
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct TxNonsegwitCont0;
+pub struct TxNonsegwitCont0 {
+    pub txin_count: VarInt,
+}
 type TxNonsegwitCont0Type<'a, 'b> = &'b (RepeatResult<Txin<'a>>, VarInt);
 type TxNonsegwitCont0SType<'a, 'x> = (&'x RepeatResult<Txin<'a>>, &'x VarInt);
 type TxNonsegwitCont0Input<'a, 'b, 'x> = POrSType<TxNonsegwitCont0Type<'a, 'b>, TxNonsegwitCont0SType<'a, 'x>>;
 impl<'a, 'b, 'x> Continuation<TxNonsegwitCont0Input<'a, 'b, 'x>> for TxNonsegwitCont0 {
     type Output = (RepeatN<TxoutCombinator>, LockTimeCombinator);
 
-    open spec fn requires(&self, deps: TxNonsegwitCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: TxNonsegwitCont0Input<'a, 'b, 'x>) -> bool {        let txin_count = self.txin_count@;
+
+        &&& ((RepeatN(spec_txin(), (usize::spec_from(txin_count)) as usize), BtcVarint)).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: TxNonsegwitCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_tx_nonsegwit_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_tx_nonsegwit_cont0(self.txin_count@, deps@)
     }
 
     fn apply(&self, deps: TxNonsegwitCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let (_, txout_count) = *deps;
-                (RepeatN(txout(), txout_count.ex_into()), lock_time())
+                let (_, txout_count) = deps;
+                let txin_count = self.txin_count;
+                let txout_count = *txout_count;
+                (RepeatN(txout(), (usize::ex_from(txout_count)) as usize), lock_time())
             }
             POrSType::S(deps) => {
                 let (_, txout_count) = deps;
+                let txin_count = self.txin_count;
                 let txout_count = *txout_count;
-                (RepeatN(txout(), txout_count.ex_into()), lock_time())
+                (RepeatN(txout(), (usize::ex_from(txout_count)) as usize), lock_time())
             }
         }
     }
@@ -2549,13 +2588,13 @@ impl SpecCombinator for SpecTxRestCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecTxRestCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecTxRestCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -2563,11 +2602,11 @@ impl SecureSpecCombinator for SpecTxRestCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecTxRestCombinatorAlias = Mapped<SpecTxRestCombinatorAlias1, TxRestMapper>;
@@ -2590,13 +2629,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TxRestCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type TxRestCombinatorAlias = Mapped<TxRestCombinator1, TxRestMapper>;
 
 
@@ -2605,22 +2644,24 @@ pub open spec fn spec_tx_rest(txin_count: VarInt) -> SpecTxRestCombinator {
 }
 
 pub fn tx_rest<'a>(txin_count: VarInt) -> (o: TxRestCombinator)
+
     ensures o@ == spec_tx_rest(txin_count@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = TxRestCombinator(Mapped { inner: TxRestCombinator1(Choice::new(Cond { cond: txin_count.as_usize() == 0, inner: tx_segwit() }, Cond { cond: !(txin_count.as_usize() == 0), inner: tx_nonsegwit(txin_count) })), mapper: TxRestMapper });
-    assert({
-        &&& combinator@ == spec_tx_rest(txin_count@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_tx_rest(txin_count@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
 pub fn parse_tx_rest<'a>(input: &'a [u8], txin_count: VarInt) -> (res: PResult<<TxRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
         res matches Ok((n, v)) ==> spec_tx_rest(txin_count@).spec_parse(input@) == Some((n as int, v@)),
         spec_tx_rest(txin_count@).spec_parse(input@) matches Some((n, v))
@@ -2636,6 +2677,7 @@ pub fn serialize_tx_rest<'a>(v: <TxRestCombinator as Combinator<'a, &'a [u8], Ve
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_tx_rest(txin_count@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -2652,6 +2694,7 @@ pub fn tx_rest_len<'a>(v: <TxRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>
     requires
         spec_tx_rest(txin_count@).wf(v@),
         spec_tx_rest(txin_count@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
         serialize_len == spec_tx_rest(txin_count@).spec_serialize(v@).len(),
 {
@@ -2749,13 +2792,13 @@ impl SpecCombinator for SpecTxCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecTxCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecTxCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -2763,11 +2806,11 @@ impl SecureSpecCombinator for SpecTxCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecTxCombinatorAlias = Mapped<SpecPair<(U32Le, BtcVarint), SpecTxRestCombinator>, TxMapper>;
@@ -2783,13 +2826,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TxCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type TxCombinatorAlias = Mapped<Pair<(U32Le, BtcVarint), TxRestCombinator, TxCont0>, TxMapper>;
 
 
@@ -2827,11 +2870,11 @@ pub fn tx<'a>() -> (o: TxCombinator)
         inner: Pair::new((U32Le, BtcVarint), TxCont0),
         mapper: TxMapper,
     });
-    assert({
-        &&& combinator@ == spec_tx()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_tx()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -2883,16 +2926,20 @@ type TxCont0Input<'a, 'b, 'x> = POrSType<TxCont0Type<'a, 'b>, TxCont0SType<'a, '
 impl<'a, 'b, 'x> Continuation<TxCont0Input<'a, 'b, 'x>> for TxCont0 {
     type Output = TxRestCombinator;
 
-    open spec fn requires(&self, deps: TxCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: TxCont0Input<'a, 'b, 'x>) -> bool {
+        &&& ((U32Le, BtcVarint)).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: TxCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_tx_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_tx_cont0(deps@)
     }
 
     fn apply(&self, deps: TxCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let (_, txin_count) = *deps;
+                let (_, txin_count) = deps;
+                let txin_count = *txin_count;
                 tx_rest(txin_count)
             }
             POrSType::S(deps) => {
@@ -3009,13 +3056,13 @@ impl SpecCombinator for SpecBlockCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecBlockCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecBlockCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -3023,11 +3070,11 @@ impl SecureSpecCombinator for SpecBlockCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecBlockCombinatorAlias = Mapped<SpecPair<(U32Le, (bytes::Fixed<32>, (bytes::Fixed<32>, (U32Le, (U32Le, (U32Le, BtcVarint)))))), RepeatN<SpecTxCombinator>>, BlockMapper>;
@@ -3043,13 +3090,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for BlockCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type BlockCombinatorAlias = Mapped<Pair<(U32Le, (bytes::Fixed<32>, (bytes::Fixed<32>, (U32Le, (U32Le, (U32Le, BtcVarint)))))), RepeatN<TxCombinator>, BlockCont0>, BlockMapper>;
 
 
@@ -3063,7 +3110,7 @@ pub open spec fn spec_block() -> SpecBlockCombinator {
 
 pub open spec fn spec_block_cont0(deps: (u32, (Seq<u8>, (Seq<u8>, (u32, (u32, (u32, VarInt))))))) -> RepeatN<SpecTxCombinator> {
     let (_, (_, (_, (_, (_, (_, tx_count)))))) = deps;
-    RepeatN(spec_tx(), tx_count.spec_into())
+    RepeatN(spec_tx(), (usize::spec_from(tx_count)) as usize)
 }
 
 impl View for BlockCont0 {
@@ -3087,11 +3134,11 @@ pub fn block<'a>() -> (o: BlockCombinator)
         inner: Pair::new((U32Le, (bytes::Fixed::<32>, (bytes::Fixed::<32>, (U32Le, (U32Le, (U32Le, BtcVarint)))))), BlockCont0),
         mapper: BlockMapper,
     });
-    assert({
-        &&& combinator@ == spec_block()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_block()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -3143,22 +3190,26 @@ type BlockCont0Input<'a, 'b, 'x> = POrSType<BlockCont0Type<'a, 'b>, BlockCont0ST
 impl<'a, 'b, 'x> Continuation<BlockCont0Input<'a, 'b, 'x>> for BlockCont0 {
     type Output = RepeatN<TxCombinator>;
 
-    open spec fn requires(&self, deps: BlockCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: BlockCont0Input<'a, 'b, 'x>) -> bool {
+        &&& ((U32Le, (bytes::Fixed::<32>, (bytes::Fixed::<32>, (U32Le, (U32Le, (U32Le, BtcVarint))))))).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: BlockCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_block_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_block_cont0(deps@)
     }
 
     fn apply(&self, deps: BlockCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let (_, (_, (_, (_, (_, (_, tx_count)))))) = *deps;
-                RepeatN(tx(), tx_count.ex_into())
+                let (_, (_, (_, (_, (_, (_, tx_count)))))) = deps;
+                let tx_count = *tx_count;
+                RepeatN(tx(), (usize::ex_from(tx_count)) as usize)
             }
             POrSType::S(deps) => {
                 let (_, (_, (_, (_, (_, (_, tx_count)))))) = deps;
                 let tx_count = *tx_count;
-                RepeatN(tx(), tx_count.ex_into())
+                RepeatN(tx(), (usize::ex_from(tx_count)) as usize)
             }
         }
     }
diff --git a/vest-dsl/src/ast.rs b/vest-dsl/src/ast.rs
index 07c0641e..5128e2d9 100644
--- a/vest-dsl/src/ast.rs
+++ b/vest-dsl/src/ast.rs
@@ -38,11 +38,6 @@ pub enum Definition<'i> {
         combinator: Combinator<'i>,
         span: Span<'i>,
     },
-    SecCombinator {
-        name: Identifier<'i>,
-        combinator: Combinator<'i>,
-        span: Span<'i>,
-    },
     ConstCombinator {
         name: Identifier<'i>,
         const_combinator: ConstCombinator<'i>,
@@ -64,9 +59,6 @@ pub enum Endianess {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ParamDefn<'i> {
-    Stream {
-        name: Identifier<'i>,
-    },
     Dependent {
         name: Identifier<'i>,
         combinator: CombinatorInner<'i>,
@@ -89,12 +81,10 @@ pub enum CombinatorInner<'i> {
     Wrap(WrapCombinator<'i>),
     Enum(EnumCombinator<'i>),
     Choice(ChoiceCombinator<'i>),
-    SepBy(SepByCombinator<'i>),
     Vec(VecCombinator<'i>),
     Array(ArrayCombinator<'i>),
     Bytes(BytesCombinator<'i>),
     Tail(TailCombinator<'i>),
-    Apply(ApplyCombinator<'i>),
     Option(OptionCombinator<'i>),
     Invocation(CombinatorInvocation<'i>),
     MacroInvocation {
@@ -239,7 +229,6 @@ impl PartialEq for StructCombinator<'_> {
 
 #[derive(Debug, Clone, Eq, Hash)]
 pub enum StructField<'i> {
-    Stream(StreamTransform<'i>),
     Dependent {
         label: Identifier<'i>,
         combinator: Combinator<'i>,
@@ -260,7 +249,6 @@ pub enum StructField<'i> {
 impl PartialEq for StructField<'_> {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
-            (StructField::Stream(s1), StructField::Stream(s2)) => s1 == s2,
             (
                 StructField::Dependent {
                     label: l1,
@@ -302,17 +290,8 @@ impl PartialEq for StructField<'_> {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct StreamTransform<'i> {
-    pub streams: Vec<String>,
-    pub func: Identifier<'i>,
-    pub args: Vec<Param<'i>>,
-    pub span: Span<'i>,
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Param<'i> {
-    Stream(Identifier<'i>),
     Dependent(Identifier<'i>),
 }
 
@@ -399,19 +378,12 @@ pub enum Choices<'i> {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum VecCombinator<'i> {
     Vec(Box<Combinator<'i>>),
-    Vec1(Box<Combinator<'i>>),
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SepByCombinator<'i> {
-    pub combinator: VecCombinator<'i>,
-    pub sep: ConstCombinator<'i>,
 }
 
 #[derive(Debug, Clone, Eq, Hash)]
 pub struct ArrayCombinator<'i> {
     pub combinator: Box<Combinator<'i>>,
-    pub len: LengthSpecifier<'i>,
+    pub len: LengthExpr<'i>,
     pub span: Span<'i>,
 }
 
@@ -421,12 +393,190 @@ impl PartialEq for ArrayCombinator<'_> {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum LengthSpecifier<'i> {
-    Const(usize),
-    Dependent(Identifier<'i>),
+/// Arithmetic operators for length expressions
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ArithOp {
+    Add,
+    Sub,
+    Mul,
+    Div,
+}
+
+/// A dependent field identifier, potentially with nested field access (e.g., @hdr.payload_length)
+#[derive(Debug, Clone, Eq)]
+pub struct DependentId<'i> {
+    /// The root field name (without @)
+    pub root: String,
+    /// Optional path of nested field accesses
+    pub path: Vec<String>,
+    pub span: Span<'i>,
+}
+
+impl PartialEq for DependentId<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.root == other.root && self.path == other.path
+    }
+}
+
+impl Hash for DependentId<'_> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.root.hash(state);
+        self.path.hash(state);
+    }
 }
 
+impl<'i> DependentId<'i> {
+    pub fn simple(name: String, span: Span<'i>) -> Self {
+        Self {
+            root: name,
+            path: Vec::new(),
+            span,
+        }
+    }
+
+    pub fn is_simple(&self) -> bool {
+        self.path.is_empty()
+    }
+
+    /// Returns the full path as a dotted string (e.g., "hdr.payload_length")
+    pub fn full_path(&self) -> String {
+        if self.path.is_empty() {
+            self.root.clone()
+        } else {
+            format!("{}.{}", self.root, self.path.join("."))
+        }
+    }
+}
+
+impl Display for DependentId<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "@{}", self.full_path())
+    }
+}
+
+/// Length expression for array sizes - supports constants, dependent fields,
+/// static size expressions, and arithmetic
+#[derive(Debug, Clone, Eq, Hash)]
+pub enum LengthExpr<'i> {
+    Const {
+        value: usize,
+        span: Span<'i>,
+    },
+    Dependent(DependentId<'i>),
+    SizeOf {
+        format_name: Identifier<'i>,
+        span: Span<'i>,
+    },
+    BinOp {
+        op: ArithOp,
+        left: Box<LengthExpr<'i>>,
+        right: Box<LengthExpr<'i>>,
+        span: Span<'i>,
+    },
+}
+
+impl PartialEq for LengthExpr<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (LengthExpr::Const { value: v1, .. }, LengthExpr::Const { value: v2, .. }) => v1 == v2,
+            (LengthExpr::Dependent(d1), LengthExpr::Dependent(d2)) => d1 == d2,
+            (
+                LengthExpr::SizeOf {
+                    format_name: n1, ..
+                },
+                LengthExpr::SizeOf {
+                    format_name: n2, ..
+                },
+            ) => n1 == n2,
+            (
+                LengthExpr::BinOp {
+                    op: o1,
+                    left: l1,
+                    right: r1,
+                    ..
+                },
+                LengthExpr::BinOp {
+                    op: o2,
+                    left: l2,
+                    right: r2,
+                    ..
+                },
+            ) => o1 == o2 && l1 == l2 && r1 == r2,
+            _ => false,
+        }
+    }
+}
+
+impl<'i> LengthExpr<'i> {
+    pub fn as_span(&self) -> Span<'i> {
+        match self {
+            LengthExpr::Const { span, .. } => *span,
+            LengthExpr::Dependent(d) => d.span,
+            LengthExpr::SizeOf { span, .. } => *span,
+            LengthExpr::BinOp { span, .. } => *span,
+        }
+    }
+
+    /// Collects all dependent identifiers referenced in this length expression
+    pub fn collect_dependent_ids(&self) -> Vec<&DependentId<'i>> {
+        match self {
+            LengthExpr::Const { .. } | LengthExpr::SizeOf { .. } => Vec::new(),
+            LengthExpr::Dependent(d) => vec![d],
+            LengthExpr::BinOp { left, right, .. } => {
+                let mut ids = left.collect_dependent_ids();
+                ids.extend(right.collect_dependent_ids());
+                ids
+            }
+        }
+    }
+
+    /// Returns true if this is a simple constant value
+    pub fn is_const(&self) -> bool {
+        matches!(self, LengthExpr::Const { .. })
+    }
+
+    /// Returns the constant value if this is a simple constant
+    pub fn as_const(&self) -> Option<usize> {
+        match self {
+            LengthExpr::Const { value, .. } => Some(*value),
+            _ => None,
+        }
+    }
+}
+
+impl<'i> DependentId<'i> {
+    /// Convert to an Identifier (only works for simple ids without nested access)
+    pub fn to_identifier(&self) -> Identifier<'i> {
+        Identifier {
+            name: self.root.clone(),
+            span: self.span,
+        }
+    }
+}
+
+impl Display for LengthExpr<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LengthExpr::Const { value, .. } => write!(f, "{}", value),
+            LengthExpr::Dependent(d) => write!(f, "{}", d),
+            LengthExpr::SizeOf { format_name, .. } => write!(f, "|{}|", format_name),
+            LengthExpr::BinOp {
+                op, left, right, ..
+            } => {
+                let op_str = match op {
+                    ArithOp::Add => "+",
+                    ArithOp::Sub => "-",
+                    ArithOp::Mul => "*",
+                    ArithOp::Div => "/",
+                };
+                write!(f, "({} {} {})", left, op_str, right)
+            }
+        }
+    }
+}
+
+pub type LengthSpecifier<'i> = LengthExpr<'i>;
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct OptionCombinator<'i>(pub Box<Combinator<'i>>);
 
@@ -447,12 +597,6 @@ impl PartialEq for TailCombinator<'_> {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ApplyCombinator<'i> {
-    pub stream: Identifier<'i>,
-    pub combinator: Box<Combinator<'i>>,
-}
-
 #[derive(Debug, Clone, Eq, Hash)]
 pub struct CombinatorInvocation<'i> {
     pub func: Identifier<'i>,
@@ -468,13 +612,9 @@ impl PartialEq for CombinatorInvocation<'_> {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ConstCombinator<'i> {
-    Vec(Box<ConstCombinator<'i>>),
-    ConstArray(ConstArrayCombinator<'i>),
     ConstBytes(ConstBytesCombinator<'i>),
     ConstInt(ConstIntCombinator<'i>),
     ConstEnum(ConstEnumCombinator<'i>),
-    ConstStruct(ConstStructCombinator<'i>),
-    ConstChoice(ConstChoiceCombinator<'i>),
     ConstCombinatorInvocation {
         name: Identifier<'i>,
         span: Span<'i>,
@@ -484,32 +624,14 @@ pub enum ConstCombinator<'i> {
 impl<'i> ConstCombinator<'i> {
     pub fn as_span(&self) -> Span<'i> {
         match self {
-            ConstCombinator::Vec(c) => c.as_span(),
-            ConstCombinator::ConstArray(c) => c.span,
             ConstCombinator::ConstBytes(c) => c.span,
             ConstCombinator::ConstInt(c) => c.span,
             ConstCombinator::ConstEnum(c) => c.span,
-            ConstCombinator::ConstStruct(..) => todo!("VestDSL does not support const structs yet"),
-            ConstCombinator::ConstChoice(..) => todo!("VestDSL does not support const choices yet"),
             ConstCombinator::ConstCombinatorInvocation { span, .. } => *span,
         }
     }
 }
 
-#[derive(Debug, Clone, Eq, Hash)]
-pub struct ConstArrayCombinator<'i> {
-    pub combinator: IntCombinator,
-    pub len: usize,
-    pub values: ConstArray<'i>,
-    pub span: Span<'i>,
-}
-
-impl PartialEq for ConstArrayCombinator<'_> {
-    fn eq(&self, other: &Self) -> bool {
-        self.combinator == other.combinator && self.len == other.len && self.values == other.values
-    }
-}
-
 #[derive(Debug, Clone, Eq, Hash)]
 pub struct ConstBytesCombinator<'i> {
     pub len: usize,
@@ -616,17 +738,6 @@ impl PartialEq for ConstIntCombinator<'_> {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstStructCombinator<'i>(pub Vec<ConstCombinator<'i>>);
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstChoiceCombinator<'i>(pub Vec<ConstChoice<'i>>);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstChoice<'i> {
-    pub tag: String,
-    pub combinator: ConstCombinator<'i>,
-}
-
 impl Display for Identifier<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.name)
@@ -648,17 +759,12 @@ impl Display for Definition<'_> {
                 }
                 write!(f, " = {}", combinator)
             }
-            Definition::SecCombinator {
-                name, combinator, ..
-            } => {
-                write!(f, "secret {} = {}", name, combinator)
-            }
             Definition::ConstCombinator {
                 name,
                 const_combinator,
                 ..
             } => {
-                write!(f, "const {} = {}", name, const_combinator)
+                write!(f, "const {}: {}", name, const_combinator)
             }
             Definition::Endianess(endianess) => match endianess {
                 Endianess::Little => write!(f, "!LITTLE_ENDIAN"),
@@ -684,7 +790,6 @@ impl Display for Definition<'_> {
 impl Display for ParamDefn<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ParamDefn::Stream { name } => write!(f, "${}", name),
             ParamDefn::Dependent {
                 name, combinator, ..
             } => write!(f, "{}:{}", name, combinator),
@@ -711,16 +816,14 @@ impl Display for CombinatorInner<'_> {
             CombinatorInner::Wrap(w) => write!(f, "{}", w),
             CombinatorInner::Enum(e) => write!(f, "{}", e),
             CombinatorInner::Choice(c) => write!(f, "{}", c),
-            CombinatorInner::SepBy(s) => write!(f, "{}", s),
             CombinatorInner::Vec(v) => write!(f, "{}", v),
             CombinatorInner::Array(a) => write!(f, "{}", a),
             CombinatorInner::Bytes(a) => write!(f, "{}", a),
             CombinatorInner::Tail(t) => write!(f, "{}", t),
-            CombinatorInner::Apply(a) => write!(f, "{}", a),
             CombinatorInner::Option(o) => write!(f, "{}", o),
             CombinatorInner::Invocation(i) => write!(f, "{}", i),
             CombinatorInner::MacroInvocation { name, args } => {
-                write!(f, "{}({})", name, args.iter().join(","))
+                write!(f, "{}!({})", name, args.iter().join(","))
             }
         }
     }
@@ -786,7 +889,6 @@ impl Display for StructCombinator<'_> {
 impl Display for StructField<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            StructField::Stream(s) => write!(f, "{}", s),
             StructField::Dependent {
                 label, combinator, ..
             } => {
@@ -809,24 +911,14 @@ impl Display for StructField<'_> {
 impl Display for ConstCombinator<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ConstCombinator::Vec(v) => write!(f, "{}", v),
-            ConstCombinator::ConstArray(a) => write!(f, "{}", a),
             ConstCombinator::ConstBytes(b) => write!(f, "{}", b),
             ConstCombinator::ConstInt(i) => write!(f, "{}", i),
             ConstCombinator::ConstEnum(e) => write!(f, "{}", e),
-            ConstCombinator::ConstStruct(s) => write!(f, "{}", s),
-            ConstCombinator::ConstChoice(c) => write!(f, "{}", c),
             ConstCombinator::ConstCombinatorInvocation { name, .. } => write!(f, "{}", name),
         }
     }
 }
 
-impl Display for ConstArrayCombinator<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "[{}]", self.values)
-    }
-}
-
 impl Display for ConstBytesCombinator<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.values)
@@ -896,42 +988,9 @@ impl Display for ConstIntCombinator<'_> {
     }
 }
 
-impl Display for ConstStructCombinator<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{{")?;
-        for combinator in &self.0 {
-            write!(f, "{}", combinator)?;
-        }
-        write!(f, "}}")
-    }
-}
-
-impl Display for ConstChoiceCombinator<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{{")?;
-        for choice in &self.0 {
-            write!(f, "{}", choice)?;
-        }
-        write!(f, "}}")
-    }
-}
-
-impl Display for ConstChoice<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}:{}", self.tag, self.combinator)
-    }
-}
-
-impl Display for StreamTransform<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "@{}({})", self.func, self.args.iter().join(","))
-    }
-}
-
 impl Display for Param<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Param::Stream(s) => write!(f, "${}", s),
             Param::Dependent(s) => write!(f, "{}", s),
         }
     }
@@ -980,7 +1039,7 @@ impl Display for Enum<'_> {
 
 impl Display for ChoiceCombinator<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "choice ")?;
+        write!(f, "choose ")?;
         if let Some(depend_id) = &self.depend_id {
             write!(f, "({})", depend_id)?;
         }
@@ -1018,17 +1077,10 @@ impl Display for Choices<'_> {
     }
 }
 
-impl Display for SepByCombinator<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}_sepby_{}", self.combinator, self.sep)
-    }
-}
-
 impl Display for VecCombinator<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            VecCombinator::Vec(v) => write!(f, "{}*", v),
-            VecCombinator::Vec1(v) => write!(f, "{}+", v),
+            VecCombinator::Vec(v) => write!(f, "Vec<{}>", v),
         }
     }
 }
@@ -1039,15 +1091,6 @@ impl Display for ArrayCombinator<'_> {
     }
 }
 
-impl Display for LengthSpecifier<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            LengthSpecifier::Const(n) => write!(f, "{}", n),
-            LengthSpecifier::Dependent(s) => write!(f, "@{}", s),
-        }
-    }
-}
-
 impl Display for BytesCombinator<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "[u8; {}]", self.len)
@@ -1062,13 +1105,7 @@ impl Display for TailCombinator<'_> {
 
 impl Display for OptionCombinator<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}?", self.0)
-    }
-}
-
-impl Display for ApplyCombinator<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}({})", self.stream, self.combinator)
+        write!(f, "Option<{}>", self.0)
     }
 }
 
@@ -1094,14 +1131,10 @@ impl<'i> CombinatorInner<'i> {
                 | EnumCombinator::NonExhaustive { span, .. },
             ) => *span,
             CombinatorInner::Choice(c) => c.span,
-            CombinatorInner::SepBy(s) => match &s.combinator {
-                VecCombinator::Vec(v) | VecCombinator::Vec1(v) => v.span,
-            },
-            CombinatorInner::Vec(VecCombinator::Vec(v) | VecCombinator::Vec1(v)) => v.span,
+            CombinatorInner::Vec(VecCombinator::Vec(v)) => v.span,
             CombinatorInner::Array(a) => a.span,
             CombinatorInner::Bytes(b) => b.span,
             CombinatorInner::Tail(t) => t.span,
-            CombinatorInner::Apply(a) => a.combinator.span,
             CombinatorInner::Option(o) => o.0.span,
             CombinatorInner::Invocation(i) => i.span,
             CombinatorInner::MacroInvocation { .. } => Span::new("", 0, 0).unwrap(),
@@ -1109,7 +1142,7 @@ impl<'i> CombinatorInner<'i> {
     }
 }
 
-pub fn from_str(source: &str) -> Result<Vec<Definition>, Box<Error<Rule>>> {
+pub fn from_str(source: &str) -> Result<Vec<Definition<'_>>, Box<Error<Rule>>> {
     let mut definitions = vec![];
 
     let pairs = VestCombinator::parse(Rule::grammar, source)?;
@@ -1135,64 +1168,30 @@ fn build_definition(pair: pest::iterators::Pair<Rule>) -> Definition {
     let span = rule.as_span();
     match rule.as_rule() {
         Rule::combinator_defn => {
-            // combinator_defn     = { secret? ~ var_id ~ param_defn_list? ~ "=" ~ combinator }
             let mut inner_rules = rule.into_inner();
-            // check if secret
+            let name = build_id(inner_rules.next().unwrap());
             let next_rule = inner_rules.next().unwrap();
             match next_rule.as_rule() {
-                Rule::secret => {
-                    let name = build_id(inner_rules.next().unwrap());
-                    let next_rule = inner_rules.next().unwrap();
-                    match next_rule.as_rule() {
-                        Rule::param_defn_list => {
-                            // ignore the param_defn_list for now
-                            // let param_defns = parse_param_defns(next_rule);
-                            let combinator = build_combinator(inner_rules.next().unwrap());
-                            Definition::SecCombinator {
-                                name,
-                                combinator,
-                                span,
-                            }
-                        }
-                        Rule::combinator => {
-                            let combinator = build_combinator(next_rule);
-                            Definition::SecCombinator {
-                                name,
-                                combinator,
-                                span,
-                            }
-                        }
-                        _ => unreachable!(),
+                Rule::param_defn_list => {
+                    let param_defns = build_param_defns(next_rule);
+                    let combinator = build_combinator(inner_rules.next().unwrap());
+                    Definition::Combinator {
+                        name,
+                        param_defns,
+                        combinator,
+                        span,
                     }
                 }
-                _ =>
-                // must be var_id
-                {
-                    let name = build_id(next_rule);
-                    let next_rule = inner_rules.next().unwrap();
-                    match next_rule.as_rule() {
-                        Rule::param_defn_list => {
-                            let param_defns = build_param_defns(next_rule);
-                            let combinator = build_combinator(inner_rules.next().unwrap());
-                            Definition::Combinator {
-                                name,
-                                param_defns,
-                                combinator,
-                                span,
-                            }
-                        }
-                        Rule::combinator => {
-                            let combinator = build_combinator(next_rule);
-                            Definition::Combinator {
-                                name,
-                                param_defns: vec![],
-                                combinator,
-                                span,
-                            }
-                        }
-                        _ => unreachable!(),
+                Rule::combinator => {
+                    let combinator = build_combinator(next_rule);
+                    Definition::Combinator {
+                        name,
+                        param_defns: vec![],
+                        combinator,
+                        span,
                     }
                 }
+                _ => unreachable!(),
             }
         }
         Rule::const_combinator_defn => {
@@ -1246,24 +1245,17 @@ fn build_param_defns(pair: pest::iterators::Pair<Rule>) -> Vec<ParamDefn> {
         match pair.as_rule() {
             Rule::param_defn => {
                 let mut inner_rules = pair.into_inner();
-                let next_rule = inner_rules.next().unwrap();
-                let mut name = build_id(next_rule.clone());
-                match next_rule.as_rule() {
-                    Rule::stream_id => {
-                        name.name = name.name.strip_prefix('$').unwrap().to_string();
-                        param_defns.push(ParamDefn::Stream { name });
-                    }
-                    Rule::depend_id => {
-                        name.name = name.name.strip_prefix('@').unwrap().to_string();
-                        let combinator = build_combinator_inner(inner_rules.next().unwrap());
-                        param_defns.push(ParamDefn::Dependent {
-                            name,
-                            combinator,
-                            span,
-                        });
-                    }
-                    _ => unreachable!(),
+                let mut name = build_id(inner_rules.next().unwrap());
+                match name.name.strip_prefix('@') {
+                    Some(stripped) => name.name = stripped.to_string(),
+                    None => unreachable!(),
                 }
+                let combinator = build_combinator_inner(inner_rules.next().unwrap());
+                param_defns.push(ParamDefn::Dependent {
+                    name,
+                    combinator,
+                    span,
+                });
             }
             _ => unreachable!(),
         }
@@ -1284,14 +1276,12 @@ fn build_combinator(pair: pest::iterators::Pair<Rule>) -> Combinator {
         }
         None => (None, inner_span),
     };
-    // Create a span that covers the entire combinator
     let span = Span::new(
         inner_span.get_input(),
         inner_span.start(),
         and_then_span.end(),
     )
     .expect("Failed to create span for combinator: {:inner_span:?}, {and_then_span:?}");
-    // let and_then = inner_rules.next().map(|r| Box::new(build_combinator(r)));
     Combinator {
         inner,
         and_then,
@@ -1356,13 +1346,15 @@ fn build_combinator_inner(pair: pest::iterators::Pair<Rule>) -> CombinatorInner
                     CombinatorInner::Enum(EnumCombinator::Exhaustive { enums, span })
                 }
                 Rule::non_exhaustive_enum => {
-                    let enums = rule.into_inner().map(build_enum).collect();
+                    let enums = rule
+                        .into_inner()
+                        .filter(|pair| pair.as_rule() == Rule::enum_field)
+                        .map(build_enum)
+                        .collect();
                     CombinatorInner::Enum(EnumCombinator::NonExhaustive { enums, span })
                 }
                 _ => unreachable!(),
             }
-            // let enums = rule.into_inner().map(parse_enum).collect();
-            // CombinatorInner::Enum(EnumCombinator { enums })
         }
         Rule::choice_combinator => {
             let mut inner_rules = rule.into_inner();
@@ -1388,32 +1380,12 @@ fn build_combinator_inner(pair: pest::iterators::Pair<Rule>) -> CombinatorInner
                 _ => unreachable!(),
             }
         }
-        Rule::sepby_combinator => {
-            let mut inner_rules = rule.into_inner();
-            let combinator = build_vec_combinator(inner_rules.next().unwrap());
-            let sep = build_const_combinator(inner_rules.next().unwrap());
-            CombinatorInner::SepBy(SepByCombinator { combinator, sep })
-        }
         Rule::vec_combinator => CombinatorInner::Vec(build_vec_combinator(rule)),
         Rule::array_combinator => {
             let mut inner_rules = rule.into_inner();
             let comb = build_combinator(inner_rules.next().unwrap());
-            let next_rule = inner_rules.next().unwrap();
-            let len = match next_rule.as_rule() {
-                Rule::const_int => {
-                    let len = build_const_int(next_rule);
-                    let len: usize = len
-                        .try_into()
-                        .unwrap_or_else(|_| panic!("Array length {} does not fit into usize", len));
-                    LengthSpecifier::Const(len)
-                }
-                Rule::depend_id => {
-                    let mut id = build_id(next_rule);
-                    id.name = id.name.strip_prefix('@').unwrap().to_string();
-                    LengthSpecifier::Dependent(id)
-                }
-                _ => unreachable!(),
-            };
+            let len_rule = inner_rules.next().unwrap();
+            let len = build_length_expr(len_rule);
             match comb.inner {
                 // [u8; ...] would generate bytes combinator
                 CombinatorInner::ConstraintInt(ConstraintIntCombinator {
@@ -1437,12 +1409,6 @@ fn build_combinator_inner(pair: pest::iterators::Pair<Rule>) -> CombinatorInner
             CombinatorInner::Option(OptionCombinator(Box::new(combinator)))
         }
         Rule::tail_combinator => CombinatorInner::Tail(TailCombinator { span }),
-        Rule::apply_combinator => {
-            let mut inner_rules = rule.into_inner();
-            let stream = build_id(inner_rules.next().unwrap());
-            let combinator = Box::new(build_combinator(inner_rules.next().unwrap()));
-            CombinatorInner::Apply(ApplyCombinator { stream, combinator })
-        }
         Rule::combinator_invocation => {
             CombinatorInner::Invocation(build_combinator_invocation(rule))
         }
@@ -1533,12 +1499,106 @@ fn build_const_int(pair: pest::iterators::Pair<Rule>) -> i128 {
     }
 }
 
+fn build_length_expr(pair: pest::iterators::Pair<Rule>) -> LengthExpr {
+    let span = pair.as_span();
+    match pair.as_rule() {
+        Rule::length_expr => {
+            let mut inner_rules = pair.into_inner();
+            let first_term = build_length_expr(inner_rules.next().unwrap());
+
+            let mut result = first_term;
+            while let Some(op_rule) = inner_rules.next() {
+                let op = match op_rule.as_rule() {
+                    Rule::add_op => ArithOp::Add,
+                    Rule::sub_op => ArithOp::Sub,
+                    _ => unreachable!("Expected add_op or sub_op"),
+                };
+                let right_term = build_length_expr(inner_rules.next().unwrap());
+                let new_span = Span::new(
+                    result.as_span().get_input(),
+                    result.as_span().start(),
+                    right_term.as_span().end(),
+                )
+                .unwrap();
+                result = LengthExpr::BinOp {
+                    op,
+                    left: Box::new(result),
+                    right: Box::new(right_term),
+                    span: new_span,
+                };
+            }
+            result
+        }
+        Rule::length_term => {
+            let mut inner_rules = pair.into_inner();
+            let first_atom = build_length_expr(inner_rules.next().unwrap());
+
+            let mut result = first_atom;
+            while let Some(op_rule) = inner_rules.next() {
+                let op = match op_rule.as_rule() {
+                    Rule::mul_op => ArithOp::Mul,
+                    Rule::div_op => ArithOp::Div,
+                    _ => unreachable!("Expected mul_op or div_op"),
+                };
+                let right_atom = build_length_expr(inner_rules.next().unwrap());
+                let new_span = Span::new(
+                    result.as_span().get_input(),
+                    result.as_span().start(),
+                    right_atom.as_span().end(),
+                )
+                .unwrap();
+                result = LengthExpr::BinOp {
+                    op,
+                    left: Box::new(result),
+                    right: Box::new(right_atom),
+                    span: new_span,
+                };
+            }
+            result
+        }
+        Rule::length_atom => {
+            let inner_rule = pair.into_inner().next().unwrap();
+            build_length_expr(inner_rule)
+        }
+        Rule::size_expr => {
+            let mut inner_rules = pair.into_inner();
+            let format_name = build_id(inner_rules.next().unwrap());
+            LengthExpr::SizeOf { format_name, span }
+        }
+        Rule::const_int => {
+            let value = build_const_int(pair);
+            let value: usize = value
+                .try_into()
+                .unwrap_or_else(|_| panic!("Array length {} does not fit into usize", value));
+            LengthExpr::Const { value, span }
+        }
+        Rule::depend_id => {
+            let dep_id = build_dependent_id(pair);
+            LengthExpr::Dependent(dep_id)
+        }
+        _ => unreachable!("Unexpected rule in length_expr: {:?}", pair.as_rule()),
+    }
+}
+
+fn build_dependent_id(pair: pest::iterators::Pair<Rule>) -> DependentId {
+    let span = pair.as_span();
+    let full_str = pair.as_str();
+
+    // Parse @root.field1.field2 format
+    let without_at = full_str.strip_prefix('@').unwrap();
+    let parts: Vec<&str> = without_at.split('.').collect();
+
+    let root = parts[0].to_string();
+    let path = parts[1..].iter().map(|s| s.to_string()).collect();
+
+    DependentId { root, path, span }
+}
+
 fn build_field(pair: pest::iterators::Pair<Rule>) -> StructField {
     let mut inner_rules = pair.into_inner();
     let rule = inner_rules.next().unwrap();
     let span = rule.as_span();
     match rule.as_rule() {
-        Rule::stream_transform => build_stream_transform(rule),
         Rule::constant => {
             let next_rule = inner_rules.next().unwrap();
             let label = build_id(next_rule);
@@ -1578,49 +1638,16 @@ fn build_field(pair: pest::iterators::Pair<Rule>) -> StructField {
     }
 }
 
-fn build_stream_transform(pair: pest::iterators::Pair<Rule>) -> StructField {
-    let mut inner_rules = pair.into_inner();
-    let rule = inner_rules.next().unwrap();
-    let span = rule.as_span();
-    match rule.as_rule() {
-        Rule::stream_ids => {
-            let streams = rule.into_inner().map(|r| r.as_str().to_string()).collect();
-            let func = build_id(inner_rules.next().unwrap());
-            let args = build_params(inner_rules.next().unwrap());
-            StructField::Stream(StreamTransform {
-                streams,
-                func,
-                args,
-                span,
-            })
-        }
-        Rule::var_id => {
-            let func = build_id(rule);
-            let args = build_params(inner_rules.next().unwrap());
-            StructField::Stream(StreamTransform {
-                streams: vec![],
-                func,
-                args,
-                span,
-            })
-        }
-        _ => unreachable!(),
-    }
-}
-
-fn build_params(pair: pest::iterators::Pair<'_, Rule>) -> Vec<Param> {
+fn build_params(pair: pest::iterators::Pair<'_, Rule>) -> Vec<Param<'_>> {
     pair.into_inner().map(build_param).collect()
 }
 
 fn build_param(pair: pest::iterators::Pair<Rule>) -> Param {
     let mut inner_rules = pair.into_inner();
     let rule = inner_rules.next().unwrap();
-    let mut name = build_id(rule.clone());
-    match rule.as_rule() {
-        Rule::stream_id => {
-            name.name = name.name.strip_prefix('$').unwrap().to_string();
-            Param::Stream(name)
-        }
+    let rule_kind = rule.as_rule();
+    let mut name = build_id(rule);
+    match rule_kind {
         Rule::depend_id => {
             name.name = name.name.strip_prefix('@').unwrap().to_string();
             Param::Dependent(name)
@@ -1746,25 +1773,28 @@ fn build_choices<'i>(inner_rules: pest::iterators::Pairs<'i, Rule>) -> Choices<'
     }
 }
 
-fn build_vec_combinator(pair: pest::iterators::Pair<'_, Rule>) -> VecCombinator {
+fn build_vec_combinator(pair: pest::iterators::Pair<'_, Rule>) -> VecCombinator<'_> {
     let mut inner_rules = pair.into_inner();
-    let rule = inner_rules.next().unwrap();
+    let _ = inner_rules.next().unwrap();
     let combinator = build_combinator(inner_rules.next().unwrap());
-    match rule.as_rule() {
-        Rule::vec1 => VecCombinator::Vec1(Box::new(combinator)),
-        Rule::vec => VecCombinator::Vec(Box::new(combinator)),
-        _ => unreachable!(),
-    }
+    VecCombinator::Vec(Box::new(combinator))
 }
 
-fn build_const_combinator(rule: pest::iterators::Pair<'_, Rule>) -> ConstCombinator {
-    let mut inner_rules = rule.into_inner();
-    let rule = inner_rules.next().unwrap();
+fn build_const_combinator(rule: pest::iterators::Pair<'_, Rule>) -> ConstCombinator<'_> {
     let span = rule.as_span();
     match rule.as_rule() {
-        Rule::vec => ConstCombinator::Vec(Box::new(build_const_combinator(
-            inner_rules.next().unwrap(),
-        ))),
+        Rule::const_combinator | Rule::inline_const_combinator => {
+            build_const_combinator(rule.into_inner().next().unwrap())
+        }
+        Rule::const_bytes_combinator => {
+            let mut inner_rules = rule.into_inner();
+            let len = build_const_int(inner_rules.next().unwrap());
+            let len: usize = len
+                .try_into()
+                .unwrap_or_else(|_| panic!("length {} does not fit into usize", len));
+            let values = build_const_array(inner_rules.next().unwrap());
+            ConstCombinator::ConstBytes(ConstBytesCombinator { len, values, span })
+        }
         Rule::const_enum_combinator => {
             let mut inner_rules = rule.into_inner();
             let combinator = build_combinator_invocation(inner_rules.next().unwrap());
@@ -1775,27 +1805,6 @@ fn build_const_combinator(rule: pest::iterators::Pair<'_, Rule>) -> ConstCombina
                 span,
             })
         }
-        Rule::const_array_combinator => {
-            let mut inner_rules = rule.into_inner();
-            let combinator = build_int_combinator(inner_rules.next().unwrap());
-            let len = build_const_int(inner_rules.next().unwrap());
-            let len: usize = len
-                .try_into()
-                .unwrap_or_else(|_| panic!("length {} does not fit into usize", len));
-            let values = build_const_array(inner_rules.next().unwrap());
-            // check for special case of `[u8; ...] = [...]` ==> ConstBytes
-            match combinator {
-                IntCombinator::Unsigned(8) => {
-                    ConstCombinator::ConstBytes(ConstBytesCombinator { len, values, span })
-                }
-                _ => ConstCombinator::ConstArray(ConstArrayCombinator {
-                    combinator,
-                    len,
-                    values,
-                    span,
-                }),
-            }
-        }
         Rule::const_int_combinator => {
             let mut inner_rules = rule.into_inner();
             let combinator = build_int_combinator(inner_rules.next().unwrap());
@@ -1806,12 +1815,6 @@ fn build_const_combinator(rule: pest::iterators::Pair<'_, Rule>) -> ConstCombina
                 span,
             })
         }
-        Rule::const_struct_combinator => ConstCombinator::ConstStruct(ConstStructCombinator(
-            rule.into_inner().map(build_const_combinator).collect(),
-        )),
-        Rule::const_choice_combinator => ConstCombinator::ConstChoice(ConstChoiceCombinator(
-            rule.into_inner().map(build_const_choice).collect(),
-        )),
         Rule::const_id => ConstCombinator::ConstCombinatorInvocation {
             name: build_id(rule),
             span: span.clone(),
@@ -1820,14 +1823,7 @@ fn build_const_combinator(rule: pest::iterators::Pair<'_, Rule>) -> ConstCombina
     }
 }
 
-fn build_const_choice(pair: pest::iterators::Pair<'_, Rule>) -> ConstChoice {
-    let mut inner_rules = pair.into_inner();
-    let tag = inner_rules.next().unwrap().as_str().to_string();
-    let combinator = build_const_combinator(inner_rules.next().unwrap());
-    ConstChoice { tag, combinator }
-}
-
-fn build_enum_constraint(pair: pest::iterators::Pair<'_, Rule>) -> EnumConstraint {
+fn build_enum_constraint(pair: pest::iterators::Pair<'_, Rule>) -> EnumConstraint<'_> {
     let span = pair.as_span();
     match pair.as_rule() {
         Rule::enum_constraint_elem => {
@@ -1863,7 +1859,7 @@ fn build_enum_constraint(pair: pest::iterators::Pair<'_, Rule>) -> EnumConstrain
     }
 }
 
-fn build_const_array(pair: pest::iterators::Pair<'_, Rule>) -> ConstArray {
+fn build_const_array(pair: pest::iterators::Pair<'_, Rule>) -> ConstArray<'_> {
     let mut inner_rules = pair.into_inner();
     let rule = inner_rules.next().unwrap();
     let span = rule.as_span();
diff --git a/vest-dsl/src/codegen.rs b/vest-dsl/src/codegen.rs
index f511574e..728d7d13 100644
--- a/vest-dsl/src/codegen.rs
+++ b/vest-dsl/src/codegen.rs
@@ -2,13 +2,12 @@
 #![allow(dead_code)]
 #![allow(unused_variables)]
 
+use crate::utils::VestHasherBuilder;
+use crate::vestir::*;
 use std::collections::hash_map::DefaultHasher;
 use std::collections::HashSet;
 use std::hash::{Hash, Hasher};
 use std::{collections::HashMap, fmt::Display};
-use crate::utils::VestHasherBuilder;
-use crate::vestir::*;
-
 
 /// convert snake case to upper camel case
 /// e.g. `foo_bar` -> `FooBar`
@@ -142,6 +141,205 @@ fn gen_nested_eithers(num_of_variants: usize, var_name: &str) -> Vec<String> {
     }
 }
 
+fn eval_const_length_expr(
+    len: &LengthExpr,
+    static_sizes: &HashMap<String, usize>,
+) -> Option<usize> {
+    match len {
+        LengthExpr::Const(n) => Some(*n),
+        LengthExpr::Dependent(..) => None,
+        LengthExpr::SizeOf(format_name) => static_sizes.get(format_name).copied(),
+        LengthExpr::BinOp { op, left, right } => {
+            let left = eval_const_length_expr(left, static_sizes)?;
+            let right = eval_const_length_expr(right, static_sizes)?;
+            match op {
+                ArithOp::Add => left.checked_add(right),
+                ArithOp::Sub => left.checked_sub(right),
+                ArithOp::Mul => left.checked_mul(right),
+                ArithOp::Div => left.checked_div(right),
+            }
+        }
+    }
+}
+
+fn gen_constraint_elem_expr(constraint: &ConstraintElem, value: &str) -> String {
+    match constraint {
+        ConstraintElem::Single(n) => format!("({value} == {n})"),
+        ConstraintElem::Range { start, end } => {
+            if let Some(start) = start {
+                if let Some(end) = end {
+                    format!("({value} >= {start} && {value} <= {end})")
+                } else {
+                    format!("({value} >= {start})")
+                }
+            } else if let Some(end) = end {
+                format!("({value} <= {end})")
+            } else {
+                panic!("a range constraint must have at least one bound")
+            }
+        }
+    }
+}
+
+fn gen_int_constraint_expr(constraint: &IntConstraint, value: &str) -> String {
+    match constraint {
+        IntConstraint::Single(constraint_elem) => gen_constraint_elem_expr(constraint_elem, value),
+        IntConstraint::Set(cs) => cs
+            .iter()
+            .map(|constraint_elem| gen_constraint_elem_expr(constraint_elem, value))
+            .collect::<Vec<_>>()
+            .join(" || "),
+        IntConstraint::Neg(c) => format!("!({})", gen_int_constraint_expr(c, value)),
+    }
+}
+
+fn int_constraint_cast_suffix(combinator: &IntCombinator, mode: Mode) -> &'static str {
+    match (combinator, mode) {
+        (IntCombinator::Unsigned(24), Mode::Spec) => ".spec_as_u32()",
+        (IntCombinator::Unsigned(24), Mode::Exec(_)) => ".as_u32()",
+        (IntCombinator::BtcVarint, Mode::Spec) => ".spec_as_usize()",
+        (IntCombinator::BtcVarint, Mode::Exec(_)) => ".as_usize()",
+        _ => "",
+    }
+}
+
+fn gen_param_requirements_with<FValue, FView>(
+    param_defns: &[ParamDefn],
+    ctx: &CodegenCtx,
+    mode: Mode,
+    value_expr: FValue,
+    view_expr: FView,
+) -> Vec<String>
+where
+    FValue: Fn(&str) -> String,
+    FView: Fn(&str) -> String,
+{
+    param_defns
+        .iter()
+        .filter_map(|param_defn| match param_defn {
+            ParamDefn::Dependent { name, combinator } => match combinator {
+                CombinatorInner::ConstraintInt(ConstraintIntCombinator {
+                    combinator,
+                    constraint: Some(constraint),
+                }) => {
+                    let value = format!(
+                        "({}){}",
+                        value_expr(name),
+                        int_constraint_cast_suffix(combinator, mode)
+                    );
+                    Some(gen_int_constraint_expr(constraint, &value))
+                }
+                CombinatorInner::Invocation(invocation) => {
+                    match ctx.global_ctx.resolve_alias(combinator) {
+                        CombinatorInner::Bytes(_) | CombinatorInner::Tail(_) => None,
+                        _ => {
+                            let args = invocation
+                                .args
+                                .iter()
+                                .map(|arg| match arg {
+                                    Param::Dependent(arg) => view_expr(arg),
+                                })
+                                .collect::<Vec<_>>()
+                                .join(", ");
+                            Some(format!(
+                                "spec_{}({}).wf({})",
+                                invocation.func,
+                                args,
+                                view_expr(name)
+                            ))
+                        }
+                    }
+                }
+                _ => None,
+            },
+        })
+        .collect()
+}
+
+fn gen_exec_param_requirements(param_defns: &[ParamDefn], ctx: &CodegenCtx) -> Vec<String> {
+    gen_param_requirements_with(
+        param_defns,
+        ctx,
+        Mode::Exec(LifetimeAnn::None),
+        |name| name.to_string(),
+        |name| format!("{name}@"),
+    )
+}
+
+fn format_requires_block(lines: &[String], indent: &str) -> String {
+    if lines.is_empty() {
+        String::new()
+    } else {
+        format!(
+            "{indent}requires\n{}\n",
+            lines
+                .iter()
+                .map(|line| format!("{indent}    {line},"))
+                .collect::<Vec<_>>()
+                .join("\n")
+        )
+    }
+}
+
+fn format_conjunction_block(lines: &[String], indent: &str) -> String {
+    if lines.is_empty() {
+        "true".to_string()
+    } else {
+        format!(
+            "\n{}\n{indent}",
+            lines
+                .iter()
+                .map(|line| format!("{indent}&&& {line}"))
+                .collect::<Vec<_>>()
+                .join("\n")
+        )
+    }
+}
+
+fn comma_prefix(value: &str) -> String {
+    if value.is_empty() {
+        String::new()
+    } else {
+        format!("{value}, ")
+    }
+}
+
+fn length_expr_convert_fn(mode: Mode) -> &'static str {
+    match mode {
+        Mode::Spec => "usize::spec_from",
+        Mode::Exec(_) => "usize::ex_from",
+    }
+}
+
+/// Generate Rust code for a LengthExpr
+fn gen_length_expr(len: &LengthExpr, convert_fn: &str, ctx: &CodegenCtx) -> String {
+    if let Some(value) = eval_const_length_expr(len, &ctx.global_ctx.static_sizes) {
+        return value.to_string();
+    }
+
+    match len {
+        LengthExpr::Const(n) => n.to_string(),
+        LengthExpr::Dependent(name) => format!("{convert_fn}({name})"),
+        LengthExpr::SizeOf(format_name) => ctx
+            .global_ctx
+            .static_sizes
+            .get(format_name)
+            .copied()
+            .unwrap_or_else(|| panic!("static size not found for `{}`", format_name))
+            .to_string(),
+        LengthExpr::BinOp { op, left, right } => {
+            let left_code = gen_length_expr(left, convert_fn, ctx);
+            let right_code = gen_length_expr(right, convert_fn, ctx);
+            match op {
+                ArithOp::Add => format!("({left_code} + {right_code})"),
+                ArithOp::Sub => format!("({left_code} - {right_code})"),
+                ArithOp::Mul => format!("({left_code} * {right_code})"),
+                ArithOp::Div => format!("({left_code} / {right_code})"),
+            }
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub enum Mode {
     Spec,
@@ -217,36 +415,49 @@ fn msg_need_lifetime(combinator: &Combinator, ctx: &GlobalCtx) -> bool {
                 .iter()
                 .any(|(_, combinator)| msg_need_lifetime(combinator, ctx)),
         },
-        SepBy(SepByCombinator { combinator, sep }) => {
-            let combinator = Combinator {
-                inner: Vec(combinator.clone()),
-                and_then: None,
-            };
-            msg_need_lifetime(&combinator, ctx) || const_msg_need_lifetime(sep, ctx)
-        }
-        Vec(VecCombinator::Vec(combinator) | VecCombinator::Vec1(combinator)) => {
-            msg_need_lifetime(combinator, ctx)
-        }
+        Vec(VecCombinator::Vec(combinator)) => msg_need_lifetime(combinator, ctx),
         Array(ArrayCombinator { combinator, .. }) => msg_need_lifetime(combinator, ctx),
         Option(OptionCombinator(combinator)) => msg_need_lifetime(combinator, ctx),
-        ConstraintInt(_) | ConstraintEnum(_) | Enum(_) | Apply(_) => false,
+        ConstraintInt(_) | ConstraintEnum(_) | Enum(_) => false,
         Invocation(_) => unreachable!("invocation should be resolved by now"),
     }
 }
 
+fn dependent_field_needs_exec_copy(combinator: &Combinator, ctx: &GlobalCtx) -> bool {
+    matches!(
+        ctx.resolve(combinator),
+        CombinatorInner::ConstraintInt(_)
+            | CombinatorInner::ConstraintEnum(_)
+            | CombinatorInner::Enum(_)
+    )
+}
+
+fn dependent_field_needs_exec_deref(combinator: &Combinator, ctx: &GlobalCtx) -> bool {
+    matches!(
+        ctx.resolve(combinator),
+        CombinatorInner::Bytes(_) | CombinatorInner::Tail(_)
+    )
+}
+
+fn dependent_field_needs_exec_shadow(combinator: &Combinator, ctx: &GlobalCtx) -> bool {
+    dependent_field_needs_exec_copy(combinator, ctx)
+        || dependent_field_needs_exec_deref(combinator, ctx)
+}
+
+fn dependent_param_defs(ctx: &CodegenCtx) -> Vec<(&str, &CombinatorInner)> {
+    ctx.param_defns
+        .iter()
+        .filter_map(|param_defn| match param_defn {
+            ParamDefn::Dependent { name, combinator } => Some((name.as_str(), combinator)),
+        })
+        .collect()
+}
+
 /// Helper function to determine if a const format needs lifetime annotations
 fn const_msg_need_lifetime(const_combinator: &ConstCombinator, ctx: &GlobalCtx) -> bool {
     let const_combinator = ctx.resolve_const(const_combinator);
     match const_combinator {
-        ConstCombinator::ConstArray(_) => true, // TODO: can be more fine-grained
         ConstCombinator::ConstBytes(_) => true, // TODO: can be more fine-grained
-        ConstCombinator::ConstStruct(ConstStructCombinator(fields)) => fields
-            .iter()
-            .any(|field| const_msg_need_lifetime(field, ctx)),
-        ConstCombinator::ConstChoice(ConstChoiceCombinator(choices)) => choices
-            .iter()
-            .any(|ConstChoice { combinator, .. }| const_msg_need_lifetime(combinator, ctx)),
-        ConstCombinator::Vec(combinator) => const_msg_need_lifetime(combinator, ctx),
         ConstCombinator::ConstEnum(_)
         | ConstCombinator::ConstInt(_)
         | ConstCombinator::ConstCombinatorInvocation(_) => false,
@@ -283,7 +494,8 @@ impl CodegenCtx {
         // first we need to determine which formats' types need lifetime annotations
 
         // init the format lifetimes with None
-        let mut msg_lifetimes: HashMap<String, LifetimeAnn, VestHasherBuilder> = HashMap::with_hasher(VestHasherBuilder);
+        let mut msg_lifetimes: HashMap<String, LifetimeAnn, VestHasherBuilder> =
+            HashMap::with_hasher(VestHasherBuilder);
         for defn in ast {
             match defn {
                 Definition::Combinator { name, .. } => {
@@ -458,7 +670,10 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for {name}Combinator {{
             }
         };
         if let Some(and_then) = &self.and_then {
-            let (comb_type, additional_code) = self.inner.gen_combinator_type(name, mode, ctx); // must be `bytes::Variable` or `bytes::Tail`
+            let (comb_type, additional_code) = match &self.inner {
+                CombinatorInner::Bytes(..) => ("bytes::Variable".to_string(), "".to_string()),
+                _ => self.inner.gen_combinator_type(name, mode, ctx),
+            };
             let (and_then_comb_type, and_then_additional_code) =
                 and_then.inner.gen_combinator_type(name, mode, ctx);
             if !ctx.top_level {
@@ -499,7 +714,20 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for {name}Combinator {{
 
     fn gen_combinator_expr(&self, name: &str, mode: Mode, ctx: &CodegenCtx) -> (String, String) {
         if let Some(and_then) = &self.and_then {
-            let (comb_expr, additional_code) = self.inner.gen_combinator_expr(name, mode, ctx);
+            let (comb_expr, additional_code) = match &self.inner {
+                CombinatorInner::Bytes(bytes) => {
+                    let len_expr = if let Some(len) =
+                        eval_const_length_expr(&bytes.len, &ctx.global_ctx.static_sizes)
+                    {
+                        len.to_string()
+                    } else {
+                        let convert = length_expr_convert_fn(mode);
+                        format!("({}) as usize", gen_length_expr(&bytes.len, convert, ctx))
+                    };
+                    (format!("bytes::Variable({})", len_expr), "".to_string())
+                }
+                _ => self.inner.gen_combinator_expr(name, mode, ctx),
+            };
             let (and_then_comb_expr, and_then_additional_code) =
                 and_then.inner.gen_combinator_expr(name, mode, ctx);
             let combinator_expr = format!("AndThen({}, {})", comb_expr, and_then_comb_expr);
@@ -523,9 +751,7 @@ impl Codegen for CombinatorInner {
             CombinatorInner::Choice(p) => p.gen_msg_type(name, mode, ctx),
             CombinatorInner::Array(p) => p.gen_msg_type(name, mode, ctx),
             CombinatorInner::Vec(p) => p.gen_msg_type(name, mode, ctx),
-            CombinatorInner::SepBy(p) => p.gen_msg_type(name, mode, ctx),
             CombinatorInner::Wrap(p) => p.gen_msg_type(name, mode, ctx),
-            CombinatorInner::Apply(p) => p.gen_msg_type(name, mode, ctx),
             CombinatorInner::Option(p) => p.gen_msg_type(name, mode, ctx),
         }
     }
@@ -548,9 +774,7 @@ impl Codegen for CombinatorInner {
             CombinatorInner::Choice(p) => p.gen_combinator_type(name, mode, ctx),
             CombinatorInner::Array(p) => p.gen_combinator_type(upper_caml_name, mode, ctx),
             CombinatorInner::Vec(p) => p.gen_combinator_type(upper_caml_name, mode, ctx),
-            CombinatorInner::SepBy(p) => p.gen_combinator_type(upper_caml_name, mode, ctx),
             CombinatorInner::Wrap(p) => p.gen_combinator_type(upper_caml_name, mode, ctx),
-            CombinatorInner::Apply(p) => p.gen_combinator_type(upper_caml_name, mode, ctx),
             CombinatorInner::Option(p) => p.gen_combinator_type(upper_caml_name, mode, ctx),
         }
     }
@@ -567,9 +791,7 @@ impl Codegen for CombinatorInner {
             CombinatorInner::Choice(p) => p.gen_combinator_expr(name, mode, ctx),
             CombinatorInner::Array(p) => p.gen_combinator_expr(name, mode, ctx),
             CombinatorInner::Vec(p) => p.gen_combinator_expr(name, mode, ctx),
-            CombinatorInner::SepBy(p) => p.gen_combinator_expr(name, mode, ctx),
             CombinatorInner::Wrap(p) => p.gen_combinator_expr(name, mode, ctx),
-            CombinatorInner::Apply(p) => p.gen_combinator_expr(name, mode, ctx),
             CombinatorInner::Option(p) => p.gen_combinator_expr(name, mode, ctx),
         }
     }
@@ -597,37 +819,6 @@ impl Codegen for ConstraintIntCombinator {
         mode: Mode,
         ctx: &mut CodegenCtx,
     ) -> (String, String) {
-        fn gen_constraints(c: &IntConstraint) -> String {
-            match c {
-                IntConstraint::Single(constraint_elem) => gen_constraint_elem(constraint_elem),
-                IntConstraint::Set(cs) => cs
-                    .iter()
-                    .map(gen_constraint_elem)
-                    .collect::<Vec<_>>()
-                    .join(" || "),
-                IntConstraint::Neg(c) => {
-                    format!("!({})", gen_constraints(c))
-                }
-            }
-        }
-        fn gen_constraint_elem(c: &ConstraintElem) -> String {
-            match c {
-                ConstraintElem::Single(n) => format!("(i == {})", n),
-                ConstraintElem::Range { start, end } => {
-                    if let Some(start) = start {
-                        if let Some(end) = end {
-                            format!("(i >= {} && i <= {})", start, end)
-                        } else {
-                            format!("(i >= {})", start)
-                        }
-                    } else if let Some(end) = end {
-                        format!("(i <= {})", end)
-                    } else {
-                        panic!("a range constraint must have at least one bound")
-                    }
-                }
-            }
-        }
         let endianness = match ctx.endianess {
             Endianess::Little => "Le",
             Endianess::Big => "Be",
@@ -655,12 +846,9 @@ impl Codegen for ConstraintIntCombinator {
             );
             // impl SpecPred
             let input_type = format!("{}", self.combinator);
-            let (spec_cast, cast) = match input_type.as_str() {
-                "u24" => (".spec_as_u32()", ".as_u32()"),
-                "VarInt" => (".spec_as_usize()", ".as_usize()"),
-                _ => ("", ""),
-            };
-            let constraints = gen_constraints(constraint);
+            let spec_cast = int_constraint_cast_suffix(&self.combinator, Mode::Spec);
+            let cast = int_constraint_cast_suffix(&self.combinator, Mode::Exec(LifetimeAnn::None));
+            let constraints = gen_int_constraint_expr(constraint, "i");
             let impl_spec_pred = format!(
                 r#"impl SpecPred<{input_type}> for Predicate{hash} {{
     open spec fn spec_apply(&self, i: &{input_type}) -> bool {{
@@ -749,24 +937,22 @@ impl Codegen for BytesCombinator {
         mode: Mode,
         ctx: &mut CodegenCtx,
     ) -> (String, String) {
-        match &self.len {
-            LengthSpecifier::Const(len) => (format!("bytes::Fixed<{}>", len), "".to_string()),
-            LengthSpecifier::Dependent(..) => ("bytes::Variable".to_string(), "".to_string()),
+        match eval_const_length_expr(&self.len, &ctx.global_ctx.static_sizes) {
+            Some(len) => (format!("bytes::Fixed<{}>", len), "".to_string()),
+            None => ("bytes::Variable".to_string(), "".to_string()),
         }
     }
 
     fn gen_combinator_expr(&self, name: &str, mode: Mode, ctx: &CodegenCtx) -> (String, String) {
-        let into = match mode {
-            Mode::Spec => ".spec_into()",
-            _ => ".ex_into()",
-        };
-        match &self.len {
-            LengthSpecifier::Const(len) => {
+        let convert = length_expr_convert_fn(mode);
+        match eval_const_length_expr(&self.len, &ctx.global_ctx.static_sizes) {
+            Some(len) => {
                 let combinator_expr = format!("bytes::Fixed::<{}>", len);
                 (combinator_expr, "".to_string())
             }
-            LengthSpecifier::Dependent(depend_id) => {
-                let combinator_expr = format!("bytes::Variable({}{})", depend_id, into);
+            None => {
+                let len_expr = gen_length_expr(&self.len, convert, ctx);
+                let combinator_expr = format!("bytes::Variable(({}) as usize)", len_expr);
                 (combinator_expr, "".to_string())
             }
         }
@@ -881,12 +1067,8 @@ impl Codegen for CombinatorInvocation {
         let args = &self
             .args
             .iter()
-            .map(|arg| {
-                if let Param::Dependent(arg) = arg {
-                    arg.to_string()
-                } else {
-                    unimplemented!()
-                }
+            .map(|arg| match arg {
+                Param::Dependent(arg) => arg.to_string(),
             })
             .collect::<Vec<_>>()
             .join(", ");
@@ -1228,6 +1410,28 @@ impl{lifetime_ann} {from_trait}<{msg_type_name}Inner{lifetime_ann}> for {msg_typ
             .map(|field| comb_type_and_code_from_field(field, name, mode, ctx).1)
             .collect::<Vec<_>>()
             .join("");
+        let continuation_lifetime_ann = match mode {
+            Mode::Exec(lifetime_ann) => {
+                let capture_uses_lifetime =
+                    dependent_param_defs(ctx)
+                        .into_iter()
+                        .any(|(_, combinator)| {
+                            combinator
+                                .gen_msg_type(
+                                    "",
+                                    Mode::Exec(lifetime_ann),
+                                    &ctx.disable_top_level(),
+                                )
+                                .contains("'a")
+                        });
+                if capture_uses_lifetime {
+                    "<'a>"
+                } else {
+                    ""
+                }
+            }
+            Mode::Spec => "",
+        };
         let mut combinator_types = |fields: &[StructField]| {
             fields
                 .iter()
@@ -1299,7 +1503,7 @@ impl_wrapper_combinator!({name}Combinator{i}, {name}CombinatorAlias{i});
                     &self.0,
                     &mut into_comb_type_pairs,
                     &|_| "Pair<".into(),
-                    &|depth| format!(", {name}Cont{depth}>"),
+                    &|depth| format!(", {name}Cont{depth}{continuation_lifetime_ann}>"),
                     0,
                 ),
             };
@@ -1393,41 +1597,22 @@ impl_wrapper_combinator!({name}Combinator{i}, {name}CombinatorAlias{i});
                         Bracket::Parentheses,
                     )
                 };
-                let mut into_binding_pairs_only_dependent = |fields: &[StructField]| {
-                    fmt_in_pairs(
-                        &fields
-                            .iter()
-                            .filter_map(|field| match field {
-                                StructField::Dependent { label, .. } => Some(label.to_string()),
-                                _ => None,
-                            })
-                            .collect::<Vec<_>>(),
-                        "",
-                        Bracket::Parentheses,
-                    )
-                };
-                let mut into_binding_pairs_only_dependent_deref = |fields: &[StructField]| {
-                    fmt_in_pairs(
-                        &fields
-                            .iter()
-                            .filter_map(|field| match field {
-                                StructField::Dependent { label, .. } => Some(format!("*{}", label)),
-                                _ => None,
-                            })
-                            .collect::<Vec<_>>(),
-                        "",
-                        Bracket::Parentheses,
-                    )
-                };
+                let exec_shadow_bindings = fst
+                    .iter()
+                    .filter_map(|field| match field {
+                        StructField::Dependent { label, combinator }
+                            if dependent_field_needs_exec_shadow(combinator, &ctx.global_ctx) =>
+                        {
+                            Some(format!("                let {label} = *{label};\n"))
+                        }
+                        _ => None,
+                    })
+                    .collect::<String>();
                 let fst_msg_type_pairs =
                     build_nested_pairs(fst, &mut into_msg_type_pairs, "(", ")");
                 let fst_msg_ref_type_pairs =
                     build_nested_pairs(fst, &mut into_msg_ref_type_pairs, "(", ")");
                 let fst_binding_pairs = build_nested_pairs(fst, &mut into_binding_pairs, "(", ")");
-                let fst_binding_pairs_only_dependent =
-                    build_nested_pairs(fst, &mut into_binding_pairs_only_dependent, "(", ")");
-                let fst_binding_pairs_only_dependent_deref =
-                    build_nested_pairs(fst, &mut into_binding_pairs_only_dependent_deref, "(", ")");
                 let (snd_combinator_types, (snd_exprs, snd_code)): (Vec<_>, (Vec<_>, Vec<_>)) = snd
                     .iter()
                     .map(|field| match field {
@@ -1445,38 +1630,145 @@ impl_wrapper_combinator!({name}Combinator{i}, {name}CombinatorAlias{i});
                                 ),
                             )
                         }
-                        _ => todo!(),
+                        StructField::Const { combinator, label } => {
+                            let name = &lower_snake_to_upper_snake(&(name.to_owned() + label));
+                            (
+                                combinator
+                                    .gen_combinator_type(name, mode, &mut ctx.disable_top_level())
+                                    .0,
+                                combinator.gen_combinator_expr(
+                                    name,
+                                    mode,
+                                    &ctx.disable_top_level(),
+                                ),
+                            )
+                        }
                     })
                     .unzip();
                 let snd_combinator_types =
                     fmt_in_pairs(&snd_combinator_types, "", Bracket::Parentheses);
                 let snd_exprs = fmt_in_pairs(&snd_exprs, "", Bracket::Parentheses);
                 let snaked_name = upper_camel_to_snake(name);
+                let captured_params = dependent_param_defs(ctx);
+                let captured_spec_params = captured_params
+                    .iter()
+                    .map(|(name, combinator)| {
+                        format!(
+                            "{name}: {}",
+                            combinator.gen_msg_type("", Mode::Spec, &ctx.disable_top_level())
+                        )
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                let captured_args = captured_params
+                    .iter()
+                    .map(|(name, _)| (*name).to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                let captured_self_args_view = captured_params
+                    .iter()
+                    .map(|(name, _)| format!("self.{name}@"))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                let captured_exec_fields = captured_params
+                    .iter()
+                    .map(|(name, combinator)| {
+                        (
+                            (*name).to_string(),
+                            combinator.gen_msg_type(
+                                "",
+                                Mode::Exec(LifetimeAnn::Some),
+                                &ctx.disable_top_level(),
+                            ),
+                        )
+                    })
+                    .collect::<Vec<_>>();
+                let continuation_lifetime_ann =
+                    if captured_exec_fields.iter().any(|(_, ty)| ty.contains("'a")) {
+                        "<'a>"
+                    } else {
+                        ""
+                    };
+                let continuation_ty = format!("{name}Cont{depth}{continuation_lifetime_ann}");
+                let captured_spec_params_prefix = comma_prefix(&captured_spec_params);
+                let captured_args_prefix = comma_prefix(&captured_args);
+                let captured_self_args_view_prefix = comma_prefix(&captured_self_args_view);
+                let fst_spec_expr = match mode {
+                    Mode::Spec => fst_expr.clone(),
+                    Mode::Exec(_) => {
+                        gen_combinator_expr_helper(fst, name, Mode::Spec, ctx, depth + 1).0
+                    }
+                };
+                let continuation_expr = if captured_args.is_empty() {
+                    format!("{name}Cont{depth}")
+                } else {
+                    format!("{name}Cont{depth} {{ {captured_args} }}")
+                };
+                let continuation_struct_decl = if captured_exec_fields.is_empty() {
+                    format!("pub struct {name}Cont{depth};")
+                } else {
+                    let fields = captured_exec_fields
+                        .iter()
+                        .map(|(name, ty)| format!("    pub {name}: {ty},"))
+                        .collect::<Vec<_>>()
+                        .join("\n");
+                    format!(
+                        "pub struct {name}Cont{depth}{continuation_lifetime_ann} {{\n{fields}\n}}"
+                    )
+                };
+                let continuation_self_bindings = captured_params
+                    .iter()
+                    .map(|(name, _)| format!("                let {name} = self.{name};\n"))
+                    .collect::<String>();
+                let continuation_spec_bindings = captured_params
+                    .iter()
+                    .map(|(name, _)| format!("        let {name} = self.{name}@;\n"))
+                    .collect::<String>();
+                let continuation_requirements = {
+                    let mut requirements = gen_param_requirements_with(
+                        &ctx.param_defns,
+                        ctx,
+                        Mode::Spec,
+                        |name| format!("self.{name}@"),
+                        |name| format!("self.{name}@"),
+                    );
+                    requirements.push(format!("({fst_spec_expr}).wf(deps@)"));
+                    format!(
+                        "{}{}",
+                        continuation_spec_bindings,
+                        format_conjunction_block(&requirements, "        ")
+                    )
+                };
+                let continuation_view_impl = if continuation_lifetime_ann.is_empty() {
+                    format!("impl View for {continuation_ty} {{")
+                } else {
+                    format!("impl<'a> View for {continuation_ty} {{")
+                };
                 let expr = match mode {
                     Mode::Spec => {
                         format!(
-                            r#"Pair::spec_new({fst_expr}, |deps| spec_{snaked_name}_cont{depth}(deps))"#,
+                            r#"Pair::spec_new({fst_expr}, |deps| spec_{snaked_name}_cont{depth}({captured_args_prefix}deps))"#,
                         )
                     }
                     _ => {
-                        format!(r#"Pair::new({fst_expr}, {name}Cont{depth})"#,)
+                        format!(r#"Pair::new({fst_expr}, {continuation_expr})"#,)
                     }
                 };
                 let additional_code = match mode {
                     Mode::Spec => {
                         format!(
                             r#"
-pub open spec fn spec_{snaked_name}_cont{depth}(deps: {fst_msg_type_pairs}) -> {snd_combinator_types} {{
+pub open spec fn spec_{snaked_name}_cont{depth}({captured_spec_params_prefix}deps: {fst_msg_type_pairs}) -> {snd_combinator_types} {{
     let {fst_binding_pairs} = deps;
     {snd_exprs}
 }}
 
-impl View for {name}Cont{depth} {{
+{continuation_view_impl}
     type V = spec_fn({fst_msg_type_pairs}) -> {snd_combinator_types};
 
     open spec fn view(&self) -> Self::V {{
         |deps: {fst_msg_type_pairs}| {{
-            spec_{snaked_name}_cont{depth}(deps)
+            spec_{snaked_name}_cont{depth}({captured_self_args_view_prefix}deps)
         }}
     }}
 }}
@@ -1486,29 +1778,29 @@ impl View for {name}Cont{depth} {{
                     _ => {
                         format!(
                             r#"
-pub struct {name}Cont{depth};
+{continuation_struct_decl}
 type {name}Cont{depth}Type<'a, 'b> = &'b {fst_msg_type_pairs};
 type {name}Cont{depth}SType<'a, 'x> = {fst_msg_ref_type_pairs};
 type {name}Cont{depth}Input<'a, 'b, 'x> = POrSType<{name}Cont{depth}Type<'a, 'b>, {name}Cont{depth}SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<{name}Cont{depth}Input<'a, 'b, 'x>> for {name}Cont{depth} {{
+impl<'a, 'b, 'x> Continuation<{name}Cont{depth}Input<'a, 'b, 'x>> for {continuation_ty} {{
     type Output = {snd_combinator_types};
 
-    open spec fn requires(&self, deps: {name}Cont{depth}Input<'a, 'b, 'x>) -> bool {{ true }}
+    open spec fn requires(&self, deps: {name}Cont{depth}Input<'a, 'b, 'x>) -> bool {{{continuation_requirements}}}
 
     open spec fn ensures(&self, deps: {name}Cont{depth}Input<'a, 'b, 'x>, o: Self::Output) -> bool {{
-        o@ == spec_{snaked_name}_cont{depth}(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_{snaked_name}_cont{depth}({captured_self_args_view_prefix}deps@)
     }}
 
     fn apply(&self, deps: {name}Cont{depth}Input<'a, 'b, 'x>) -> Self::Output {{
         match deps {{
             POrSType::P(deps) => {{
-                let {fst_binding_pairs} = *deps;
-                {snd_exprs}
+                let {fst_binding_pairs} = deps;
+{continuation_self_bindings}{exec_shadow_bindings}                {snd_exprs}
             }}
             POrSType::S(deps) => {{
                 let {fst_binding_pairs} = deps;
-                let {fst_binding_pairs_only_dependent} = {fst_binding_pairs_only_dependent_deref};
-                {snd_exprs}
+{continuation_self_bindings}{exec_shadow_bindings}                {snd_exprs}
             }}
         }}
     }}
@@ -2241,6 +2533,83 @@ impl DisjointFrom<{}> for {} {{
                         _ => None,
                     })
                     .unwrap();
+                let gen_array_choice_arms = |arrays: &[(ConstArray, Combinator)]| {
+                    let const_array_bytes = |array: &ConstArray| -> Option<Vec<u8>> {
+                        match array {
+                            ConstArray::Char(bytes) => Some(bytes.clone()),
+                            ConstArray::Int(ints) => {
+                                ints.iter().map(|value| (*value).try_into().ok()).collect()
+                            }
+                            ConstArray::Repeat(value, count) => {
+                                let value = (*value).try_into().ok()?;
+                                Some(vec![value; *count])
+                            }
+                            ConstArray::Wildcard => None,
+                        }
+                    };
+                    arrays
+                        .iter()
+                        .map(|(variant, combinator)| {
+                            let (inner, code) = combinator.gen_combinator_expr(
+                                name,
+                                mode,
+                                &ctx.disable_top_level(),
+                            );
+                            let bool_exp = match variant {
+                                ConstArray::Char(..)
+                                | ConstArray::Int(..)
+                                | ConstArray::Repeat(..) => {
+                                    let bytes = const_array_bytes(variant).unwrap();
+                                    let bytes = bytes
+                                        .iter()
+                                        .map(|i| format!("{}u8", i))
+                                        .collect::<Vec<_>>()
+                                        .join(", ");
+                                    match mode {
+                                        Mode::Spec => format!("{} == seq![{}]", depend_id, bytes),
+                                        _ => format!(
+                                            "compare_slice({}, [{}].as_slice())",
+                                            depend_id, bytes
+                                        ),
+                                    }
+                                }
+                                ConstArray::Wildcard => {
+                                    let other_variants = arrays
+                                        .iter()
+                                        .filter_map(|(variant, _)| match variant {
+                                            ConstArray::Char(..)
+                                            | ConstArray::Int(..)
+                                            | ConstArray::Repeat(..) => {
+                                                let bytes = const_array_bytes(variant).unwrap();
+                                                let bytes = bytes
+                                                    .iter()
+                                                    .map(|i| format!("{}u8", i))
+                                                    .collect::<Vec<_>>()
+                                                    .join(", ");
+                                                match mode {
+                                                    Mode::Spec => Some(format!(
+                                                        "{} == seq![{}]",
+                                                        depend_id, bytes
+                                                    )),
+                                                    _ => Some(format!(
+                                                        "compare_slice({}, [{}].as_slice())",
+                                                        depend_id, bytes
+                                                    )),
+                                                }
+                                            }
+                                            ConstArray::Wildcard => None,
+                                        })
+                                        .collect::<Vec<_>>();
+                                    format!("!({})", other_variants.join(" || "))
+                                }
+                            };
+                            (
+                                format!("Cond {{ cond: {}, inner: {} }}", bool_exp, inner),
+                                code,
+                            )
+                        })
+                        .unzip()
+                };
                 match combinator {
                     // invocation to an enum
                     CombinatorInner::Invocation(CombinatorInvocation {
@@ -2324,55 +2693,13 @@ impl DisjointFrom<{}> for {} {{
                                     )
                                 })
                                 .unzip(),
-                            Choices::Arrays(..) => unreachable!(),
+                            Choices::Arrays(arrays) => gen_array_choice_arms(arrays),
                         }
                     }
                     // bytes
                     CombinatorInner::Bytes(BytesCombinator { len }) => {
                         match &self.choices {
-                            Choices::Arrays(arrays)=> arrays
-                                .iter()
-                                .map(|(variant, combinator)| {
-                                    let (inner, code) =
-                                        combinator.gen_combinator_expr(name, mode, &ctx.disable_top_level());
-                                    let bool_exp = match variant {
-                                        ConstArray::Int(ints) => {
-                                            let ints = ints.iter().map(|i| format!("{}u8", i)).collect::<Vec<_>>().join(", ");
-                                            match mode {
-                                                Mode::Spec => format!("{} == seq![{}]", depend_id, ints),
-                                                _ => format!("compare_slice({}, {}.as_slice())", depend_id, variant),
-                                            }
-                                        }
-                                        ConstArray::Wildcard => {
-                                                 // default case; the negation of all other cases
-                                             let other_variants = arrays
-                                                 .iter()
-                                                 .filter_map(|(variant, _)| {
-                                                    match variant {
-                                                          ConstArray::Int(ints) => {
-                                                            let ints = ints.iter().map(|i| format!("{}u8", i)).collect::<Vec<_>>().join(", ");
-                                                            match mode {
-                                                                Mode::Spec => Some(format!("{} == seq![{}]", depend_id, ints)),
-                                                                _ => Some(format!(
-                                                                    "compare_slice({}, {}.as_slice())",
-                                                                    depend_id, variant
-                                                                ))
-                                                            }
-                                                        }
-                                                        _ => None
-                                                        }
-                                                 })
-                                                 .collect::<Vec<_>>();
-                                             format!("!({})", other_variants.join(" || "))
-                                        }
-                                        _ => unimplemented!(),
-                                    };
-                                    (
-                                        format!("Cond {{ cond: {}, inner: {} }}", bool_exp, inner),
-                                        code,
-                                    )
-                                })
-                                .unzip(),
+                            Choices::Arrays(arrays) => gen_array_choice_arms(arrays),
                             Choices::Ints(..) | Choices::Enums(..) => unreachable!(),
                         }
                     }
@@ -2528,32 +2855,22 @@ impl Codegen for ArrayCombinator {
     }
 
     fn gen_combinator_expr(&self, name: &str, mode: Mode, ctx: &CodegenCtx) -> (String, String) {
-        let into = match mode {
-            Mode::Spec => ".spec_into()",
-            _ => ".ex_into()",
-        };
+        let convert = length_expr_convert_fn(mode);
         let (inner, additional_code) =
             self.combinator
                 .gen_combinator_expr(name, mode, &ctx.disable_top_level());
-        match &self.len {
-            LengthSpecifier::Const(len) => {
-                (format!("RepeatN({}, {})", inner, len), additional_code)
-            }
-            LengthSpecifier::Dependent(depend_id) => (
-                format!("RepeatN({}, {}{})", inner, depend_id, into),
-                additional_code,
-            ),
-        }
-
-        // let combinator_expr = format!("RepeatN({}, {}{})", inner.0, len, into);
-        // (combinator_expr, inner.1)
+        let len_expr = gen_length_expr(&self.len, convert, ctx);
+        (
+            format!("RepeatN({}, ({}) as usize)", inner, len_expr),
+            additional_code,
+        )
     }
 }
 
 impl Codegen for VecCombinator {
     fn gen_msg_type(&self, name: &str, mode: Mode, ctx: &CodegenCtx) -> String {
         let inner = match self {
-            VecCombinator::Vec1(combinator) | VecCombinator::Vec(combinator) => {
+            VecCombinator::Vec(combinator) => {
                 combinator.gen_msg_type("", mode, &ctx.disable_top_level())
             }
         };
@@ -2586,7 +2903,7 @@ impl Codegen for VecCombinator {
         ctx: &mut CodegenCtx,
     ) -> (String, String) {
         let inner = match self {
-            VecCombinator::Vec1(combinator) | VecCombinator::Vec(combinator) => {
+            VecCombinator::Vec(combinator) => {
                 combinator.gen_combinator_type(name, mode, &mut ctx.disable_top_level())
             }
         };
@@ -2595,7 +2912,7 @@ impl Codegen for VecCombinator {
 
     fn gen_combinator_expr(&self, name: &str, mode: Mode, ctx: &CodegenCtx) -> (String, String) {
         let inner = match self {
-            VecCombinator::Vec1(combinator) | VecCombinator::Vec(combinator) => {
+            VecCombinator::Vec(combinator) => {
                 combinator.gen_combinator_expr(name, mode, &ctx.disable_top_level())
             }
         };
@@ -2607,25 +2924,6 @@ impl Codegen for VecCombinator {
     }
 }
 
-impl Codegen for SepByCombinator {
-    fn gen_msg_type(&self, name: &str, mode: Mode, ctx: &CodegenCtx) -> String {
-        todo!()
-    }
-
-    fn gen_combinator_type(
-        &self,
-        name: &str,
-        mode: Mode,
-        ctx: &mut CodegenCtx,
-    ) -> (String, String) {
-        todo!()
-    }
-
-    fn gen_combinator_expr(&self, name: &str, mode: Mode, ctx: &CodegenCtx) -> (String, String) {
-        todo!()
-    }
-}
-
 impl Codegen for WrapCombinator {
     fn gen_msg_type(&self, name: &str, mode: Mode, ctx: &CodegenCtx) -> String {
         let inner = &self
@@ -2775,25 +3073,6 @@ impl Codegen for WrapCombinator {
     }
 }
 
-impl Codegen for ApplyCombinator {
-    fn gen_msg_type(&self, name: &str, mode: Mode, ctx: &CodegenCtx) -> String {
-        todo!()
-    }
-
-    fn gen_combinator_type(
-        &self,
-        name: &str,
-        mode: Mode,
-        ctx: &mut CodegenCtx,
-    ) -> (String, String) {
-        todo!()
-    }
-
-    fn gen_combinator_expr(&self, name: &str, mode: Mode, ctx: &CodegenCtx) -> (String, String) {
-        todo!()
-    }
-}
-
 impl Codegen for OptionCombinator {
     fn gen_msg_type(&self, name: &str, mode: Mode, ctx: &CodegenCtx) -> String {
         let inner = &self.0.gen_msg_type("", mode, &ctx.disable_top_level());
@@ -2849,10 +3128,6 @@ impl Codegen for ConstCombinator {
             ConstCombinator::ConstInt(c) => c.gen_msg_type(name, mode, ctx),
             ConstCombinator::ConstBytes(c) => c.gen_msg_type(name, mode, ctx),
             ConstCombinator::ConstEnum(c) => c.gen_msg_type(name, mode, ctx),
-            ConstCombinator::ConstArray(..) => todo!(),
-            ConstCombinator::Vec(..) => todo!(),
-            ConstCombinator::ConstStruct(..) => todo!(),
-            ConstCombinator::ConstChoice(..) => todo!(),
             ConstCombinator::ConstCombinatorInvocation(name) => {
                 let invocked = match mode {
                     Mode::Spec => format!("Spec{}", name),
@@ -2898,10 +3173,6 @@ impl Codegen for ConstCombinator {
             ConstCombinator::ConstInt(c) => c.gen_combinator_type(name, mode, ctx),
             ConstCombinator::ConstBytes(c) => c.gen_combinator_type(name, mode, ctx),
             ConstCombinator::ConstEnum(c) => c.gen_combinator_type(name, mode, ctx),
-            ConstCombinator::ConstArray(..) => todo!(),
-            ConstCombinator::Vec(..) => todo!(),
-            ConstCombinator::ConstStruct(..) => todo!(),
-            ConstCombinator::ConstChoice(..) => todo!(),
             ConstCombinator::ConstCombinatorInvocation(name) => {
                 let invocked = snake_to_upper_caml(name);
                 match mode {
@@ -2931,10 +3202,6 @@ impl Codegen for ConstCombinator {
             ConstCombinator::ConstInt(c) => c.gen_combinator_expr(name, mode, ctx),
             ConstCombinator::ConstBytes(c) => c.gen_combinator_expr(name, mode, ctx),
             ConstCombinator::ConstEnum(c) => c.gen_combinator_expr(name, mode, ctx),
-            ConstCombinator::ConstArray(..) => todo!(),
-            ConstCombinator::Vec(..) => todo!(),
-            ConstCombinator::ConstStruct(..) => todo!(),
-            ConstCombinator::ConstChoice(..) => todo!(),
             ConstCombinator::ConstCombinatorInvocation(name) => {
                 let invocked = match mode {
                     Mode::Spec => format!("spec_{}", name),
@@ -3059,9 +3326,9 @@ impl Codegen for ConstraintEnumCombinator {
             enum_type: &str,
             variants: &[Enum],
             exhaustive: bool,
-            inferred: &IntCombinator,
             var: &str,
         ) -> String {
+            let raw_value = format!("(*{var})");
             match constraint {
                 EnumConstraint::Single(variant) => {
                     if exhaustive {
@@ -3072,7 +3339,7 @@ impl Codegen for ConstraintEnumCombinator {
                             .find(|Enum { name, .. }| name == variant)
                             .map(|e| e.value)
                             .unwrap();
-                        format!("{var} == {}", val)
+                        format!("{raw_value} == {}", val)
                     }
                 }
                 EnumConstraint::Set(set) => {
@@ -3087,7 +3354,7 @@ impl Codegen for ConstraintEnumCombinator {
                                     .find(|Enum { name, .. }| name == variant)
                                     .map(|e| e.value)
                                     .unwrap();
-                                format!("{var} == {}", val)
+                                format!("{raw_value} == {}", val)
                             }
                         })
                         .collect::<Vec<_>>();
@@ -3099,7 +3366,7 @@ impl Codegen for ConstraintEnumCombinator {
                 }
                 EnumConstraint::Neg(c) => format!(
                     "!({})",
-                    enum_constraint_expr(c, enum_type, variants, exhaustive, inferred, var)
+                    enum_constraint_expr(c, enum_type, variants, exhaustive, var)
                 ),
             }
         }
@@ -3120,14 +3387,8 @@ impl Codegen for ConstraintEnumCombinator {
 }}
 "#
         );
-        let constraint_expr = enum_constraint_expr(
-            &self.constraint,
-            &enum_type,
-            variants,
-            exhaustive,
-            inferred,
-            "e",
-        );
+        let constraint_expr =
+            enum_constraint_expr(&self.constraint, &enum_type, variants, exhaustive, "e");
         let impl_spec_pred = format!(
             r#"impl SpecPred<{msg_type}> for Predicate{hash} {{
     open spec fn spec_apply(&self, e: &{msg_type}) -> bool {{
@@ -3728,6 +3989,8 @@ pub open spec fn spec_{name}({spec_params}) -> Spec{upper_caml_name}Combinator {
                         .map(|(n, t)| format!("{}: {}", n, t))
                         .collect::<Vec<_>>()
                         .join(", ");
+                    let param_requirements = gen_exec_param_requirements(param_defns, ctx);
+                    let constructor_requires = format_requires_block(&param_requirements, "    ");
                     let args_iter = dep_params_name.iter().map(|&n| n.to_string());
                     let args_view = args_iter
                         .clone()
@@ -3740,9 +4003,40 @@ pub open spec fn spec_{name}({spec_params}) -> Spec{upper_caml_name}Combinator {
                         Mode::Exec(lifetime_ann),
                         ctx,
                     );
+                    let parse_requires = format_requires_block(
+                        &[
+                            vec!["input.len() <= usize::MAX".to_string()],
+                            param_requirements.clone(),
+                        ]
+                        .concat(),
+                        "    ",
+                    );
+                    let serialize_requires = format_requires_block(
+                        &[
+                            vec![
+                                "pos <= old(data)@.len() <= usize::MAX".to_string(),
+                                format!("spec_{name}({args_view}).wf(v@)"),
+                            ],
+                            param_requirements.clone(),
+                        ]
+                        .concat(),
+                        "    ",
+                    );
+                    let len_requires = format_requires_block(
+                        &[
+                            vec![
+                                format!("spec_{name}({args_view}).wf(v@)"),
+                                format!("spec_{name}({args_view}).spec_serialize(v@).len() <= usize::MAX"),
+                            ],
+                            param_requirements.clone(),
+                        ]
+                        .concat(),
+                        "    ",
+                    );
                     code.push_str(&format!(
                         r#"
 pub fn {name}<'a>({exec_params}) -> (o: {upper_caml_name}Combinator)
+{constructor_requires}
     ensures o@ == spec_{name}({args_view}),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
@@ -3757,8 +4051,7 @@ pub fn {name}<'a>({exec_params}) -> (o: {upper_caml_name}Combinator)
 }}
 
 pub fn parse_{name}<'a>(input: &'a [u8], {exec_params}) -> (res: PResult<<{upper_caml_name}Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
+{parse_requires}
     ensures
         res matches Ok((n, v)) ==> spec_{name}({args_view}).spec_parse(input@) == Some((n as int, v@)),
         spec_{name}({args_view}).spec_parse(input@) matches Some((n, v))
@@ -3771,9 +4064,7 @@ pub fn parse_{name}<'a>(input: &'a [u8], {exec_params}) -> (res: PResult<<{upper
 }}
 
 pub fn serialize_{name}<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, {exec_params}) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_{name}({args_view}).wf(v@),
+{serialize_requires}
     ensures
         o matches Ok(n) ==> {{
             &&& data@.len() == old(data)@.len()
@@ -3787,9 +4078,7 @@ pub fn serialize_{name}<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'
 }}
 
 pub fn {name}_len<'a>(v: <{upper_caml_name}Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, {exec_params}) -> (serialize_len: usize)
-    requires
-        spec_{name}({args_view}).wf(v@),
-        spec_{name}({args_view}).spec_serialize(v@).len() <= usize::MAX,
+{len_requires}
     ensures
         serialize_len == spec_{name}({args_view}).spec_serialize(v@).len(),
 {{
diff --git a/vest-dsl/src/elab.rs b/vest-dsl/src/elab.rs
index d67dc032..4e51c8a7 100644
--- a/vest-dsl/src/elab.rs
+++ b/vest-dsl/src/elab.rs
@@ -65,7 +65,7 @@ type MacroDefn<'ast> = (Vec<String>, Combinator<'ast>);
 /// Expand the macro invocations
 fn expand_macros(ast: &mut Vec<Definition>) {
     // collect the macro definitions
-    let mut macro_defns = HashMap::with_hasher(VestHasherBuilder); 
+    let mut macro_defns = HashMap::with_hasher(VestHasherBuilder);
     for defn in ast.iter() {
         if let Definition::MacroDefn { name, params, body } = defn {
             macro_defns.insert(name.name.clone(), (params.clone(), body.clone()));
@@ -127,10 +127,7 @@ fn expand_macros_in_combinator_inner<'ast>(
                     | StructField::Dependent { combinator, .. } => {
                         expand_macros_in_combinator(combinator, macro_defns);
                     }
-                    StructField::Const { .. } => {
-                        // TODO: skip const fields for now
-                    }
-                    _ => {}
+                    StructField::Const { .. } => {}
                 }
             }
         }
@@ -161,11 +158,9 @@ fn expand_macros_in_combinator_inner<'ast>(
                 }
             }
         },
-        CombinatorInner::Vec(combinator) => match combinator {
-            VecCombinator::Vec(combinator) | VecCombinator::Vec1(combinator) => {
-                expand_macros_in_combinator(combinator, macro_defns);
-            }
-        },
+        CombinatorInner::Vec(VecCombinator::Vec(combinator)) => {
+            expand_macros_in_combinator(combinator, macro_defns);
+        }
         CombinatorInner::Array(ArrayCombinator { combinator, .. }) => {
             expand_macros_in_combinator(combinator, macro_defns);
         }
@@ -209,10 +204,7 @@ fn substitute_in_combinator_inner<'ast>(
                     | StructField::Dependent { combinator, .. } => {
                         substitute_in_combinator(combinator, param, arg.clone());
                     }
-                    StructField::Const { .. } => {
-                        // TODO: skip const fields for now
-                    }
-                    _ => {}
+                    StructField::Const { .. } => {}
                 }
             }
         }
@@ -247,11 +239,9 @@ fn substitute_in_combinator_inner<'ast>(
                 }
             }
         },
-        CombinatorInner::Vec(combinator) => match combinator {
-            VecCombinator::Vec(combinator) | VecCombinator::Vec1(combinator) => {
-                substitute_in_combinator(combinator, param, arg.clone());
-            }
-        },
+        CombinatorInner::Vec(VecCombinator::Vec(combinator)) => {
+            substitute_in_combinator(combinator, param, arg.clone());
+        }
         CombinatorInner::Array(ArrayCombinator { combinator, .. }) => {
             substitute_in_combinator(combinator, param, arg.clone());
         }
@@ -265,6 +255,15 @@ fn substitute_in_combinator_inner<'ast>(
 
 fn expand_definitions(ast: &mut Vec<Definition>) {
     let mut expanded = Vec::new();
+    let mut used_names: HashSet<String> = ast
+        .iter()
+        .filter_map(|defn| match defn {
+            Definition::Combinator { name, .. } | Definition::ConstCombinator { name, .. } => {
+                Some(name.name.clone())
+            }
+            _ => None,
+        })
+        .collect();
     let mut elab_ctx = ElabCtx::new();
     for defn in ast.iter_mut() {
         elab_ctx.reset();
@@ -276,16 +275,20 @@ fn expand_definitions(ast: &mut Vec<Definition>) {
                 ..
             } => {
                 param_defns.iter().for_each(|param_defn| {
-                    if let ParamDefn::Dependent {
+                    let ParamDefn::Dependent {
                         name, combinator, ..
-                    } = param_defn
-                    {
-                        elab_ctx
-                            .dependencies
-                            .push((name.name.to_owned(), combinator.clone()));
-                    }
+                    } = param_defn;
+                    elab_ctx
+                        .dependencies
+                        .push((name.name.to_owned(), combinator.clone()));
                 });
-                expand_combinator(name.name.as_str(), combinator, &mut expanded, &mut elab_ctx);
+                expand_combinator(
+                    name.name.as_str(),
+                    combinator,
+                    &mut expanded,
+                    &mut elab_ctx,
+                    &mut used_names,
+                );
             }
             Definition::ConstCombinator { .. } => {}
             _ => {}
@@ -294,138 +297,307 @@ fn expand_definitions(ast: &mut Vec<Definition>) {
     ast.extend(expanded);
 }
 
-#[allow(clippy::single_match)]
-/// for now only expand struct fields containing choices
 fn expand_combinator<'ast>(
     name: &str,
     combinator: &mut Combinator<'ast>,
     expanded: &mut Vec<Definition<'ast>>,
     elab_ctx: &mut ElabCtx<'ast>,
+    used_names: &mut HashSet<String>,
 ) {
+    if let Some(and_then) = &mut combinator.and_then {
+        // Keep the direct continuation inside the current named helper so the
+        // public type for `bytes >>= { ... }` / `bytes >>= choose { ... }`
+        // remains attached to this definition.
+        expand_combinator(
+            &child_generated_name(name, "inner"),
+            and_then,
+            expanded,
+            elab_ctx,
+            used_names,
+        );
+    }
+
     match &mut combinator.inner {
         CombinatorInner::Struct(StructCombinator { fields, .. }) => {
             for field in fields {
                 match field {
                     StructField::Ordinary {
-                        label,
-                        combinator,
-                        span,
+                        label, combinator, ..
                     } => {
-                        if matches!(&combinator.inner, CombinatorInner::Choice(_))
-                            || (matches!(
-                                &combinator.inner,
-                                CombinatorInner::Bytes(_) | CombinatorInner::Tail(_)
-                            ) && combinator.and_then.is_some()
-                                && matches!(
-                                    &combinator.and_then.as_ref().unwrap().inner,
-                                    CombinatorInner::Choice(_)
-                                ))
-                        {
-                            let params: HashSet<Param> = collect_params(combinator);
-                            let param_defns: Vec<ParamDefn> = params
-                                .iter()
-                                .map(|param| match param {
-                                    Param::Dependent(name) => ParamDefn::Dependent {
-                                        name: name.to_owned(),
-                                        combinator: elab_ctx
-                                            .dependencies
-                                            .iter()
-                                            .find_map(|(dep_name, dep_combinator)| {
-                                                if *dep_name == name.name {
-                                                    Some(dep_combinator.clone())
-                                                } else {
-                                                    None
-                                                }
-                                            })
-                                            .unwrap_or_else(|| {
-                                                panic!("Dependent combinator not found: {}", name)
-                                            }),
-                                        span: *span,
-                                    },
-                                    _ => unreachable!(),
-                                })
-                                .collect();
-                            let generated_name = name.to_owned() + "_" + label.name.as_str();
-                            let new_defn = Definition::Combinator {
-                                name: Identifier {
-                                    name: generated_name.clone(),
-                                    span: *span,
-                                },
-                                combinator: combinator.clone(),
-                                param_defns,
-                                span: span.clone(),
-                            };
-                            *combinator = Combinator {
-                                inner: CombinatorInner::Invocation(CombinatorInvocation {
-                                    func: Identifier {
-                                        name: generated_name,
-                                        span: *span,
-                                    },
-                                    args: params.into_iter().collect(),
-                                    span: *span,
-                                }),
-                                and_then: None,
-                                span: *span,
-                            };
-                            expanded.push(new_defn);
-                            // expand_definitions(expanded);
-                        }
+                        expand_child_combinator(
+                            &child_generated_name(name, &generated_segment(&label.name)),
+                            combinator,
+                            expanded,
+                            elab_ctx,
+                            used_names,
+                        );
                     }
                     StructField::Dependent {
                         label, combinator, ..
                     } => {
+                        expand_child_combinator(
+                            &child_generated_name(name, &generated_segment(&label.name)),
+                            combinator,
+                            expanded,
+                            elab_ctx,
+                            used_names,
+                        );
                         elab_ctx
                             .dependencies
                             .push((label.name.to_owned(), combinator.inner.clone()));
-                        // TODO: do we care `and_then` here?
-                        // NOTE: don't expand dependent fields for now
                     }
                     StructField::Const { .. } => {}
-                    _ => {}
                 }
             }
         }
-        // CombinatorInner::Choice(ChoiceCombinator { depend_id, choices }) =>
-        // CombinatorInner::Bytes(BytesCombinator { len }) =>
-        // CombinatorInner::Tail(TailCombinator) =>
-        // CombinatorInner::ConstraintInt(..) => {}
-        CombinatorInner::ConstraintEnum(..) => {}
-        // CombinatorInner::Wrap(..) => {}
-        // CombinatorInner::Enum(..) => {}
-        // CombinatorInner::SepBy(SepByCombinator { combinator, sep }) =>
-        // CombinatorInner::Vec(VecCombinator::Vec(combinator)) =>
-        // CombinatorInner::Vec(VecCombinator::Vec1(combinator)) =>
-        // CombinatorInner::Array(ArrayCombinator { combinator, len }) =>
-        // CombinatorInner::Apply(ApplyCombinator { stream, combinator }) =>
-        // CombinatorInner::Option(OptionCombinator(combinator)) =>
-        // CombinatorInner::Invocation(CombinatorInvocation { func, args }) =>
+        CombinatorInner::Choice(ChoiceCombinator { choices, .. }) => match choices {
+            Choices::Enums(enums) => {
+                for (variant, combinator) in enums {
+                    expand_child_combinator(
+                        &child_generated_name(name, &generated_segment(&variant.name)),
+                        combinator,
+                        expanded,
+                        elab_ctx,
+                        used_names,
+                    );
+                }
+            }
+            Choices::Ints(ints) => {
+                for (idx, (_, combinator)) in ints.iter_mut().enumerate() {
+                    expand_child_combinator(
+                        &child_generated_name(name, &format!("choice{idx}")),
+                        combinator,
+                        expanded,
+                        elab_ctx,
+                        used_names,
+                    );
+                }
+            }
+            Choices::Arrays(arrays) => {
+                for (idx, (_, combinator)) in arrays.iter_mut().enumerate() {
+                    expand_child_combinator(
+                        &child_generated_name(name, &format!("choice{idx}")),
+                        combinator,
+                        expanded,
+                        elab_ctx,
+                        used_names,
+                    );
+                }
+            }
+        },
+        CombinatorInner::Wrap(WrapCombinator { combinator, .. }) => {
+            expand_child_combinator(
+                &child_generated_name(name, "inner"),
+                combinator,
+                expanded,
+                elab_ctx,
+                used_names,
+            );
+        }
+        CombinatorInner::Vec(VecCombinator::Vec(combinator))
+        | CombinatorInner::Array(ArrayCombinator { combinator, .. })
+        | CombinatorInner::Option(OptionCombinator(combinator)) => {
+            expand_child_combinator(
+                &child_generated_name(name, "item"),
+                combinator,
+                expanded,
+                elab_ctx,
+                used_names,
+            );
+        }
         _ => {}
     }
 }
 
+fn expand_child_combinator<'ast>(
+    generated_base: &str,
+    combinator: &mut Combinator<'ast>,
+    expanded: &mut Vec<Definition<'ast>>,
+    elab_ctx: &mut ElabCtx<'ast>,
+    used_names: &mut HashSet<String>,
+) {
+    if contains_anonymous_format(combinator) {
+        *combinator =
+            lift_anonymous_combinator(generated_base, combinator, expanded, elab_ctx, used_names);
+    } else {
+        expand_combinator(generated_base, combinator, expanded, elab_ctx, used_names);
+    }
+}
+
+fn lift_anonymous_combinator<'ast>(
+    generated_base: &str,
+    combinator: &Combinator<'ast>,
+    expanded: &mut Vec<Definition<'ast>>,
+    elab_ctx: &ElabCtx<'ast>,
+    used_names: &mut HashSet<String>,
+) -> Combinator<'ast> {
+    let generated_name = fresh_generated_name(generated_base, used_names);
+    let mut lifted = combinator.clone();
+    let mut lifted_ctx = ElabCtx {
+        dependencies: elab_ctx.dependencies.clone(),
+    };
+    let params = sorted_params(&lifted);
+    let param_defns = build_param_defns(&params, &lifted_ctx.dependencies, lifted.span);
+
+    expand_combinator(
+        generated_name.as_str(),
+        &mut lifted,
+        expanded,
+        &mut lifted_ctx,
+        used_names,
+    );
+
+    expanded.push(Definition::Combinator {
+        name: Identifier {
+            name: generated_name.clone(),
+            span: combinator.span,
+        },
+        param_defns,
+        combinator: lifted,
+        span: combinator.span,
+    });
+
+    Combinator {
+        inner: CombinatorInner::Invocation(CombinatorInvocation {
+            func: Identifier {
+                name: generated_name,
+                span: combinator.span,
+            },
+            args: params,
+            span: combinator.span,
+        }),
+        and_then: None,
+        span: combinator.span,
+    }
+}
+
+fn build_param_defns<'ast>(
+    params: &[Param<'ast>],
+    dependencies: &[(String, CombinatorInner<'ast>)],
+    span: Span<'ast>,
+) -> Vec<ParamDefn<'ast>> {
+    params
+        .iter()
+        .map(|param| match param {
+            Param::Dependent(name) => ParamDefn::Dependent {
+                name: name.to_owned(),
+                combinator: dependencies
+                    .iter()
+                    .find_map(|(dep_name, dep_combinator)| {
+                        if *dep_name == name.name {
+                            Some(dep_combinator.clone())
+                        } else {
+                            None
+                        }
+                    })
+                    .unwrap_or_else(|| panic!("Dependent combinator not found: {}", name)),
+                span,
+            },
+        })
+        .collect()
+}
+
+fn sorted_params<'ast>(combinator: &Combinator<'ast>) -> Vec<Param<'ast>> {
+    let mut params: Vec<_> = collect_params(combinator).into_iter().collect();
+    params.sort_by(|lhs, rhs| match (lhs, rhs) {
+        (Param::Dependent(lhs), Param::Dependent(rhs)) => lhs.name.cmp(&rhs.name),
+    });
+    params
+}
+
+fn contains_anonymous_format(combinator: &Combinator) -> bool {
+    if let Some(and_then) = &combinator.and_then {
+        if contains_anonymous_format(and_then) {
+            return true;
+        }
+    }
+
+    match &combinator.inner {
+        CombinatorInner::Struct(..) | CombinatorInner::Choice(..) => true,
+        CombinatorInner::Wrap(WrapCombinator { combinator, .. })
+        | CombinatorInner::Vec(VecCombinator::Vec(combinator))
+        | CombinatorInner::Array(ArrayCombinator { combinator, .. })
+        | CombinatorInner::Option(OptionCombinator(combinator)) => {
+            contains_anonymous_format(combinator)
+        }
+        _ => false,
+    }
+}
+
+fn generated_segment(segment: &str) -> String {
+    let mut generated = String::new();
+    for ch in segment.chars() {
+        if ch.is_ascii_alphanumeric() {
+            generated.push(ch.to_ascii_lowercase());
+        } else {
+            generated.push('_');
+        }
+    }
+    if generated.is_empty() {
+        "anon".to_string()
+    } else {
+        generated
+    }
+}
+
+fn child_generated_name(parent: &str, segment: &str) -> String {
+    if segment == "inner" {
+        // `FooInner` is already reserved by codegen for the parent definition's
+        // tuple/choice carrier type, so lifted anonymous continuations need a
+        // distinct suffix here.
+        format!("{parent}_anon_{segment}")
+    } else {
+        format!("{parent}_{segment}")
+    }
+}
+
+fn fresh_generated_name(base: &str, used_names: &mut HashSet<String>) -> String {
+    if used_names.insert(base.to_string()) {
+        return base.to_string();
+    }
+
+    let mut idx = 0usize;
+    loop {
+        let candidate = format!("{base}_{idx}");
+        if used_names.insert(candidate.clone()) {
+            return candidate;
+        }
+        idx += 1;
+    }
+}
+
 fn collect_params<'ast>(combinator: &Combinator<'ast>) -> HashSet<Param<'ast>> {
+    collect_params_with_bound(combinator, &HashSet::new())
+}
+
+fn collect_params_with_bound<'ast>(
+    combinator: &Combinator<'ast>,
+    bound: &HashSet<String>,
+) -> HashSet<Param<'ast>> {
     let mut params = HashSet::new();
     match &combinator.inner {
         CombinatorInner::Choice(ChoiceCombinator {
             depend_id, choices, ..
         }) => {
             if let Some(depend_id) = depend_id {
-                params.insert(Param::Dependent(depend_id.to_owned()));
+                if !bound.contains(&depend_id.name) {
+                    params.insert(Param::Dependent(depend_id.to_owned()));
+                }
             }
             match choices {
                 Choices::Enums(enums) => {
                     for (_, combinator) in enums {
-                        params.extend(collect_params(combinator));
+                        params.extend(collect_params_with_bound(combinator, bound));
                     }
                 }
                 Choices::Ints(ints) => {
                     for (_, combinator) in ints {
-                        params.extend(collect_params(combinator));
+                        params.extend(collect_params_with_bound(combinator, bound));
                     }
                 }
                 Choices::Arrays(arrays) => {
                     for (_, combinator) in arrays {
-                        params.extend(collect_params(combinator));
+                        params.extend(collect_params_with_bound(combinator, bound));
                     }
                 }
             }
@@ -433,61 +605,65 @@ fn collect_params<'ast>(combinator: &Combinator<'ast>) -> HashSet<Param<'ast>> {
         CombinatorInner::Array(ArrayCombinator {
             combinator, len, ..
         }) => {
-            if let LengthSpecifier::Dependent(name) = len {
-                params.insert(Param::Dependent(name.to_owned()));
+            for dep_id in len.collect_dependent_ids() {
+                let ident = dep_id.to_identifier();
+                if !bound.contains(&ident.name) {
+                    params.insert(Param::Dependent(ident));
+                }
             }
-            params.extend(collect_params(combinator));
+            params.extend(collect_params_with_bound(combinator, bound));
         }
         CombinatorInner::Bytes(BytesCombinator { len, .. }) => {
-            if let LengthSpecifier::Dependent(name) = len {
-                params.insert(Param::Dependent(name.to_owned()));
+            for dep_id in len.collect_dependent_ids() {
+                let ident = dep_id.to_identifier();
+                if !bound.contains(&ident.name) {
+                    params.insert(Param::Dependent(ident));
+                }
             }
             if let Some(and_then) = &combinator.and_then {
-                params.extend(collect_params(and_then));
+                params.extend(collect_params_with_bound(and_then, bound));
             }
         }
         CombinatorInner::Tail(..) => {
             if let Some(and_then) = &combinator.and_then {
-                params.extend(collect_params(and_then));
+                params.extend(collect_params_with_bound(and_then, bound));
             }
         }
         CombinatorInner::Invocation(CombinatorInvocation { args, .. }) => {
             for arg in args {
-                if let Param::Dependent(name) = arg {
+                let Param::Dependent(name) = arg;
+                if !bound.contains(&name.name) {
                     params.insert(Param::Dependent(name.to_owned()));
                 }
             }
         }
-        CombinatorInner::Vec(VecCombinator::Vec1(combinator) | VecCombinator::Vec(combinator)) => {
-            params.extend(collect_params(combinator));
-        }
-        CombinatorInner::SepBy(SepByCombinator {
-            combinator: VecCombinator::Vec(combinator) | VecCombinator::Vec1(combinator),
-            ..
-        }) => {
-            params.extend(collect_params(combinator));
+        CombinatorInner::Vec(VecCombinator::Vec(combinator)) => {
+            params.extend(collect_params_with_bound(combinator, bound));
         }
         CombinatorInner::Wrap(WrapCombinator { combinator, .. }) => {
-            params.extend(collect_params(combinator));
+            params.extend(collect_params_with_bound(combinator, bound));
         }
         CombinatorInner::Struct(StructCombinator { fields, .. }) => {
+            let mut locally_bound = bound.clone();
             for field in fields {
                 match field {
                     StructField::Ordinary { combinator, .. }
                     | StructField::Dependent { combinator, .. } => {
-                        params.extend(collect_params(combinator));
+                        params.extend(collect_params_with_bound(combinator, &locally_bound));
                     }
-                    _ => {}
+                    StructField::Const { .. } => {}
+                }
+                if let StructField::Dependent { label, .. } = field {
+                    locally_bound.insert(label.name.clone());
                 }
             }
         }
         CombinatorInner::Option(OptionCombinator(combinator)) => {
-            params.extend(collect_params(combinator));
+            params.extend(collect_params_with_bound(combinator, bound));
         }
         CombinatorInner::Enum(..)
         | CombinatorInner::ConstraintInt(..)
-        | CombinatorInner::ConstraintEnum(..)
-        | CombinatorInner::Apply(..) => {}
+        | CombinatorInner::ConstraintEnum(..) => {}
 
         CombinatorInner::MacroInvocation { .. } => {
             unreachable!("macro invocation should be resolved by now")
@@ -541,7 +717,6 @@ fn collect_invocations_inner(combinator_inner: &CombinatorInner, invocations: &m
                         collect_invocations(combinator, invocations);
                     }
                     StructField::Const { .. } => {}
-                    _ => {}
                 }
             }
         }
@@ -565,7 +740,7 @@ fn collect_invocations_inner(combinator_inner: &CombinatorInner, invocations: &m
                 }
             }
         },
-        CombinatorInner::Vec(VecCombinator::Vec(combinator) | VecCombinator::Vec1(combinator)) => {
+        CombinatorInner::Vec(VecCombinator::Vec(combinator)) => {
             collect_invocations(combinator, invocations);
         }
         CombinatorInner::Array(ArrayCombinator { combinator, .. }) => {
@@ -579,56 +754,21 @@ fn collect_invocations_inner(combinator_inner: &CombinatorInner, invocations: &m
         CombinatorInner::ConstraintEnum(ConstraintEnumCombinator { combinator, .. }) => {
             invocations.push(combinator.func.name.to_owned());
             for arg in &combinator.args {
-                if let Param::Dependent(name) = arg {
-                    let _ = name; // no invocations inside params
-                }
+                let Param::Dependent(name) = arg;
+                let _ = name; // no invocations inside params
             }
         }
         CombinatorInner::Bytes(..) => {}
         CombinatorInner::Tail(..) => {}
-        CombinatorInner::Apply(..) => {}
-        CombinatorInner::SepBy(..) => {}
         CombinatorInner::MacroInvocation { .. } => {}
     }
 }
 
 fn collect_const_invocations(const_combinator: &ConstCombinator) -> Vec<String> {
-    let mut invocations = Vec::new();
     match const_combinator {
-        ConstCombinator::ConstStruct(ConstStructCombinator(fields)) => {
-            for field in fields {
-                if let ConstCombinator::ConstCombinatorInvocation {
-                    name: invocation, ..
-                } = field
-                {
-                    invocations.push(invocation.name.to_owned());
-                }
-            }
-        }
-        ConstCombinator::ConstChoice(ConstChoiceCombinator(choices)) => {
-            for ConstChoice { combinator, .. } in choices {
-                if let ConstCombinator::ConstCombinatorInvocation {
-                    name: invocation, ..
-                } = combinator
-                {
-                    invocations.push(invocation.name.to_owned());
-                }
-            }
-        }
         ConstCombinator::ConstCombinatorInvocation {
             name: invocation, ..
-        } => {
-            invocations.push(invocation.name.to_owned());
-        }
-        ConstCombinator::Vec(combinator) => {
-            if let ConstCombinator::ConstCombinatorInvocation {
-                name: invocation, ..
-            } = combinator.as_ref()
-            {
-                invocations.push(invocation.name.to_owned());
-            }
-        }
-        _ => {}
+        } => vec![invocation.name.to_owned()],
+        _ => Vec::new(),
     }
-    invocations
 }
diff --git a/vest-dsl/src/lib.rs b/vest-dsl/src/lib.rs
index c6e647c1..e7a4276c 100644
--- a/vest-dsl/src/lib.rs
+++ b/vest-dsl/src/lib.rs
@@ -33,9 +33,10 @@ impl std::error::Error for VestError {}
 /// Compiles the given source code and returns the resulting output.
 ///
 /// # Example
-/// ```rust
+/// ```rust,ignore
 /// use std::error::Error;
 /// use std::io::Write;
+/// use vest::{compile, codegen::CodegenOpts};
 ///
 /// // build.rs
 /// fn main() -> Result<(), Box<dyn Error>> {
@@ -113,10 +114,11 @@ pub fn compile(
 /// Compiles the given file and returns the resulting output.
 ///
 /// # Example
-/// ```rust
+/// ```rust,ignore
 /// // build.rs
 /// use std::error::Error;
 /// use std::io::Write;
+/// use vest::{compile_file, codegen::CodegenOpts};
 ///
 /// fn main() -> Result<(), Box<dyn Error>> {
 ///   println!("cargo::rerun-if-changed=src/tlv.vest");
@@ -138,15 +140,16 @@ pub fn compile_file(
 /// Compiles the given file and saves it to `output_file`.
 ///
 /// # Example
-/// ```rust
+/// ```rust,ignore
 /// // build.rs
 /// use std::error::Error;
+/// use vest::{compile_to, codegen::CodegenOpts};
 ///
 /// fn main() -> Result<(), Box<dyn Error>> {
 ///   println!("cargo::rerun-if-changed=src/tlv.vest");
 ///   let input_file = "src/tlv.vest";
 ///   let output_file = "src/tlv.rs";
-///   let code = compile_to(file_name, CodegenOpts::All, output_file)?;
+///   compile_to(input_file, CodegenOpts::All, output_file)?;
 ///   Ok(())
 /// }
 /// ```
diff --git a/vest-dsl/src/main.rs b/vest-dsl/src/main.rs
index 590a9e1b..e682eac0 100644
--- a/vest-dsl/src/main.rs
+++ b/vest-dsl/src/main.rs
@@ -1,12 +1,7 @@
-use std::{error::Error, io::Write, path::PathBuf};
-
-mod ast;
-mod elab;
-mod type_check;
-mod utils;
-mod vestir;
+use std::{error::Error, path::PathBuf};
 
 use clap::Parser;
+use vest::{codegen::CodegenOpts, compile_to};
 
 /// Vest: A generator for formally verified parsers/serializers in Verus
 #[derive(Parser, Debug)]
@@ -34,41 +29,22 @@ fn replace_extension(filename: &str, new_ext: &str) -> String {
     path.to_string_lossy().into_owned()
 }
 
-#[derive(Debug)]
-pub enum VestError {
-    ParsingError,
-    TypeError,
-    CodegenError,
-}
-
-impl std::fmt::Display for VestError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            VestError::ParsingError => write!(f, "Failed to compile, parsing error."),
-            VestError::TypeError => write!(f, "Failed to compile, type error."),
-            VestError::CodegenError => write!(f, "Failed to compile, codegen error."),
-        }
-    }
-}
-
-impl std::error::Error for VestError {}
-
 fn main() -> Result<(), Box<dyn Error>> {
     let args = Args::parse();
 
     let codegen_opt = args
         .codegen
         .map(|s| match s.as_str() {
-            "all" => vest::codegen::CodegenOpts::All,
-            "types" => vest::codegen::CodegenOpts::Types,
-            "impls" => vest::codegen::CodegenOpts::Impls,
-            "anns" => vest::codegen::CodegenOpts::Anns,
+            "all" => CodegenOpts::All,
+            "types" => CodegenOpts::Types,
+            "impls" => CodegenOpts::Impls,
+            "anns" => CodegenOpts::Anns,
             _ => panic!("Invalid codegen option"),
         })
-        .unwrap_or(vest::codegen::CodegenOpts::All);
+        .unwrap_or(CodegenOpts::All);
     let output_file = args
         .output
         .unwrap_or(replace_extension(args.vest_file.as_str(), "rs"));
-    vest::compile_to(&args.vest_file, codegen_opt, &output_file)?;
+    compile_to(&args.vest_file, codegen_opt, &output_file)?;
     Ok(())
 }
diff --git a/vest-dsl/src/type_check.rs b/vest-dsl/src/type_check.rs
index 5a23bd3a..d1846238 100644
--- a/vest-dsl/src/type_check.rs
+++ b/vest-dsl/src/type_check.rs
@@ -13,6 +13,7 @@ pub struct GlobalCtx<'ast> {
     pub combinators: HashSet<CombinatorSig<'ast>>,
     pub const_combinators: HashSet<ConstCombinatorSig<'ast>>,
     pub enums: HashMap<&'ast str, EnumCombinator<'ast>>, // enum name -> enum combinator
+    pub static_sizes: HashMap<String, usize>,
 }
 
 pub struct LocalCtx<'ast> {
@@ -55,19 +56,17 @@ pub struct ConstCombinatorSig<'ast> {
 }
 
 impl<'ast> CombinatorSig<'ast> {
-    pub fn as_span(&self) -> Span {
-        let (mut start, mut end) = (usize::MAX, 0);
-        let input = self.resolved_combinator.as_span().get_input();
+    pub fn as_span(&self) -> Span<'ast> {
+        let body_span = self.resolved_combinator.as_span();
+        let input = body_span.get_input();
+        let mut start = self.name.span.start();
+        let mut end = body_span.end();
         for param in self.param_defns {
-            match param {
-                ParamDefn::Dependent { span, .. } => {
-                    start = start.min(span.start());
-                    end = end.max(span.end());
-                }
-                _ => {}
-            }
+            let ParamDefn::Dependent { span, .. } = param;
+            start = start.min(span.start());
+            end = end.max(span.end());
         }
-        Span::new(input, start, end).unwrap()
+        Span::new(input, start, end).expect("combinator signature span should be valid")
     }
 }
 
@@ -112,6 +111,282 @@ impl<'ast> GlobalCtx<'ast> {
     }
 }
 
+struct StaticSizeEnv<'ast> {
+    formats: HashMap<&'ast str, &'ast Combinator<'ast>>,
+    const_formats: HashMap<&'ast str, &'ast ConstCombinator<'ast>>,
+    format_sizes: HashMap<String, Option<usize>>,
+    const_sizes: HashMap<String, Option<usize>>,
+    visiting_formats: HashSet<String>,
+    visiting_consts: HashSet<String>,
+}
+
+impl<'ast> StaticSizeEnv<'ast> {
+    fn new(ast: &'ast [Definition<'ast>]) -> Self {
+        let mut formats = HashMap::new();
+        let mut const_formats = HashMap::new();
+        for defn in ast {
+            match defn {
+                Definition::Combinator {
+                    name, combinator, ..
+                } => {
+                    formats.insert(name.name.as_str(), combinator);
+                }
+                Definition::ConstCombinator {
+                    name,
+                    const_combinator,
+                    ..
+                } => {
+                    const_formats.insert(name.name.as_str(), const_combinator);
+                }
+                _ => {}
+            }
+        }
+
+        let mut format_sizes = HashMap::new();
+        for (name, size) in builtin_static_sizes() {
+            format_sizes.insert(name.to_string(), Some(size));
+        }
+
+        Self {
+            formats,
+            const_formats,
+            format_sizes,
+            const_sizes: HashMap::new(),
+            visiting_formats: HashSet::new(),
+            visiting_consts: HashSet::new(),
+        }
+    }
+
+    fn compute_all(mut self) -> HashMap<String, usize> {
+        let format_names = self.formats.keys().copied().collect::<Vec<_>>();
+        for name in format_names {
+            let _ = self.format_size(name);
+        }
+
+        self.format_sizes
+            .into_iter()
+            .filter_map(|(name, size)| size.map(|size| (name, size)))
+            .collect()
+    }
+
+    fn format_size(&mut self, name: &str) -> Option<usize> {
+        if let Some(size) = self.format_sizes.get(name) {
+            return *size;
+        }
+
+        let combinator = *self.formats.get(name)?;
+        let name = name.to_string();
+        if !self.visiting_formats.insert(name.clone()) {
+            self.format_sizes.insert(name, None);
+            return None;
+        }
+
+        let size = self.combinator_size(combinator);
+        self.visiting_formats.remove(&name);
+        self.format_sizes.insert(name, size);
+        size
+    }
+
+    fn const_format_size(&mut self, name: &str) -> Option<usize> {
+        if let Some(size) = self.const_sizes.get(name) {
+            return *size;
+        }
+
+        let combinator = *self.const_formats.get(name)?;
+        let name = name.to_string();
+        if !self.visiting_consts.insert(name.clone()) {
+            self.const_sizes.insert(name, None);
+            return None;
+        }
+
+        let size = self.const_combinator_size(combinator);
+        self.visiting_consts.remove(&name);
+        self.const_sizes.insert(name, size);
+        size
+    }
+
+    fn combinator_size(&mut self, combinator: &Combinator<'ast>) -> Option<usize> {
+        // `>>=` reparses the bytes from `inner`, so it does not change the consumed size.
+        self.combinator_inner_size(&combinator.inner)
+    }
+
+    fn combinator_inner_size(&mut self, inner: &CombinatorInner<'ast>) -> Option<usize> {
+        use CombinatorInner::*;
+
+        match inner {
+            ConstraintInt(combinator) => int_combinator_static_size(&combinator.combinator),
+            ConstraintEnum(combinator) => self.format_size(&combinator.combinator.func.name),
+            Struct(StructCombinator { fields, .. }) => {
+                fields.iter().try_fold(0usize, |acc, field| {
+                    let field_size = match field {
+                        StructField::Ordinary { combinator, .. }
+                        | StructField::Dependent { combinator, .. } => {
+                            self.combinator_size(combinator)
+                        }
+                        StructField::Const { combinator, .. } => {
+                            self.const_combinator_size(combinator)
+                        }
+                    }?;
+                    acc.checked_add(field_size)
+                })
+            }
+            Wrap(WrapCombinator {
+                prior,
+                combinator,
+                post,
+                ..
+            }) => {
+                let prior_size = prior.iter().try_fold(0usize, |acc, combinator| {
+                    acc.checked_add(self.const_combinator_size(combinator)?)
+                })?;
+                let inner_size = self.combinator_size(combinator)?;
+                let post_size = post.iter().try_fold(0usize, |acc, combinator| {
+                    acc.checked_add(self.const_combinator_size(combinator)?)
+                })?;
+                prior_size.checked_add(inner_size)?.checked_add(post_size)
+            }
+            Enum(enum_comb) => enum_static_size(enum_comb),
+            Choice(ChoiceCombinator { choices, .. }) => self.choice_size(choices),
+            Vec(..) | Tail(..) | Option(..) => None,
+            Array(ArrayCombinator {
+                combinator, len, ..
+            }) => {
+                let elem_size = self.combinator_size(combinator)?;
+                let len = self.length_expr_size(len)?;
+                elem_size.checked_mul(len)
+            }
+            Bytes(BytesCombinator { len, .. }) => self.length_expr_size(len),
+            Invocation(CombinatorInvocation { func, .. }) => self.format_size(&func.name),
+            MacroInvocation { .. } => unreachable!("macro invocation should be resolved by now"),
+        }
+    }
+
+    fn const_combinator_size(&mut self, combinator: &ConstCombinator<'ast>) -> Option<usize> {
+        use ConstCombinator::*;
+
+        match combinator {
+            ConstBytes(ConstBytesCombinator { len, .. }) => Some(*len),
+            ConstInt(ConstIntCombinator { combinator, .. }) => {
+                int_combinator_static_size(combinator)
+            }
+            ConstEnum(ConstEnumCombinator { combinator, .. }) => {
+                self.format_size(&combinator.func.name)
+            }
+            ConstCombinatorInvocation { name, .. } => self.const_format_size(&name.name),
+        }
+    }
+
+    fn choice_size(&mut self, choices: &Choices<'ast>) -> Option<usize> {
+        match choices {
+            Choices::Enums(choices) => common_static_size(
+                choices
+                    .iter()
+                    .map(|(_, combinator)| self.combinator_size(combinator)),
+            ),
+            Choices::Ints(choices) => common_static_size(
+                choices
+                    .iter()
+                    .map(|(_, combinator)| self.combinator_size(combinator)),
+            ),
+            Choices::Arrays(choices) => common_static_size(
+                choices
+                    .iter()
+                    .map(|(_, combinator)| self.combinator_size(combinator)),
+            ),
+        }
+    }
+
+    fn length_expr_size(&mut self, len: &LengthExpr<'ast>) -> Option<usize> {
+        match len {
+            LengthExpr::Const { value, .. } => Some(*value),
+            LengthExpr::Dependent(..) => None,
+            LengthExpr::SizeOf { format_name, .. } => self.format_size(&format_name.name),
+            LengthExpr::BinOp {
+                op, left, right, ..
+            } => {
+                let left = self.length_expr_size(left)?;
+                let right = self.length_expr_size(right)?;
+                match op {
+                    ArithOp::Add => left.checked_add(right),
+                    ArithOp::Sub => left.checked_sub(right),
+                    ArithOp::Mul => left.checked_mul(right),
+                    ArithOp::Div => left.checked_div(right),
+                }
+            }
+        }
+    }
+}
+
+fn builtin_static_sizes() -> [(&'static str, usize); 10] {
+    [
+        ("u8", 1),
+        ("i8", 1),
+        ("u16", 2),
+        ("i16", 2),
+        ("u24", 3),
+        ("i24", 3),
+        ("u32", 4),
+        ("i32", 4),
+        ("u64", 8),
+        ("i64", 8),
+    ]
+}
+
+fn int_combinator_static_size(combinator: &IntCombinator) -> Option<usize> {
+    match combinator {
+        IntCombinator::Unsigned(8) | IntCombinator::Signed(8) => Some(1),
+        IntCombinator::Unsigned(16) | IntCombinator::Signed(16) => Some(2),
+        IntCombinator::Unsigned(24) | IntCombinator::Signed(24) => Some(3),
+        IntCombinator::Unsigned(32) | IntCombinator::Signed(32) => Some(4),
+        IntCombinator::Unsigned(64) | IntCombinator::Signed(64) => Some(8),
+        IntCombinator::BtcVarint | IntCombinator::ULEB128 => None,
+        _ => None,
+    }
+}
+
+fn enum_static_size(enum_comb: &EnumCombinator<'_>) -> Option<usize> {
+    let enums = match enum_comb {
+        EnumCombinator::Exhaustive { enums, .. } | EnumCombinator::NonExhaustive { enums, .. } => {
+            enums
+        }
+    };
+    int_combinator_static_size(&resolve_enum_type(enums))
+}
+
+fn common_static_size(sizes: impl IntoIterator<Item = Option<usize>>) -> Option<usize> {
+    let mut sizes = sizes.into_iter();
+    let first = sizes.next()??;
+    for size in sizes {
+        if size? != first {
+            return None;
+        }
+    }
+    Some(first)
+}
+
+fn eval_const_length_expr(
+    len: &LengthExpr<'_>,
+    static_sizes: &HashMap<String, usize>,
+) -> Option<usize> {
+    match len {
+        LengthExpr::Const { value, .. } => Some(*value),
+        LengthExpr::Dependent(..) => None,
+        LengthExpr::SizeOf { format_name, .. } => static_sizes.get(&format_name.name).copied(),
+        LengthExpr::BinOp {
+            op, left, right, ..
+        } => {
+            let left = eval_const_length_expr(left, static_sizes)?;
+            let right = eval_const_length_expr(right, static_sizes)?;
+            match op {
+                ArithOp::Add => left.checked_add(right),
+                ArithOp::Sub => left.checked_sub(right),
+                ArithOp::Mul => left.checked_mul(right),
+                ArithOp::Div => left.checked_div(right),
+            }
+        }
+    }
+}
+
 fn span_as_range(span: &Span) -> std::ops::Range<usize> {
     span.start()..span.end()
 }
@@ -139,6 +414,7 @@ pub fn check<'ast>(
         combinators: HashSet::new(),
         const_combinators: HashSet::new(),
         enums: HashMap::new(),
+        static_sizes: HashMap::new(),
     };
     let mut local_ctx = LocalCtx::new();
     for defn in ast {
@@ -246,6 +522,8 @@ pub fn check<'ast>(
         }
     }
 
+    global_ctx.static_sizes = StaticSizeEnv::new(ast).compute_all();
+
     for defn in ast {
         check_defn(defn, &mut local_ctx, &global_ctx, source)?;
     }
@@ -292,115 +570,13 @@ fn check_const_combinator<'ast>(
             variant,
             span,
         }) => check_const_enum_combinator(combinator, variant, span, local_ctx, global_ctx, source),
-        ConstArray(combinator) => check_const_array_combinator(combinator, source),
         ConstBytes(combinator) => check_const_bytes_combinator(combinator, source),
-        ConstStruct(ConstStructCombinator(const_combinators)) => {
-            check_const_struct_combinator(const_combinators, local_ctx, global_ctx, source)
-        }
-        ConstChoice(ConstChoiceCombinator(const_choices)) => {
-            check_const_choice_combinator(const_choices, local_ctx, global_ctx, source)
-        }
-        Vec(const_combinator) => {
-            check_const_combinator(const_combinator, local_ctx, global_ctx, source)
-        }
         ConstCombinatorInvocation { name, span } => {
             check_const_combinator_invocation(name, *span, local_ctx, global_ctx, source)
         }
     }
 }
 
-fn check_const_struct_combinator<'ast>(
-    const_combinators: &[ConstCombinator<'ast>],
-    local_ctx: &mut LocalCtx<'ast>,
-    global_ctx: &'ast GlobalCtx<'ast>,
-    source: (&str, &Source),
-) -> Result<(), VestError> {
-    for const_combinator in const_combinators {
-        check_const_combinator(const_combinator, local_ctx, global_ctx, source)?;
-    }
-    Ok(())
-}
-
-fn check_const_array_combinator(
-    ConstArrayCombinator {
-        combinator,
-        len,
-        values,
-        span,
-    }: &ConstArrayCombinator,
-    source: (&str, &Source),
-) -> Result<(), VestError> {
-    match values {
-        ConstArray::Int {
-            ints: int_vals,
-            span: array_span,
-        } => {
-            if int_vals.len() != *len {
-                Report::build(ReportKind::Error, (source.0, span_as_range(span)))
-                    .with_message("mismatched array length")
-                    .with_label(
-                        Label::new((source.0, span_as_range(array_span)))
-                            .with_message(format!(
-                        "Length of array does not match the specified length (expected {}, got {})",
-                        len,
-                        int_vals.len()
-                    ))
-                            .with_color(Color::Red),
-                    )
-                    .finish()
-                    .eprint(source)
-                    .unwrap();
-                Err(VestError::TypeError)
-            } else {
-                for value in int_vals {
-                    check_const_int_combinator(combinator, value, array_span, source)?;
-                }
-                Ok(())
-            }
-        }
-        ConstArray::Repeat {
-            repeat: int_val,
-            count,
-            span: array_span,
-        } => {
-            if *count != *len {
-                Report::build(ReportKind::Error, (source.0, span_as_range(span)))
-                    .with_message("mismatched array length")
-                    .with_label(
-                        Label::new((source.0, span_as_range(array_span)))
-                            .with_message(format!(
-                        "Length of array does not match the specified length (expected {}, got {})",
-                        len, count
-                    ))
-                            .with_color(Color::Red),
-                    )
-                    .finish()
-                    .eprint(source)
-                    .unwrap();
-                Err(VestError::TypeError)
-            } else {
-                check_const_int_combinator(combinator, int_val, array_span, source)
-            }
-        }
-        ConstArray::Char {
-            span: array_span, ..
-        } => {
-            Report::build(ReportKind::Error, (source.0, span_as_range(span)))
-                .with_message("mismatched array type")
-                .with_label(
-                    Label::new((source.0, span_as_range(array_span)))
-                        .with_message("char array literals should be of type `[u8; N]`")
-                        .with_color(Color::Red),
-                )
-                .finish()
-                .eprint(source)
-                .unwrap();
-            Err(VestError::TypeError)
-        }
-        ConstArray::Wildcard => Ok(()),
-    }
-}
-
 fn check_const_combinator_invocation<'ast>(
     name: &Identifier<'ast>,
     span: Span<'ast>,
@@ -430,18 +606,6 @@ fn check_const_combinator_invocation<'ast>(
     }
 }
 
-fn check_const_choice_combinator<'ast>(
-    const_choices: &[ConstChoice<'ast>],
-    local_ctx: &mut LocalCtx<'ast>,
-    global_ctx: &'ast GlobalCtx<'ast>,
-    source: (&str, &Source),
-) -> Result<(), VestError> {
-    for ConstChoice { combinator, .. } in const_choices {
-        check_const_combinator(combinator, local_ctx, global_ctx, source)?;
-    }
-    Ok(())
-}
-
 fn check_const_enum_combinator<'ast>(
     combinator: &CombinatorInvocation<'ast>,
     variant: &Identifier<'ast>,
@@ -736,7 +900,7 @@ fn check_combinator<'ast>(
     Combinator {
         inner,
         and_then,
-        span,
+        span: _,
     }: &Combinator<'ast>,
     param_defns: &'ast [ParamDefn<'ast>],
     local_ctx: &mut LocalCtx<'ast>,
@@ -791,7 +955,7 @@ fn check_combinator_inner<'ast>(
         ConstraintInt(ConstraintIntCombinator {
             combinator,
             constraint,
-            span,
+            span: _,
         }) => check_constraint_int_combinator(combinator, constraint.as_ref(), source),
         ConstraintEnum(ConstraintEnumCombinator {
             combinator,
@@ -821,7 +985,7 @@ fn check_combinator_inner<'ast>(
             prior,
             combinator,
             post,
-            span,
+            span: _,
         }) => check_wrap_combinator(
             prior,
             combinator,
@@ -848,15 +1012,9 @@ fn check_combinator_inner<'ast>(
             global_ctx,
             source,
         ),
-        SepBy(SepByCombinator { combinator, sep }) => {
-            check_sep_by_combinator(combinator, sep, param_defns, local_ctx, global_ctx, source)
-        }
         Vec(VecCombinator::Vec(combinator)) => {
             check_combinator(combinator, param_defns, local_ctx, global_ctx, source)
         }
-        Vec(VecCombinator::Vec1(combinator)) => {
-            check_combinator(combinator, param_defns, local_ctx, global_ctx, source)
-        }
         Array(ArrayCombinator {
             combinator,
             len,
@@ -874,14 +1032,6 @@ fn check_combinator_inner<'ast>(
             check_bytes_combinator(len, span, param_defns, local_ctx, global_ctx, source)
         }
         Tail(TailCombinator { .. }) => Ok(()),
-        Apply(ApplyCombinator { stream, combinator }) => check_apply_combinator(
-            stream,
-            combinator,
-            param_defns,
-            local_ctx,
-            global_ctx,
-            source,
-        ),
         Option(OptionCombinator(combinator)) => {
             check_combinator(combinator, param_defns, local_ctx, global_ctx, source)
         }
@@ -964,7 +1114,6 @@ fn check_combinator_invocation<'ast>(
 
             for (arg, param_defn) in zip(args, combinator_sig.param_defns) {
                 match (arg, param_defn) {
-                    (Param::Stream(_), ParamDefn::Stream { .. }) => {}
                     (Param::Dependent(depend_id), ParamDefn::Dependent { combinator, .. }) => {
                         fn resolve_up_to_enums<'ast>(
                             comb: CombinatorInner<'ast>,
@@ -1024,11 +1173,9 @@ fn check_combinator_invocation<'ast>(
                             }
                         } else {
                             // 2. try to find `depend_id` in param_defns
-                            let param_defn =
-                                param_defns.iter().find(|param_defn| match param_defn {
-                                    ParamDefn::Dependent { name, .. } => name == depend_id,
-                                    _ => false,
-                                });
+                            let param_defn = param_defns
+                                .iter()
+                                .find(|param_defn| matches!(param_defn, ParamDefn::Dependent { name, .. } if name == depend_id));
                             match param_defn {
                                 Some(ParamDefn::Dependent {
                                     combinator: combinator_,
@@ -1089,7 +1236,6 @@ fn check_combinator_invocation<'ast>(
                             }
                         }
                     }
-                    _ => return Err(VestError::TypeError),
                 }
             }
         }
@@ -1097,148 +1243,364 @@ fn check_combinator_invocation<'ast>(
     Ok(())
 }
 
-fn check_apply_combinator<'ast>(
-    _stream: &Identifier<'ast>,
-    combinator: &Combinator<'ast>,
+fn check_length_expr<'ast>(
+    len: &LengthExpr<'ast>,
+    span: &Span<'ast>,
     param_defns: &'ast [ParamDefn<'ast>],
     local_ctx: &mut LocalCtx<'ast>,
     global_ctx: &'ast GlobalCtx<'ast>,
     source: (&str, &Source),
 ) -> Result<(), VestError> {
-    check_combinator(combinator, param_defns, local_ctx, global_ctx, source)
+    match len {
+        LengthExpr::Const { .. } => Ok(()),
+        LengthExpr::Dependent(depend_id) => check_dependent_id_is_valid_length(
+            depend_id,
+            span,
+            param_defns,
+            local_ctx,
+            global_ctx,
+            source,
+        ),
+        LengthExpr::SizeOf {
+            format_name,
+            span: size_span,
+        } => {
+            if global_ctx.static_sizes.contains_key(&format_name.name) {
+                return Ok(());
+            }
+
+            if let Some(sig) = global_ctx
+                .combinators
+                .iter()
+                .find(|sig| sig.name == *format_name)
+            {
+                Report::build(ReportKind::Error, (source.0, span_as_range(size_span)))
+                    .with_message("format does not have a statically-known size")
+                    .with_label(
+                        Label::new((source.0, span_as_range(size_span)))
+                            .with_message(format!("`{}` depends on runtime values", format_name))
+                            .with_color(Color::Red),
+                    )
+                    .with_label(
+                        Label::new((source.0, span_as_range(&sig.as_span())))
+                            .with_message(format!("`{}` is defined here", format_name))
+                            .with_color(Color::Yellow),
+                    )
+                    .finish()
+                    .eprint(source)
+                    .unwrap();
+                return Err(VestError::TypeError);
+            }
+
+            {
+                Report::build(ReportKind::Error, (source.0, span_as_range(size_span)))
+                    .with_message("undefined format in size expression")
+                    .with_label(
+                        Label::new((source.0, span_as_range(size_span)))
+                            .with_message(format!("`{}` is not defined", format_name))
+                            .with_color(Color::Red),
+                    )
+                    .finish()
+                    .eprint(source)
+                    .unwrap();
+                return Err(VestError::TypeError);
+            }
+        }
+        LengthExpr::BinOp { left, right, .. } => {
+            check_length_expr(left, span, param_defns, local_ctx, global_ctx, source)?;
+            check_length_expr(right, span, param_defns, local_ctx, global_ctx, source)
+        }
+    }
 }
 
-fn check_bytes_combinator<'ast>(
-    len: &LengthSpecifier<'ast>,
+fn check_dependent_id_is_valid_length<'ast>(
+    depend_id: &DependentId<'ast>,
     span: &Span<'ast>,
     param_defns: &'ast [ParamDefn<'ast>],
     local_ctx: &mut LocalCtx<'ast>,
     global_ctx: &'ast GlobalCtx<'ast>,
     source: (&str, &Source),
 ) -> Result<(), VestError> {
-    match len {
-        LengthSpecifier::Const(..) => {
-            // nothing to check
-            Ok(())
-        }
-        LengthSpecifier::Dependent(depend_id) => {
-            // 1. try to find `depend_id` in local_ctx
-            if let Some(combinator) = local_ctx.dependent_fields.get(depend_id) {
-                match global_ctx.resolve(combinator) {
-                    CombinatorInner::ConstraintInt(ConstraintIntCombinator {
-                        combinator:
-                            IntCombinator::Unsigned(_)
-                            | IntCombinator::BtcVarint
-                            | IntCombinator::ULEB128,
-                        ..
-                    }) => Ok(()),
+    // For simple dependent ids (no nested access), check in local_ctx and param_defns
+    if depend_id.is_simple() {
+        let root_id = depend_id.to_identifier();
+
+        // 1. try to find in local_ctx
+        if let Some(combinator) = local_ctx.dependent_fields.get(&root_id) {
+            return check_combinator_is_unsigned_int(
+                global_ctx.resolve(combinator),
+                &depend_id.full_path(),
+                span,
+                &combinator.span,
+                source,
+            );
+        }
+
+        // 2. try to find in param_defns
+        let param_defn = param_defns
+            .iter()
+            .find(|param_defn| matches!(param_defn, ParamDefn::Dependent { name, .. } if name == &root_id));
+
+        match param_defn {
+            Some(ParamDefn::Dependent { combinator, .. }) => {
+                return check_combinator_is_unsigned_int(
+                    global_ctx.resolve_alias(combinator),
+                    &depend_id.full_path(),
+                    span,
+                    &combinator.as_span(),
+                    source,
+                );
+            }
+            _ => {
+                report_unbound_field!(source, span, root_id);
+                return Err(VestError::TypeError);
+            }
+        }
+    }
+
+    // For nested access (@hdr.field), we need to resolve through the struct
+    let root_id = Identifier {
+        name: depend_id.root.clone(),
+        span: depend_id.span,
+    };
+
+    // Find the root field
+    let root_combinator = if let Some(combinator) = local_ctx.dependent_fields.get(&root_id) {
+        global_ctx.resolve(combinator)
+    } else {
+        let param_defn = param_defns
+            .iter()
+            .find(|param_defn| matches!(param_defn, ParamDefn::Dependent { name, .. } if name == &root_id));
+        match param_defn {
+            Some(ParamDefn::Dependent { combinator, .. }) => global_ctx.resolve_alias(combinator),
+            _ => {
+                report_unbound_field!(source, span, root_id);
+                return Err(VestError::TypeError);
+            }
+        }
+    };
+
+    // Navigate through nested fields
+    let mut current_combinator = root_combinator;
+    for (i, field_name) in depend_id.path.iter().enumerate() {
+        match current_combinator {
+            CombinatorInner::Struct(struct_comb) => {
+                let field = struct_comb.fields.iter().find(|f| match f {
+                    StructField::Dependent { label, .. } => label.name == *field_name,
+                    _ => false,
+                });
+                match field {
+                    Some(StructField::Dependent { combinator, .. }) => {
+                        if i == depend_id.path.len() - 1 {
+                            // Final field - check it's an unsigned int
+                            return check_combinator_is_unsigned_int(
+                                global_ctx.resolve(combinator),
+                                &depend_id.full_path(),
+                                span,
+                                &combinator.span,
+                                source,
+                            );
+                        } else {
+                            current_combinator = global_ctx.resolve(combinator);
+                        }
+                    }
                     _ => {
-                        Report::build(
-                            ReportKind::Error,
-                            (source.0, span_as_range(span)),
-                        )
-                        .with_message("invalid length specifier")
+                        Report::build(ReportKind::Error, (source.0, span_as_range(span)))
+                            .with_message("invalid nested field access")
+                            .with_label(
+                                Label::new((source.0, span_as_range(&depend_id.span)))
+                                    .with_message(format!(
+                                        "field `{}` is not a dependent field in the struct",
+                                        field_name
+                                    ))
+                                    .with_color(Color::Red),
+                            )
+                            .finish()
+                            .eprint(source)
+                            .unwrap();
+                        return Err(VestError::TypeError);
+                    }
+                }
+            }
+            CombinatorInner::Invocation(inv) => {
+                // Resolve the invocation and continue
+                let sig = global_ctx
+                    .combinators
+                    .iter()
+                    .find(|sig| sig.name == inv.func);
+                if let Some(sig) = sig {
+                    current_combinator = &sig.resolved_combinator;
+                    // Retry this field with the resolved combinator
+                    return check_nested_field_in_combinator(
+                        current_combinator,
+                        &depend_id.path[i..],
+                        depend_id,
+                        span,
+                        global_ctx,
+                        source,
+                    );
+                } else {
+                    Report::build(ReportKind::Error, (source.0, span_as_range(span)))
+                        .with_message("cannot resolve type for nested access")
                         .with_label(
-                            Label::new((source.0, span_as_range(span)))
-                                .with_message(format!(
-                                    "`@{}` is not a valid length specifier, expected an unsigned int, got {}",
-                                    depend_id, combinator
-                                ))
+                            Label::new((source.0, span_as_range(&depend_id.span)))
+                                .with_message(format!("cannot resolve type of `{}`", inv.func))
                                 .with_color(Color::Red),
                         )
-                        .with_label(
-                            Label::new((source.0, span_as_range(&combinator.span)))
-                                .with_message(format!("Field `@{}` is defined here", depend_id))
-                                .with_color(Color::Yellow),
-                        )
                         .finish()
                         .eprint(source)
                         .unwrap();
-                        Err(VestError::TypeError)
-                    } // panic!("Length specifier must be an unsigned int"),
+                    return Err(VestError::TypeError);
                 }
-            } else {
-                // 2. try to find `depend_id` in param_defns
-                let param_defn = param_defns.iter().find(|param_defn| match param_defn {
-                    ParamDefn::Dependent { name, .. } => name == depend_id,
-                    _ => false,
-                });
-                // .unwrap_or_else(|| {
-                //     panic!("`{}` is not found in current scope", depend_id);
-                // });
-                match param_defn {
-                    Some(ParamDefn::Dependent { combinator, .. }) => {
-                        match global_ctx.resolve_alias(combinator) {
-                            CombinatorInner::ConstraintInt(ConstraintIntCombinator {
-                                combinator:
-                                    IntCombinator::Unsigned(_)
-                                    | IntCombinator::BtcVarint
-                                    | IntCombinator::ULEB128,
-                                ..
-                            }) => Ok(()),
-                            _ => {
-                                Report::build(
-                            ReportKind::Error,
-                            (source.0, span_as_range(span)),
-                        )
-                        .with_message("invalid length specifier")
+            }
+            _ => {
+                Report::build(ReportKind::Error, (source.0, span_as_range(span)))
+                    .with_message("invalid nested field access")
+                    .with_label(
+                        Label::new((source.0, span_as_range(&depend_id.span)))
+                            .with_message("nested field access requires a struct type")
+                            .with_color(Color::Red),
+                    )
+                    .finish()
+                    .eprint(source)
+                    .unwrap();
+                return Err(VestError::TypeError);
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn check_nested_field_in_combinator<'ast>(
+    combinator: &CombinatorInner<'ast>,
+    remaining_path: &[String],
+    depend_id: &DependentId<'ast>,
+    span: &Span<'ast>,
+    global_ctx: &'ast GlobalCtx<'ast>,
+    source: (&str, &Source),
+) -> Result<(), VestError> {
+    if remaining_path.is_empty() {
+        return check_combinator_is_unsigned_int(
+            combinator,
+            &depend_id.full_path(),
+            span,
+            &depend_id.span,
+            source,
+        );
+    }
+
+    match combinator {
+        CombinatorInner::Struct(struct_comb) => {
+            let field_name = &remaining_path[0];
+            let field = struct_comb.fields.iter().find(|f| match f {
+                StructField::Dependent { label, .. } => label.name == *field_name,
+                _ => false,
+            });
+            match field {
+                Some(StructField::Dependent { combinator, .. }) => {
+                    check_nested_field_in_combinator(
+                        global_ctx.resolve(combinator),
+                        &remaining_path[1..],
+                        depend_id,
+                        span,
+                        global_ctx,
+                        source,
+                    )
+                }
+                _ => {
+                    Report::build(ReportKind::Error, (source.0, span_as_range(span)))
+                        .with_message("invalid nested field access")
                         .with_label(
-                            Label::new((source.0, span_as_range(span)))
+                            Label::new((source.0, span_as_range(&depend_id.span)))
                                 .with_message(format!(
-                                    "`@{}` is not a valid length specifier, expected an unsigned int, got {}",
-                                    depend_id, combinator
+                                    "field `{}` is not a dependent field",
+                                    field_name
                                 ))
                                 .with_color(Color::Red),
                         )
-                        .with_label(
-                            Label::new((source.0, span_as_range(&combinator.as_span())))
-                                .with_message(format!("Parameter `@{}` is defined here", depend_id))
-                                .with_color(Color::Yellow),
-                        )
                         .finish()
                         .eprint(source)
                         .unwrap();
-                                Err(VestError::TypeError)
-                            } // panic!("Length specifier must be an unsigned int"),
-                        }
-                    }
-                    _ => {
-                        report_unbound_field!(source, span, depend_id);
-                        Err(VestError::TypeError)
-                    }
+                    Err(VestError::TypeError)
                 }
             }
         }
+        _ => {
+            Report::build(ReportKind::Error, (source.0, span_as_range(span)))
+                .with_message("invalid nested field access")
+                .with_label(
+                    Label::new((source.0, span_as_range(&depend_id.span)))
+                        .with_message("nested field access requires a struct type")
+                        .with_color(Color::Red),
+                )
+                .finish()
+                .eprint(source)
+                .unwrap();
+            Err(VestError::TypeError)
+        }
     }
 }
 
-fn check_array_combinator<'ast>(
-    combinator: &Combinator<'ast>,
-    len: &LengthSpecifier<'ast>,
+fn check_combinator_is_unsigned_int(
+    combinator: &CombinatorInner,
+    field_path: &str,
+    span: &Span,
+    def_span: &Span,
+    source: (&str, &Source),
+) -> Result<(), VestError> {
+    match combinator {
+        CombinatorInner::ConstraintInt(ConstraintIntCombinator {
+            combinator:
+                IntCombinator::Unsigned(_) | IntCombinator::BtcVarint | IntCombinator::ULEB128,
+            ..
+        }) => Ok(()),
+        _ => {
+            Report::build(ReportKind::Error, (source.0, span_as_range(span)))
+                .with_message("invalid length specifier")
+                .with_label(
+                    Label::new((source.0, span_as_range(span)))
+                        .with_message(format!(
+                            "`@{}` is not a valid length specifier, expected an unsigned int",
+                            field_path
+                        ))
+                        .with_color(Color::Red),
+                )
+                .with_label(
+                    Label::new((source.0, span_as_range(def_span)))
+                        .with_message(format!("Field `@{}` is defined here", field_path))
+                        .with_color(Color::Yellow),
+                )
+                .finish()
+                .eprint(source)
+                .unwrap();
+            Err(VestError::TypeError)
+        }
+    }
+}
+
+fn check_bytes_combinator<'ast>(
+    len: &LengthExpr<'ast>,
     span: &Span<'ast>,
     param_defns: &'ast [ParamDefn<'ast>],
     local_ctx: &mut LocalCtx<'ast>,
     global_ctx: &'ast GlobalCtx<'ast>,
     source: (&str, &Source),
 ) -> Result<(), VestError> {
-    check_combinator(combinator, param_defns, local_ctx, global_ctx, source)?;
-    check_bytes_combinator(len, span, param_defns, local_ctx, global_ctx, source)
+    check_length_expr(len, span, param_defns, local_ctx, global_ctx, source)
 }
 
-fn check_sep_by_combinator<'ast>(
-    combinator: &VecCombinator<'ast>,
-    sep: &ConstCombinator<'ast>,
+fn check_array_combinator<'ast>(
+    combinator: &Combinator<'ast>,
+    len: &LengthSpecifier<'ast>,
+    span: &Span<'ast>,
     param_defns: &'ast [ParamDefn<'ast>],
     local_ctx: &mut LocalCtx<'ast>,
     global_ctx: &'ast GlobalCtx<'ast>,
     source: (&str, &Source),
 ) -> Result<(), VestError> {
-    match combinator {
-        VecCombinator::Vec(combinator) | VecCombinator::Vec1(combinator) => {
-            check_combinator(combinator, param_defns, local_ctx, global_ctx, source)?;
-        }
-    }
-    check_const_combinator(sep, local_ctx, global_ctx, source)
+    check_combinator(combinator, param_defns, local_ctx, global_ctx, source)?;
+    check_bytes_combinator(len, span, param_defns, local_ctx, global_ctx, source)
 }
 
 impl<'ast> Choices<'ast> {
@@ -1377,8 +1739,8 @@ fn check_choice_combinator<'ast>(
                 // check if `combinator` is defined as an enum
                 if let Some(enum_) = resolve_enum_from(combinator, global_ctx) {
                     let (enum_variants, is_non_exhaustive) = match enum_ {
-                        EnumCombinator::Exhaustive { enums, span } => (enums, false),
-                        EnumCombinator::NonExhaustive { enums, span } => (enums, true),
+                        EnumCombinator::Exhaustive { enums, .. } => (enums, false),
+                        EnumCombinator::NonExhaustive { enums, .. } => (enums, true),
                     };
                     // check for well-formed variants
                     let mut variants = HashSet::new();
@@ -1640,7 +2002,7 @@ fn check_choice_combinator<'ast>(
                 } else if let Some(enum_) = resolve_enum_from(combinator, global_ctx) {
                     // check if it's non-exhaustive enum (which is equivalent to an int choice)
                     match enum_ {
-                        EnumCombinator::NonExhaustive { enums, span } => {
+                        EnumCombinator::NonExhaustive { enums, .. } => {
                             let int_combinator = resolve_enum_type(enums);
                             let mut patterns = Vec::new();
                             for (pattern, combinator) in ints {
@@ -1741,7 +2103,7 @@ fn check_choice_combinator<'ast>(
                     span: array_span,
                 }) = combinator
                 {
-                    let LengthSpecifier::Const(len) = len.clone() else {
+                    let Some(len) = eval_const_length_expr(len, &global_ctx.static_sizes) else {
                         Report::build(ReportKind::Error, (source.0, span_as_range(span)))
                             .with_message("invalid array type")
                             .with_label(
@@ -2018,7 +2380,6 @@ fn check_struct_combinator<'ast>(
     }
     for field in struct_fields {
         match field {
-            StructField::Stream(_) => {}
             StructField::Dependent {
                 label,
                 combinator,
@@ -2071,7 +2432,7 @@ fn check_constraint_int_combinator(
     source: (&str, &Source),
 ) -> Result<(), VestError> {
     match constraint {
-        Some(IntConstraint::Single { elem, span }) => {
+        Some(IntConstraint::Single { elem, span: _ }) => {
             check_constraint_elem(combinator, elem, source)?;
         }
         Some(IntConstraint::Set(constraints)) => {
@@ -2159,7 +2520,7 @@ fn check_enum_constraint<'ast>(
             enums
         }
     };
-    let mut report_missing_variant = |ident: &Identifier<'ast>| {
+    let report_missing_variant = |ident: &Identifier<'ast>| {
         Report::build(ReportKind::Error, (source.0, span_as_range(span)))
             .with_message("undefined enum variant in constraint")
             .with_label(
diff --git a/vest-dsl/src/utils.rs b/vest-dsl/src/utils.rs
index 08f63c23..16109a49 100644
--- a/vest-dsl/src/utils.rs
+++ b/vest-dsl/src/utils.rs
@@ -1,7 +1,6 @@
 use std::collections::{HashMap, HashSet};
-use std::hash::Hash;
 use std::hash::DefaultHasher;
-use std::hash::BuildHasher;
+use std::hash::Hash;
 
 #[derive(Default, Clone)]
 pub struct VestHasherBuilder;
@@ -19,7 +18,9 @@ pub enum TopoSortError<E> {
     CycleDetected(E),
 }
 
-pub fn topological_sort<K, V>(graph: &HashMap<K, V, VestHasherBuilder>) -> Result<Vec<K>, TopoSortError<K>>
+pub fn topological_sort<K, V>(
+    graph: &HashMap<K, V, VestHasherBuilder>,
+) -> Result<Vec<K>, TopoSortError<K>>
 where
     K: Eq + Hash + Clone,
     V: AsRef<[K]>,
@@ -81,21 +82,19 @@ mod tests {
 
     #[test]
     fn test_topological_sort() {
-        let mut graph = HashMap::new();
+        let mut graph = HashMap::with_hasher(VestHasherBuilder);
         graph.insert("A", vec!["B", "C"]);
         graph.insert("B", vec!["C"]);
         graph.insert("C", vec!["D"]);
         graph.insert("D", vec!["A"]);
 
-        assert_eq!(
-            topological_sort(&graph),
-            Err(TopoSortError::CycleDetected("A"))
-        );
+        // Cycle exists; the specific node detected depends on traversal order
+        assert!(topological_sort(&graph).is_err());
     }
 
     #[test]
     fn test_topological_sort_2() {
-        let mut graph = HashMap::new();
+        let mut graph = HashMap::with_hasher(VestHasherBuilder);
         graph.insert("D", vec![]);
         graph.insert("B", vec!["C"]);
         graph.insert("C", vec!["D"]);
@@ -111,7 +110,7 @@ mod tests {
 
     #[test]
     fn test_topological_sort_3() {
-        let mut graph = HashMap::new();
+        let mut graph = HashMap::with_hasher(VestHasherBuilder);
         graph.insert("A", vec!["B", "C"]);
         graph.insert("B", vec!["C"]);
         graph.insert("C", vec!["D"]);
diff --git a/vest-dsl/src/vest.pest b/vest-dsl/src/vest.pest
index bd023b47..d059a280 100644
--- a/vest-dsl/src/vest.pest
+++ b/vest-dsl/src/vest.pest
@@ -4,15 +4,15 @@ grammar = _{ SOI ~ definition+ ~ EOI }
 
 definition = { combinator_defn | const_combinator_defn | endianess_defn | macro_defn }
 
-combinator_defn = { secret? ~ var_id ~ param_defn_list? ~ "=" ~ combinator }
+combinator_defn = { var_id ~ param_defn_list? ~ "=" ~ combinator }
 param_defn_list = { "(" ~ param_defn ~ ("," ~ param_defn)* ~ ")" }
-param_defn      = { stream_id | depend_id ~ ":" ~ combinator_inner }
+param_defn      = { depend_id ~ ":" ~ combinator_inner }
 
 const_combinator_defn = { constant ~ const_id ~ ":" ~ const_combinator }
 
-endianess_defn = { ("!LITTLE_ENDIAN" | "!BIG_ENDIAN") }
+endianess_defn = { "!LITTLE_ENDIAN" | "!BIG_ENDIAN" }
 
-macro_defn       = { "macro" ~ var_id ~ "!" ~ "(" ~ macro_param_list ~ ")" ~ "=" ~ combinator }
+macro_defn       = { "macro" ~ var_id ~ "!" ~ "(" ~ macro_param_list? ~ ")" ~ "=" ~ combinator }
 macro_param_list = { var_id ~ ("," ~ var_id)* }
 
 combinator       = { ("(" ~ combinator_inner ~ ")" | combinator_inner) ~ (">>=" ~ combinator)? }
@@ -24,18 +24,17 @@ combinator_inner = {
   | wrap_combinator
   | enum_combinator
   | choice_combinator
-  | sepby_combinator
   | vec_combinator
   | tail_combinator
   | array_combinator
-  | apply_combinator
   | option_combinator
   | combinator_invocation
 }
 
 /// an integer combinator with an optional set of constraints
 constraint_int_combinator =  { int_combinator ~ ("|" ~ int_constraint)? }
-int_combinator            = ${ ((unsigned | signed) ~ decimal) | btc_varint | uleb128 }
+int_combinator            = ${ ((unsigned | signed) ~ int_width) | btc_varint | uleb128 }
+int_width                 = @{ "8" | "16" | "24" | "32" | "64" }
 int_constraint            =  { constraint_elem | constraint_elem_set | "!" ~ int_constraint }
 constraint_elem_set       =  { "{" ~ constraint_elem ~ ("," ~ constraint_elem)* ~ "}" }
 constraint_elem           =  { const_int_range | const_int }
@@ -43,47 +42,65 @@ const_int_range           =  { const_int? ~ ".." ~ const_int? }
 const_int                 = ${ hex | decimal | ascii }
 
 /// an enum combinator with an optional set of constraints
-constraint_enum_combinator = { combinator_invocation ~ ("|" ~ enum_constraint) }
+constraint_enum_combinator = { combinator_invocation ~ "|" ~ enum_constraint }
 enum_constraint            = { enum_constraint_elem | enum_constraint_set | "!" ~ enum_constraint }
 enum_constraint_set        = { "{" ~ enum_constraint_elem ~ ("," ~ enum_constraint_elem)* ~ "}" }
-enum_constraint_elem       =  { variant_id }
+enum_constraint_elem       = { variant_id }
 
 /// sequence of `combinator` with semantic labels
 struct_combinator = { "{" ~ (field ~ ",")* ~ "}" }
 field             = {
-    stream_transform
-  | constant ~ var_id ~ ":" ~ const_combinator
+    constant ~ var_id ~ ":" ~ const_combinator
   | depend_id ~ ":" ~ combinator
   | var_id ~ ":" ~ combinator
 }
-stream_transform  = { (let ~ stream_ids ~ "=")? ~ var_id ~ param_list }
-stream_ids        = { stream_id ~ ("," ~ stream_id)* }
 
-/// wrap a `combinator` with any number of `const_combinator`
-wrap_combinator = { wrap ~ "(" ~ wrap_prior ~ combinator ~ wrap_post ~ ")" }
-wrap_prior      = { (const_combinator ~ ",")* }
-wrap_post       = { ("," ~ const_combinator)* }
+/// wrap a `combinator` with any number of inline const combinators
+wrap_combinator         = { wrap ~ "(" ~ wrap_prior ~ combinator ~ wrap_post ~ ")" }
+wrap_prior              = { (inline_const_combinator ~ ",")* }
+wrap_post               = { ("," ~ inline_const_combinator)* }
+inline_const_combinator = {
+    const_bytes_combinator
+  | const_int_combinator
+  | const_enum_combinator
+}
 
 /// enum `combinator` for primitive types
-// enum_combinator = { enum ~ "{" ~ enum_field+ ~ non_exhaustive_marker? ~ "}" }
-enum_combinator       =  { enum ~ "{" ~ (non_exhaustive_enum | exhaustive_enum) ~ "}" }
-exhaustive_enum       =  { enum_field+ }
-non_exhaustive_enum   =  { enum_field+ ~ non_exhaustive_marker }
-enum_field            =  { variant_id ~ "=" ~ typed_const_int ~ "," }
-non_exhaustive_marker = _{ "..." }
+enum_combinator       = { enum ~ "{" ~ (non_exhaustive_enum | exhaustive_enum) ~ "}" }
+exhaustive_enum       = { enum_field+ }
+non_exhaustive_enum   = { enum_field+ ~ non_exhaustive_marker }
+enum_field            = { variant_id ~ "=" ~ typed_const_int ~ "," }
+non_exhaustive_marker = { "..." }
 
 /// ordered choice `combinator`
 choice_combinator = { choose ~ ("(" ~ depend_id ~ ")")? ~ "{" ~ choice+ ~ "}" }
 choice            = { (variant_id | constraint_elem | const_array) ~ "=>"? ~ combinator ~ "," }
 
-/// vec of `combinator` (`Vec` for zero or more and `Vec1` for one or more)
-vec_combinator = { (vec1 | vec) ~ "<" ~ combinator ~ ">" }
+/// vec of `combinator`
+vec_combinator = { vec ~ "<" ~ combinator ~ ">" }
+
+/// fixed size array of `combinator` with length expression
+/// supports: const_int, depend_id, |format| (static size), and arithmetic (+, -, *, /)
+array_combinator = { "[" ~ combinator ~ ";" ~ length_expr ~ "]" }
+
+/// length expression with arithmetic operators (left-associative)
+length_expr = { length_term ~ ((add_op | sub_op) ~ length_term)* }
+length_term = { length_atom ~ ((mul_op | div_op) ~ length_atom)* }
+length_atom = {
+    size_expr
+  | const_int
+  | depend_id
+  | "(" ~ length_expr ~ ")"
+}
 
-/// like `vec_combinator` but with a separator
-sepby_combinator = { vec_combinator ~ "|" ~ const_combinator }
+/// static size expression: |type_name| returns byte size of a format
+size_expr   =  { "|" ~ size_target ~ "|" }
+size_target = @{ identifier | ((unsigned | signed) ~ int_width) | btc_varint | uleb128 }
 
-/// fixed size array of `combinator` (specified by a `const_int` or `dependency_id`)
-array_combinator = { "[" ~ combinator ~ ";" ~ (const_int | depend_id) ~ "]" }
+add_op = { "+" }
+sub_op = { "-" }
+mul_op = { "*" }
+div_op = { "/" }
 
 /// an optional `combinator`
 option_combinator = { option ~ "<" ~ combinator ~ ">" }
@@ -91,29 +108,17 @@ option_combinator = { option ~ "<" ~ combinator ~ ">" }
 /// tail combinator that consumes the rest of the input
 tail_combinator = { tail }
 
-/// apply a `stream_id` to a `combinator`
-apply_combinator = { apply ~ "(" ~ stream_id ~ "," ~ combinator ~ ")" }
-
 /// invoke a `combinator` with optional `param_list`
 combinator_invocation = { var_id ~ param_list? }
 param_list            = { "(" ~ param ~ ("," ~ param)* ~ ")" }
-param                 = { stream_id | depend_id }
+param                 = { depend_id }
 
 /// invoke a `macro` with `macro_param_list`
 macro_invocation = { var_id ~ "!" ~ "(" ~ macro_arg_list ~ ")" }
 macro_arg_list   = { combinator_inner ~ ("," ~ combinator_inner)* }
 
-const_combinator = {
-    vec ~ "<" ~ const_combinator ~ ">"
-  | const_array_combinator
-  | const_int_combinator
-  | const_enum_combinator
-  | const_id
-  | const_struct_combinator
-  | const_choice_combinator
-}
-
-const_array_combinator =  { "[" ~ int_combinator ~ ";" ~ const_int ~ "]" ~ "=" ~ const_array }
+const_combinator       =  { inline_const_combinator | const_id }
+const_bytes_combinator =  { "[" ~ "u8" ~ ";" ~ const_int ~ "]" ~ "=" ~ const_array }
 const_array            =  { const_char_array | const_int_array }
 const_char_array       = ${ "\"" ~ (!"\"" ~ char)* ~ "\"" }
 const_int_array        =  { int_array_expr | repeat_int_array_expr }
@@ -124,40 +129,47 @@ const_int_combinator = { int_combinator ~ "=" ~ const_int }
 
 const_enum_combinator = { combinator_invocation ~ "=" ~ variant_id }
 
-const_struct_combinator =  { "{" ~ const_fields ~ "}" }
-const_fields            = _{ (const_combinator ~ ",")+ }
-
-const_choice_combinator = { choose ~ "{" ~ const_choice* ~ "}" }
-const_choice            = { variant_id ~ "(" ~ const_combinator ~ ")" ~ "," }
-
 /// integer literal with optional type suffix, e.g. 0u8, 0x1111u16
-typed_const_int   = ${ const_int ~ int_type_suffix? }
-int_type_suffix   = @{ ("u" | "i") ~ ("8" | "16" | "24" | "32" | "64") }
+typed_const_int = ${ const_int ~ int_type_suffix? }
+int_type_suffix = @{ ("u" | "i") ~ int_width }
 
 /// decimal literal, e.g. 15213
 decimal = @{ ASCII_DIGIT+ }
 
-/// hexidecimal literal, e.g. 0x3F, 0x5a
+/// hexadecimal literal, e.g. 0x3F, 0x5a
 hex = @{ "0x" ~ ASCII_HEX_DIGIT+ }
 
 /// ascii literal (a subset of unicode from 0 to 255), e.g '\x00', '\x1b', 'a'
 ascii = ${ "'" ~ ("\\x" ~ ASCII_HEX_DIGIT{2} | char) ~ "'" }
 char  =  { '\u{00}'..'\u{FF}' }
 
-var_id     = @{ ASCII_ALPHA_LOWER ~ (ASCII_DIGIT | ASCII_ALPHA_LOWER | "_")* }
-const_id   = @{ ASCII_ALPHA_UPPER ~ (ASCII_DIGIT | ASCII_ALPHA_UPPER | "_")* }
-variant_id = @{ (ASCII_ALPHA_UPPER ~ (ASCII_DIGIT | ASCII_ALPHA | "_")*) | "_" }
-stream_id  = @{ "$" ~ ASCII_ALPHA_LOWER ~ (ASCII_DIGIT | ASCII_ALPHA_LOWER | "_")* }
-depend_id  = @{ "@" ~ ASCII_ALPHA_LOWER ~ (ASCII_DIGIT | ASCII_ALPHA_LOWER | "_")* }
+ident_start    = _{ ASCII_ALPHA | "_" }
+ident_continue = _{ ASCII_ALPHANUMERIC | "_" }
+reserved_word  = _{
+    "macro"
+  | "const"
+  | "enum"
+  | "choose"
+  | "wrap"
+  | "Option"
+  | "Vec"
+  | "Tail"
+  | btc_varint
+  | uleb128
+  | ((unsigned | signed) ~ int_width)
+}
+identifier     =  { !(reserved_word ~ !ident_continue) ~ ident_start ~ ident_continue* }
+
+var_id     = @{ identifier }
+const_id   = @{ identifier }
+variant_id = @{ "_" | identifier }
+depend_id  = @{ "@" ~ identifier ~ ("." ~ identifier)* }
 
 // keywords
 
-secret     =  { "secret" }
 wrap       = _{ "wrap" }
 enum       = _{ "enum" }
 choose     = _{ "choose" }
-apply      = _{ "apply" }
-let        = _{ "let" }
 constant   =  { "const" }
 signed     =  { "i" }
 unsigned   =  { "u" }
@@ -165,7 +177,6 @@ btc_varint =  { "btc_varint" }
 uleb128    =  { "uleb128" }
 option     = _{ "Option" }
 vec        =  { "Vec" }
-vec1       =  { "Vec1" }
 tail       =  { "Tail" }
 
 WHITESPACE = _{ " " | "\t" | "\r" | "\n" | "\r\n" }
diff --git a/vest-dsl/src/vestir.rs b/vest-dsl/src/vestir.rs
index 265f20f5..07aaba5f 100644
--- a/vest-dsl/src/vestir.rs
+++ b/vest-dsl/src/vestir.rs
@@ -1,3 +1,4 @@
+use crate::ast;
 use itertools::Itertools;
 use std::{
     collections::{HashMap, HashSet},
@@ -46,12 +47,10 @@ pub enum CombinatorInner {
     Wrap(WrapCombinator),
     Enum(EnumCombinator),
     Choice(ChoiceCombinator),
-    SepBy(SepByCombinator),
     Vec(VecCombinator),
     Array(ArrayCombinator),
     Bytes(BytesCombinator),
     Tail(TailCombinator),
-    Apply(ApplyCombinator),
     Option(OptionCombinator),
     Invocation(CombinatorInvocation),
 }
@@ -120,7 +119,6 @@ pub enum StructField {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Param {
-    Stream(String),
     Dependent(String),
 }
 
@@ -165,25 +163,45 @@ pub enum Choices {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum VecCombinator {
     Vec(Box<Combinator>),
-    Vec1(Box<Combinator>),
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SepByCombinator {
-    pub combinator: VecCombinator,
-    pub sep: ConstCombinator,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ArrayCombinator {
     pub combinator: Box<Combinator>,
-    pub len: LengthSpecifier,
+    pub len: LengthExpr,
 }
 
+/// Arithmetic operators for length expressions
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ArithOp {
+    Add,
+    Sub,
+    Mul,
+    Div,
+}
+
+impl From<ast::ArithOp> for ArithOp {
+    fn from(op: ast::ArithOp) -> Self {
+        match op {
+            ast::ArithOp::Add => ArithOp::Add,
+            ast::ArithOp::Sub => ArithOp::Sub,
+            ast::ArithOp::Mul => ArithOp::Mul,
+            ast::ArithOp::Div => ArithOp::Div,
+        }
+    }
+}
+
+/// Length expression for array sizes
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum LengthSpecifier {
+pub enum LengthExpr {
     Const(usize),
     Dependent(String),
+    SizeOf(String),
+    BinOp {
+        op: ArithOp,
+        left: Box<LengthExpr>,
+        right: Box<LengthExpr>,
+    },
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -191,18 +209,12 @@ pub struct OptionCombinator(pub Box<Combinator>);
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BytesCombinator {
-    pub len: LengthSpecifier,
+    pub len: LengthExpr,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TailCombinator;
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ApplyCombinator {
-    pub stream: String,
-    pub combinator: Box<Combinator>,
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CombinatorInvocation {
     pub func: String,
@@ -211,23 +223,12 @@ pub struct CombinatorInvocation {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ConstCombinator {
-    Vec(Box<ConstCombinator>),
-    ConstArray(ConstArrayCombinator),
     ConstBytes(ConstBytesCombinator),
     ConstInt(ConstIntCombinator),
     ConstEnum(ConstEnumCombinator),
-    ConstStruct(ConstStructCombinator),
-    ConstChoice(ConstChoiceCombinator),
     ConstCombinatorInvocation(String),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstArrayCombinator {
-    pub combinator: IntCombinator,
-    pub len: usize,
-    pub values: ConstArray,
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ConstBytesCombinator {
     pub len: usize,
@@ -254,17 +255,6 @@ pub struct ConstIntCombinator {
     pub value: i128,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstStructCombinator(pub Vec<ConstCombinator>);
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstChoiceCombinator(pub Vec<ConstChoice>);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstChoice {
-    pub tag: String,
-    pub combinator: ConstCombinator,
-}
-
 impl Display for Definition {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -320,12 +310,10 @@ impl Display for CombinatorInner {
             CombinatorInner::Wrap(w) => write!(f, "{}", w),
             CombinatorInner::Enum(e) => write!(f, "{}", e),
             CombinatorInner::Choice(c) => write!(f, "{}", c),
-            CombinatorInner::SepBy(s) => write!(f, "{}", s),
             CombinatorInner::Vec(v) => write!(f, "{}", v),
             CombinatorInner::Array(a) => write!(f, "{}", a),
             CombinatorInner::Bytes(a) => write!(f, "{}", a),
             CombinatorInner::Tail(t) => write!(f, "{}", t),
-            CombinatorInner::Apply(a) => write!(f, "{}", a),
             CombinatorInner::Option(o) => write!(f, "{}", o),
             CombinatorInner::Invocation(i) => write!(f, "{}", i),
         }
@@ -433,24 +421,14 @@ impl Display for StructField {
 impl Display for ConstCombinator {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ConstCombinator::Vec(v) => write!(f, "{}", v),
-            ConstCombinator::ConstArray(a) => write!(f, "{}", a),
             ConstCombinator::ConstBytes(b) => write!(f, "{}", b),
             ConstCombinator::ConstInt(i) => write!(f, "{}", i),
             ConstCombinator::ConstEnum(e) => write!(f, "{}", e),
-            ConstCombinator::ConstStruct(s) => write!(f, "{}", s),
-            ConstCombinator::ConstChoice(c) => write!(f, "{}", c),
             ConstCombinator::ConstCombinatorInvocation(i) => write!(f, "{}", i),
         }
     }
 }
 
-impl Display for ConstArrayCombinator {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "[{}]", self.values)
-    }
-}
-
 impl Display for ConstBytesCombinator {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.values)
@@ -495,36 +473,9 @@ impl Display for ConstIntCombinator {
     }
 }
 
-impl Display for ConstStructCombinator {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{{")?;
-        for combinator in &self.0 {
-            write!(f, "{}", combinator)?;
-        }
-        write!(f, "}}")
-    }
-}
-
-impl Display for ConstChoiceCombinator {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{{")?;
-        for choice in &self.0 {
-            write!(f, "{}", choice)?;
-        }
-        write!(f, "}}")
-    }
-}
-
-impl Display for ConstChoice {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}:{}", self.tag, self.combinator)
-    }
-}
-
 impl Display for Param {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Param::Stream(s) => write!(f, "${}", s),
             Param::Dependent(s) => write!(f, "{}", s),
         }
     }
@@ -608,17 +559,10 @@ impl Display for Choices {
     }
 }
 
-impl Display for SepByCombinator {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}_sepby_{}", self.combinator, self.sep)
-    }
-}
-
 impl Display for VecCombinator {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             VecCombinator::Vec(v) => write!(f, "{}*", v),
-            VecCombinator::Vec1(v) => write!(f, "{}+", v),
         }
     }
 }
@@ -629,11 +573,21 @@ impl Display for ArrayCombinator {
     }
 }
 
-impl Display for LengthSpecifier {
+impl Display for LengthExpr {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            LengthSpecifier::Const(n) => write!(f, "{}", n),
-            LengthSpecifier::Dependent(s) => write!(f, "{}", s),
+            LengthExpr::Const(n) => write!(f, "{}", n),
+            LengthExpr::Dependent(s) => write!(f, "@{}", s),
+            LengthExpr::SizeOf(name) => write!(f, "|{}|", name),
+            LengthExpr::BinOp { op, left, right } => {
+                let op_str = match op {
+                    ArithOp::Add => "+",
+                    ArithOp::Sub => "-",
+                    ArithOp::Mul => "*",
+                    ArithOp::Div => "/",
+                };
+                write!(f, "({} {} {})", left, op_str, right)
+            }
         }
     }
 }
@@ -656,12 +610,6 @@ impl Display for OptionCombinator {
     }
 }
 
-impl Display for ApplyCombinator {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}({})", self.stream, self.combinator)
-    }
-}
-
 impl Display for CombinatorInvocation {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if self.args.is_empty() {
@@ -677,6 +625,7 @@ pub struct GlobalCtx {
     pub combinators: HashSet<CombinatorSig>,
     pub const_combinators: HashSet<ConstCombinatorSig>,
     pub enums: HashMap<String, EnumCombinator>,
+    pub static_sizes: HashMap<String, usize>,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
@@ -766,9 +715,6 @@ pub mod lowering {
                     const_combinator: const_combinator.into(),
                 },
                 ast::Definition::Endianess(e) => ir::Definition::Endianess(e.into()),
-                ast::Definition::SecCombinator { .. } => {
-                    unimplemented!("Secret format is not supported by VestDSL yet")
-                }
                 ast::Definition::MacroDefn { .. } => unreachable!(
                     "Macro definitions should have been expanded before lowering to IR"
                 ),
@@ -789,9 +735,6 @@ pub mod lowering {
     impl<'i> From<ast::ParamDefn<'i>> for ir::ParamDefn {
         fn from(p: ast::ParamDefn<'i>) -> Self {
             match p {
-                ast::ParamDefn::Stream { .. } => {
-                    unimplemented!("Stream transformations are not supported by VestDSL yet")
-                }
                 ast::ParamDefn::Dependent {
                     name, combinator, ..
                 } => ir::ParamDefn::Dependent {
@@ -805,7 +748,6 @@ pub mod lowering {
     impl<'i> From<ast::Param<'i>> for ir::Param {
         fn from(p: ast::Param<'i>) -> Self {
             match p {
-                ast::Param::Stream(i) => ir::Param::Stream(id(i)),
                 ast::Param::Dependent(i) => ir::Param::Dependent(id(i)),
             }
         }
@@ -832,12 +774,10 @@ pub mod lowering {
                 A::Wrap(x) => B::Wrap(x.into()),
                 A::Enum(x) => B::Enum(x.into()),
                 A::Choice(x) => B::Choice(x.into()),
-                A::SepBy(x) => B::SepBy(x.into()),
                 A::Vec(x) => B::Vec(x.into()),
                 A::Array(x) => B::Array(x.into()),
                 A::Bytes(x) => B::Bytes(x.into()),
                 A::Tail(_x) => B::Tail(ir::TailCombinator),
-                A::Apply(x) => B::Apply(x.into()),
                 A::Option(x) => B::Option(ir::OptionCombinator(Box::new((*x.0).clone().into()))),
                 A::Invocation(x) => B::Invocation(x.into()),
                 A::MacroInvocation { .. } => unreachable!(
@@ -922,9 +862,6 @@ pub mod lowering {
     impl<'i> From<ast::StructField<'i>> for ir::StructField {
         fn from(f: ast::StructField<'i>) -> Self {
             match f {
-                ast::StructField::Stream(..) => {
-                    unimplemented!("Stream transformations are not supported by VestDSL yet")
-                }
                 ast::StructField::Dependent {
                     label, combinator, ..
                 } => ir::StructField::Dependent {
@@ -1013,26 +950,16 @@ pub mod lowering {
         }
     }
 
-    // ---------- Vec / SepBy ----------
+    // ---------- Vec ----------
     impl<'i> From<ast::VecCombinator<'i>> for ir::VecCombinator {
         fn from(v: ast::VecCombinator<'i>) -> Self {
             match v {
                 ast::VecCombinator::Vec(b) => ir::VecCombinator::Vec(Box::new((*b).into())),
-                ast::VecCombinator::Vec1(b) => ir::VecCombinator::Vec1(Box::new((*b).into())),
             }
         }
     }
 
-    impl<'i> From<ast::SepByCombinator<'i>> for ir::SepByCombinator {
-        fn from(s: ast::SepByCombinator<'i>) -> Self {
-            ir::SepByCombinator {
-                combinator: s.combinator.into(),
-                sep: s.sep.into(),
-            }
-        }
-    }
-
-    // ---------- Array / Bytes / Tail / Apply / Option ----------
+    // ---------- Array / Bytes / Tail / Option ----------
     impl<'i> From<ast::ArrayCombinator<'i>> for ir::ArrayCombinator {
         fn from(a: ast::ArrayCombinator<'i>) -> Self {
             ir::ArrayCombinator {
@@ -1042,11 +969,21 @@ pub mod lowering {
         }
     }
 
-    impl<'i> From<ast::LengthSpecifier<'i>> for ir::LengthSpecifier {
-        fn from(l: ast::LengthSpecifier<'i>) -> Self {
+    impl<'i> From<ast::LengthExpr<'i>> for ir::LengthExpr {
+        fn from(l: ast::LengthExpr<'i>) -> Self {
             match l {
-                ast::LengthSpecifier::Const(n) => ir::LengthSpecifier::Const(n),
-                ast::LengthSpecifier::Dependent(i) => ir::LengthSpecifier::Dependent(id(i)),
+                ast::LengthExpr::Const { value, .. } => ir::LengthExpr::Const(value),
+                ast::LengthExpr::Dependent(d) => ir::LengthExpr::Dependent(d.full_path()),
+                ast::LengthExpr::SizeOf { format_name, .. } => {
+                    ir::LengthExpr::SizeOf(format_name.name)
+                }
+                ast::LengthExpr::BinOp {
+                    op, left, right, ..
+                } => ir::LengthExpr::BinOp {
+                    op: op.into(),
+                    left: Box::new((*left).into()),
+                    right: Box::new((*right).into()),
+                },
             }
         }
     }
@@ -1063,15 +1000,6 @@ pub mod lowering {
         }
     }
 
-    impl<'i> From<ast::ApplyCombinator<'i>> for ir::ApplyCombinator {
-        fn from(a: ast::ApplyCombinator<'i>) -> Self {
-            ir::ApplyCombinator {
-                stream: id(a.stream),
-                combinator: Box::new((*a.combinator).into()),
-            }
-        }
-    }
-
     impl<'i> From<ast::OptionCombinator<'i>> for ir::OptionCombinator {
         fn from(o: ast::OptionCombinator<'i>) -> Self {
             ir::OptionCombinator(Box::new((*o.0).into()))
@@ -1091,13 +1019,9 @@ pub mod lowering {
     impl<'i> From<ast::ConstCombinator<'i>> for ir::ConstCombinator {
         fn from(c: ast::ConstCombinator<'i>) -> Self {
             match c {
-                ast::ConstCombinator::Vec(b) => ir::ConstCombinator::Vec(Box::new((*b).into())),
-                ast::ConstCombinator::ConstArray(x) => ir::ConstCombinator::ConstArray(x.into()),
                 ast::ConstCombinator::ConstBytes(x) => ir::ConstCombinator::ConstBytes(x.into()),
                 ast::ConstCombinator::ConstInt(x) => ir::ConstCombinator::ConstInt(x.into()),
                 ast::ConstCombinator::ConstEnum(x) => ir::ConstCombinator::ConstEnum(x.into()),
-                ast::ConstCombinator::ConstStruct(x) => ir::ConstCombinator::ConstStruct(x.into()),
-                ast::ConstCombinator::ConstChoice(x) => ir::ConstCombinator::ConstChoice(x.into()),
                 ast::ConstCombinator::ConstCombinatorInvocation { name, .. } => {
                     ir::ConstCombinator::ConstCombinatorInvocation(id(name))
                 }
@@ -1105,16 +1029,6 @@ pub mod lowering {
         }
     }
 
-    impl<'i> From<ast::ConstArrayCombinator<'i>> for ir::ConstArrayCombinator {
-        fn from(c: ast::ConstArrayCombinator<'i>) -> Self {
-            ir::ConstArrayCombinator {
-                combinator: c.combinator.into(),
-                len: c.len,
-                values: c.values.into(),
-            }
-        }
-    }
-
     impl<'i> From<ast::ConstBytesCombinator<'i>> for ir::ConstBytesCombinator {
         fn from(c: ast::ConstBytesCombinator<'i>) -> Self {
             ir::ConstBytesCombinator {
@@ -1155,27 +1069,6 @@ pub mod lowering {
         }
     }
 
-    impl<'i> From<ast::ConstStructCombinator<'i>> for ir::ConstStructCombinator {
-        fn from(c: ast::ConstStructCombinator<'i>) -> Self {
-            ir::ConstStructCombinator(c.0.into_iter().map(Into::into).collect())
-        }
-    }
-
-    impl<'i> From<ast::ConstChoiceCombinator<'i>> for ir::ConstChoiceCombinator {
-        fn from(c: ast::ConstChoiceCombinator<'i>) -> Self {
-            ir::ConstChoiceCombinator(c.0.into_iter().map(Into::into).collect())
-        }
-    }
-
-    impl<'i> From<ast::ConstChoice<'i>> for ir::ConstChoice {
-        fn from(c: ast::ConstChoice<'i>) -> Self {
-            ir::ConstChoice {
-                tag: c.tag,
-                combinator: c.combinator.into(),
-            }
-        }
-    }
-
     impl<'i> From<crate::type_check::ConstCombinatorSig<'i>> for ir::ConstCombinatorSig {
         fn from(src: crate::type_check::ConstCombinatorSig<'i>) -> Self {
             ir::ConstCombinatorSig {
@@ -1209,6 +1102,7 @@ pub mod lowering {
                 combinators,
                 const_combinators,
                 enums,
+                static_sizes: src.static_sizes.clone(),
             }
         }
     }
diff --git a/vest-dsl/test/Cargo.toml b/vest-dsl/test/Cargo.toml
index 46e6a5c7..0970755d 100644
--- a/vest-dsl/test/Cargo.toml
+++ b/vest-dsl/test/Cargo.toml
@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-vstd = "0.0.0-2026-01-04-0057"
+vstd = "0.0.0-2026-03-17-2326"
 vest_lib = { path = "../../vest" }
 
 [package.metadata.verus]
diff --git a/vest-dsl/test/Makefile b/vest-dsl/test/Makefile
index dc3899c3..4dbecbfe 100644
--- a/vest-dsl/test/Makefile
+++ b/vest-dsl/test/Makefile
@@ -1,26 +1,26 @@
-.PHONY: all vest bad verus
+.PHONY: all build-vest vest bad verus
 
 CARGO        := cargo
 ROOT_MANIFEST := ../Cargo.toml
 VEST_DSL     := ../target/debug/vest
 # selected .vest files in the src directory
-VEST_FILES   := ./src/codegen.vest ./src/elab.vest ./src/enums.vest ./src/enum_constraints.vest ./src/josh.vest ./src/matches.vest ./src/opt.vest ./src/repeat.vest
+VEST_FILES   := ./src/anonymous_nested.vest ./src/codegen.vest ./src/elab.vest ./src/enums.vest ./src/enum_constraints.vest ./src/josh.vest ./src/matches.vest ./src/opt.vest ./src/repeat.vest ./src/length_expr.vest ./src/nested_access.vest ./src/ikev2.vest
 # all files in ./bad/
 BAD_VEST_FILES := $(wildcard ./bad/*.vest)
 
 all: vest bad verus
 
-$(VEST_DSL):
+build-vest:
 	$(CARGO) build --manifest-path $(ROOT_MANIFEST) -p vest
 
-vest: $(VEST_DSL)
+vest: build-vest
 	@for file in $(VEST_FILES); do \
 		echo "==================================="; \
 		echo "Processing $$file"; \
 		$(VEST_DSL) $$file; \
 	done
 
-bad: $(VEST_DSL)
+bad: build-vest
 	@for file in $(BAD_VEST_FILES); do \
 		echo "==================================="; \
 		echo "Expecting failure for $$file"; \
diff --git a/vest-dsl/test/bad/choice_arrays_folded_len_mismatch.vest b/vest-dsl/test/bad/choice_arrays_folded_len_mismatch.vest
new file mode 100644
index 00000000..3fc320b6
--- /dev/null
+++ b/vest-dsl/test/bad/choice_arrays_folded_len_mismatch.vest
@@ -0,0 +1,7 @@
+// Invalid: folded static lengths still have to match array choice patterns
+tag = [u8; |u8| + |u8|]
+
+fmt(@tag: tag) = choose(@tag) {
+    [0; 1] => u8,
+    _ => u16,
+}
diff --git a/vest-dsl/test/bad/nested_non_dependent.vest b/vest-dsl/test/bad/nested_non_dependent.vest
new file mode 100644
index 00000000..0d1783b6
--- /dev/null
+++ b/vest-dsl/test/bad/nested_non_dependent.vest
@@ -0,0 +1,10 @@
+// Invalid: non-dependent field access
+header = {
+    magic: u32,
+    len: u16,  // not @len, so can't be accessed
+}
+
+foo = {
+    @hdr: header,
+    data: [u8; @hdr.len],  // Error: 'len' is not a dependent field
+}
diff --git a/vest-dsl/test/bad/size_expr_choice_non_static.vest b/vest-dsl/test/bad/size_expr_choice_non_static.vest
new file mode 100644
index 00000000..8a2b3933
--- /dev/null
+++ b/vest-dsl/test/bad/size_expr_choice_non_static.vest
@@ -0,0 +1,9 @@
+// Invalid: a choice format is not statically sized when branch widths differ
+tagged_choice(@tag: u8) = choose(@tag) {
+    0 => u8,
+    _ => u16,
+}
+
+bad = {
+    body: [u8; |tagged_choice|],
+}
diff --git a/vest-dsl/test/bad/size_expr_non_static.vest b/vest-dsl/test/bad/size_expr_non_static.vest
new file mode 100644
index 00000000..2372f39e
--- /dev/null
+++ b/vest-dsl/test/bad/size_expr_non_static.vest
@@ -0,0 +1,9 @@
+// Invalid: size expression requires a statically-sized format
+opaque_payload = {
+    @len: u16,
+    body: [u8; @len],
+}
+
+bad = {
+    body: [u8; |opaque_payload|],
+}
diff --git a/vest-dsl/test/bad/size_expr_param_dependent.vest b/vest-dsl/test/bad/size_expr_param_dependent.vest
new file mode 100644
index 00000000..6a7c7e11
--- /dev/null
+++ b/vest-dsl/test/bad/size_expr_param_dependent.vest
@@ -0,0 +1,8 @@
+// Invalid: parameter-dependent formats do not have a statically-known size
+payload(@len: u16) = {
+    body: [u8; @len],
+}
+
+bad = {
+    body: [u8; |payload|],
+}
diff --git a/vest-dsl/test/bad/size_expr_undefined.vest b/vest-dsl/test/bad/size_expr_undefined.vest
new file mode 100644
index 00000000..81a344b9
--- /dev/null
+++ b/vest-dsl/test/bad/size_expr_undefined.vest
@@ -0,0 +1,4 @@
+// Invalid: undefined type in size expression
+foo = {
+    data: [u8; |undefined_type|],
+}
diff --git a/vest-dsl/test/src/anonymous_nested.rs b/vest-dsl/test/src/anonymous_nested.rs
new file mode 100644
index 00000000..ea3dfa59
--- /dev/null
+++ b/vest-dsl/test/src/anonymous_nested.rs
@@ -0,0 +1,4909 @@
+
+#![allow(warnings)]
+#![allow(unused)]
+use vstd::prelude::*;
+use vest_lib::regular::modifier::*;
+use vest_lib::regular::bytes;
+use vest_lib::regular::variant::*;
+use vest_lib::regular::sequence::*;
+use vest_lib::regular::repetition::*;
+use vest_lib::regular::disjoint::DisjointFrom;
+use vest_lib::regular::tag::*;
+use vest_lib::regular::uints::*;
+use vest_lib::utils::*;
+use vest_lib::properties::*;
+use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
+use vest_lib::regular::leb128::*;
+
+macro_rules! impl_wrapper_combinator {
+    ($combinator:ty, $combinator_alias:ty) => {
+        ::vstd::prelude::verus! {
+            impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for $combinator {
+                type Type = <$combinator_alias as Combinator<'a, &'a [u8], Vec<u8>>>::Type;
+                type SType = <$combinator_alias as Combinator<'a, &'a [u8], Vec<u8>>>::SType;
+                fn length(&self, v: Self::SType) -> usize
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+                open spec fn ex_requires(&self) -> bool
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+                fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&self.0, s) }
+                fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+            }
+        } // verus!
+    };
+}
+verus!{
+
+pub enum SpecCaptureParamAndLocalXAPayload {
+    C(Seq<u8>),
+    D(Seq<u8>),
+}
+
+pub type SpecCaptureParamAndLocalXAPayloadInner = Either<Seq<u8>, Seq<u8>>;
+
+impl SpecFrom<SpecCaptureParamAndLocalXAPayload> for SpecCaptureParamAndLocalXAPayloadInner {
+    open spec fn spec_from(m: SpecCaptureParamAndLocalXAPayload) -> SpecCaptureParamAndLocalXAPayloadInner {
+        match m {
+            SpecCaptureParamAndLocalXAPayload::C(m) => Either::Left(m),
+            SpecCaptureParamAndLocalXAPayload::D(m) => Either::Right(m),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecCaptureParamAndLocalXAPayloadInner> for SpecCaptureParamAndLocalXAPayload {
+    open spec fn spec_from(m: SpecCaptureParamAndLocalXAPayloadInner) -> SpecCaptureParamAndLocalXAPayload {
+        match m {
+            Either::Left(m) => SpecCaptureParamAndLocalXAPayload::C(m),
+            Either::Right(m) => SpecCaptureParamAndLocalXAPayload::D(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CaptureParamAndLocalXAPayload<'a> {
+    C(&'a [u8]),
+    D(&'a [u8]),
+}
+
+pub type CaptureParamAndLocalXAPayloadInner<'a> = Either<&'a [u8], &'a [u8]>;
+
+pub type CaptureParamAndLocalXAPayloadInnerRef<'a> = Either<&'a &'a [u8], &'a &'a [u8]>;
+
+
+impl<'a> View for CaptureParamAndLocalXAPayload<'a> {
+    type V = SpecCaptureParamAndLocalXAPayload;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            CaptureParamAndLocalXAPayload::C(m) => SpecCaptureParamAndLocalXAPayload::C(m@),
+            CaptureParamAndLocalXAPayload::D(m) => SpecCaptureParamAndLocalXAPayload::D(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a CaptureParamAndLocalXAPayload<'a>> for CaptureParamAndLocalXAPayloadInnerRef<'a> {
+    fn ex_from(m: &'a CaptureParamAndLocalXAPayload<'a>) -> CaptureParamAndLocalXAPayloadInnerRef<'a> {
+        match m {
+            CaptureParamAndLocalXAPayload::C(m) => Either::Left(m),
+            CaptureParamAndLocalXAPayload::D(m) => Either::Right(m),
+        }
+    }
+
+}
+
+impl<'a> From<CaptureParamAndLocalXAPayloadInner<'a>> for CaptureParamAndLocalXAPayload<'a> {
+    fn ex_from(m: CaptureParamAndLocalXAPayloadInner<'a>) -> CaptureParamAndLocalXAPayload<'a> {
+        match m {
+            Either::Left(m) => CaptureParamAndLocalXAPayload::C(m),
+            Either::Right(m) => CaptureParamAndLocalXAPayload::D(m),
+        }
+    }
+    
+}
+
+
+pub struct CaptureParamAndLocalXAPayloadMapper;
+impl View for CaptureParamAndLocalXAPayloadMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureParamAndLocalXAPayloadMapper {
+    type Src = SpecCaptureParamAndLocalXAPayloadInner;
+    type Dst = SpecCaptureParamAndLocalXAPayload;
+}
+impl SpecIsoProof for CaptureParamAndLocalXAPayloadMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureParamAndLocalXAPayloadMapper {
+    type Src = CaptureParamAndLocalXAPayloadInner<'a>;
+    type Dst = CaptureParamAndLocalXAPayload<'a>;
+    type RefSrc = CaptureParamAndLocalXAPayloadInnerRef<'a>;
+}
+
+type SpecCaptureParamAndLocalXAPayloadCombinatorAlias1 = Choice<Cond<bytes::Variable>, Cond<bytes::Variable>>;
+pub struct SpecCaptureParamAndLocalXAPayloadCombinator(pub SpecCaptureParamAndLocalXAPayloadCombinatorAlias);
+
+impl SpecCombinator for SpecCaptureParamAndLocalXAPayloadCombinator {
+    type Type = SpecCaptureParamAndLocalXAPayload;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureParamAndLocalXAPayloadCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureParamAndLocalXAPayloadCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureParamAndLocalXAPayloadCombinatorAlias = Mapped<SpecCaptureParamAndLocalXAPayloadCombinatorAlias1, CaptureParamAndLocalXAPayloadMapper>;
+type CaptureParamAndLocalXAPayloadCombinatorAlias1 = Choice<Cond<bytes::Variable>, Cond<bytes::Variable>>;
+pub struct CaptureParamAndLocalXAPayloadCombinator1(pub CaptureParamAndLocalXAPayloadCombinatorAlias1);
+impl View for CaptureParamAndLocalXAPayloadCombinator1 {
+    type V = SpecCaptureParamAndLocalXAPayloadCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CaptureParamAndLocalXAPayloadCombinator1, CaptureParamAndLocalXAPayloadCombinatorAlias1);
+
+pub struct CaptureParamAndLocalXAPayloadCombinator(pub CaptureParamAndLocalXAPayloadCombinatorAlias);
+
+impl View for CaptureParamAndLocalXAPayloadCombinator {
+    type V = SpecCaptureParamAndLocalXAPayloadCombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureParamAndLocalXAPayloadCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXAPayloadCombinator {
+    type Type = CaptureParamAndLocalXAPayload<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureParamAndLocalXAPayloadCombinatorAlias = Mapped<CaptureParamAndLocalXAPayloadCombinator1, CaptureParamAndLocalXAPayloadMapper>;
+
+
+pub open spec fn spec_capture_param_and_local_x_a_payload(choice2: SpecCOrD, len: u8) -> SpecCaptureParamAndLocalXAPayloadCombinator {
+    SpecCaptureParamAndLocalXAPayloadCombinator(Mapped { inner: Choice(Cond { cond: choice2 == COrD::C, inner: bytes::Variable((usize::spec_from(len)) as usize) }, Cond { cond: choice2 == COrD::D, inner: bytes::Variable((usize::spec_from(len)) as usize) }), mapper: CaptureParamAndLocalXAPayloadMapper })
+}
+
+pub fn capture_param_and_local_x_a_payload<'a>(choice2: COrD, len: u8) -> (o: CaptureParamAndLocalXAPayloadCombinator)
+    requires
+        spec_c_or_d().wf(choice2@),
+
+    ensures o@ == spec_capture_param_and_local_x_a_payload(choice2@, len@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureParamAndLocalXAPayloadCombinator(Mapped { inner: CaptureParamAndLocalXAPayloadCombinator1(Choice::new(Cond { cond: choice2 == COrD::C, inner: bytes::Variable((usize::ex_from(len)) as usize) }, Cond { cond: choice2 == COrD::D, inner: bytes::Variable((usize::ex_from(len)) as usize) })), mapper: CaptureParamAndLocalXAPayloadMapper });
+    // assert({
+    //     &&& combinator@ == spec_capture_param_and_local_x_a_payload(choice2@, len@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_param_and_local_x_a_payload<'a>(input: &'a [u8], choice2: COrD, len: u8) -> (res: PResult<<CaptureParamAndLocalXAPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_param_and_local_x_a_payload(choice2@, len@).spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_param_and_local_x_a_payload(choice2@, len@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_param_and_local_x_a_payload(choice2@, len@).spec_parse(input@) is None,
+        spec_capture_param_and_local_x_a_payload(choice2@, len@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_param_and_local_x_a_payload( choice2, len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_param_and_local_x_a_payload<'a>(v: <CaptureParamAndLocalXAPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice2: COrD, len: u8) -> (o: SResult<usize, SerializeError>)
+    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@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_capture_param_and_local_x_a_payload(choice2@, len@).spec_serialize(v@).len() <= usize::MAX,
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        serialize_len == spec_capture_param_and_local_x_a_payload(choice2@, len@).spec_serialize(v@).len(),
+{
+    let combinator = capture_param_and_local_x_a_payload( choice2, len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecCaptureParamAndLocalXA {
+    pub len: u8,
+    pub payload: SpecCaptureParamAndLocalXAPayload,
+}
+
+pub type SpecCaptureParamAndLocalXAInner = (u8, SpecCaptureParamAndLocalXAPayload);
+
+
+impl SpecFrom<SpecCaptureParamAndLocalXA> for SpecCaptureParamAndLocalXAInner {
+    open spec fn spec_from(m: SpecCaptureParamAndLocalXA) -> SpecCaptureParamAndLocalXAInner {
+        (m.len, m.payload)
+    }
+}
+
+impl SpecFrom<SpecCaptureParamAndLocalXAInner> for SpecCaptureParamAndLocalXA {
+    open spec fn spec_from(m: SpecCaptureParamAndLocalXAInner) -> SpecCaptureParamAndLocalXA {
+        let (len, payload) = m;
+        SpecCaptureParamAndLocalXA { len, payload }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CaptureParamAndLocalXA<'a> {
+    pub len: u8,
+    pub payload: CaptureParamAndLocalXAPayload<'a>,
+}
+
+impl View for CaptureParamAndLocalXA<'_> {
+    type V = SpecCaptureParamAndLocalXA;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCaptureParamAndLocalXA {
+            len: self.len@,
+            payload: self.payload@,
+        }
+    }
+}
+pub type CaptureParamAndLocalXAInner<'a> = (u8, CaptureParamAndLocalXAPayload<'a>);
+
+pub type CaptureParamAndLocalXAInnerRef<'a> = (&'a u8, &'a CaptureParamAndLocalXAPayload<'a>);
+impl<'a> From<&'a CaptureParamAndLocalXA<'a>> for CaptureParamAndLocalXAInnerRef<'a> {
+    fn ex_from(m: &'a CaptureParamAndLocalXA) -> CaptureParamAndLocalXAInnerRef<'a> {
+        (&m.len, &m.payload)
+    }
+}
+
+impl<'a> From<CaptureParamAndLocalXAInner<'a>> for CaptureParamAndLocalXA<'a> {
+    fn ex_from(m: CaptureParamAndLocalXAInner) -> CaptureParamAndLocalXA {
+        let (len, payload) = m;
+        CaptureParamAndLocalXA { len, payload }
+    }
+}
+
+pub struct CaptureParamAndLocalXAMapper;
+impl View for CaptureParamAndLocalXAMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureParamAndLocalXAMapper {
+    type Src = SpecCaptureParamAndLocalXAInner;
+    type Dst = SpecCaptureParamAndLocalXA;
+}
+impl SpecIsoProof for CaptureParamAndLocalXAMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureParamAndLocalXAMapper {
+    type Src = CaptureParamAndLocalXAInner<'a>;
+    type Dst = CaptureParamAndLocalXA<'a>;
+    type RefSrc = CaptureParamAndLocalXAInnerRef<'a>;
+}
+
+pub struct SpecCaptureParamAndLocalXACombinator(pub SpecCaptureParamAndLocalXACombinatorAlias);
+
+impl SpecCombinator for SpecCaptureParamAndLocalXACombinator {
+    type Type = SpecCaptureParamAndLocalXA;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureParamAndLocalXACombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureParamAndLocalXACombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureParamAndLocalXACombinatorAlias = Mapped<SpecPair<U8, SpecCaptureParamAndLocalXAPayloadCombinator>, CaptureParamAndLocalXAMapper>;
+
+pub struct CaptureParamAndLocalXACombinator(pub CaptureParamAndLocalXACombinatorAlias);
+
+impl View for CaptureParamAndLocalXACombinator {
+    type V = SpecCaptureParamAndLocalXACombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureParamAndLocalXACombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXACombinator {
+    type Type = CaptureParamAndLocalXA<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureParamAndLocalXACombinatorAlias = Mapped<Pair<U8, CaptureParamAndLocalXAPayloadCombinator, CaptureParamAndLocalXACont0>, CaptureParamAndLocalXAMapper>;
+
+
+pub open spec fn spec_capture_param_and_local_x_a(choice2: SpecCOrD) -> SpecCaptureParamAndLocalXACombinator {
+    SpecCaptureParamAndLocalXACombinator(
+    Mapped {
+        inner: Pair::spec_new(U8, |deps| spec_capture_param_and_local_x_a_cont0(choice2, deps)),
+        mapper: CaptureParamAndLocalXAMapper,
+    })
+}
+
+pub open spec fn spec_capture_param_and_local_x_a_cont0(choice2: SpecCOrD, deps: u8) -> SpecCaptureParamAndLocalXAPayloadCombinator {
+    let len = deps;
+    spec_capture_param_and_local_x_a_payload(choice2, len)
+}
+
+impl View for CaptureParamAndLocalXACont0 {
+    type V = spec_fn(u8) -> SpecCaptureParamAndLocalXAPayloadCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_capture_param_and_local_x_a_cont0(self.choice2@, deps)
+        }
+    }
+}
+
+pub fn capture_param_and_local_x_a<'a>(choice2: COrD) -> (o: CaptureParamAndLocalXACombinator)
+    requires
+        spec_c_or_d().wf(choice2@),
+
+    ensures o@ == spec_capture_param_and_local_x_a(choice2@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureParamAndLocalXACombinator(
+    Mapped {
+        inner: Pair::new(U8, CaptureParamAndLocalXACont0 { choice2 }),
+        mapper: CaptureParamAndLocalXAMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_capture_param_and_local_x_a(choice2@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_param_and_local_x_a<'a>(input: &'a [u8], choice2: COrD) -> (res: PResult<<CaptureParamAndLocalXACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_param_and_local_x_a(choice2@).spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_param_and_local_x_a(choice2@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_param_and_local_x_a(choice2@).spec_parse(input@) is None,
+        spec_capture_param_and_local_x_a(choice2@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_param_and_local_x_a( choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_param_and_local_x_a<'a>(v: <CaptureParamAndLocalXACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice2: COrD) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_param_and_local_x_a(choice2@).wf(v@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_capture_param_and_local_x_a(choice2@).spec_serialize(v@).len() <= usize::MAX,
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        serialize_len == spec_capture_param_and_local_x_a(choice2@).spec_serialize(v@).len(),
+{
+    let combinator = capture_param_and_local_x_a( choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct CaptureParamAndLocalXACont0 {
+    pub choice2: COrD,
+}
+type CaptureParamAndLocalXACont0Type<'a, 'b> = &'b u8;
+type CaptureParamAndLocalXACont0SType<'a, 'x> = &'x u8;
+type CaptureParamAndLocalXACont0Input<'a, 'b, 'x> = POrSType<CaptureParamAndLocalXACont0Type<'a, 'b>, CaptureParamAndLocalXACont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CaptureParamAndLocalXACont0Input<'a, 'b, 'x>> for CaptureParamAndLocalXACont0 {
+    type Output = CaptureParamAndLocalXAPayloadCombinator;
+
+    open spec fn requires(&self, deps: CaptureParamAndLocalXACont0Input<'a, 'b, 'x>) -> bool {        let choice2 = self.choice2@;
+
+        &&& spec_c_or_d().wf(self.choice2@)
+        &&& (U8).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CaptureParamAndLocalXACont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_capture_param_and_local_x_a_cont0(self.choice2@, deps@)
+    }
+
+    fn apply(&self, deps: CaptureParamAndLocalXACont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let len = deps;
+                let choice2 = self.choice2;
+                let len = *len;
+                capture_param_and_local_x_a_payload(choice2, len)
+            }
+            POrSType::S(deps) => {
+                let len = deps;
+                let choice2 = self.choice2;
+                let len = *len;
+                capture_param_and_local_x_a_payload(choice2, len)
+            }
+        }
+    }
+}
+
+pub enum SpecCaptureParamAndLocalXBY {
+    Variant0(u8),
+    Variant1(u16),
+}
+
+pub type SpecCaptureParamAndLocalXBYInner = Either<u8, u16>;
+
+impl SpecFrom<SpecCaptureParamAndLocalXBY> for SpecCaptureParamAndLocalXBYInner {
+    open spec fn spec_from(m: SpecCaptureParamAndLocalXBY) -> SpecCaptureParamAndLocalXBYInner {
+        match m {
+            SpecCaptureParamAndLocalXBY::Variant0(m) => Either::Left(m),
+            SpecCaptureParamAndLocalXBY::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecCaptureParamAndLocalXBYInner> for SpecCaptureParamAndLocalXBY {
+    open spec fn spec_from(m: SpecCaptureParamAndLocalXBYInner) -> SpecCaptureParamAndLocalXBY {
+        match m {
+            Either::Left(m) => SpecCaptureParamAndLocalXBY::Variant0(m),
+            Either::Right(m) => SpecCaptureParamAndLocalXBY::Variant1(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CaptureParamAndLocalXBY {
+    Variant0(u8),
+    Variant1(u16),
+}
+
+pub type CaptureParamAndLocalXBYInner = Either<u8, u16>;
+
+pub type CaptureParamAndLocalXBYInnerRef<'a> = Either<&'a u8, &'a u16>;
+
+
+impl View for CaptureParamAndLocalXBY {
+    type V = SpecCaptureParamAndLocalXBY;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            CaptureParamAndLocalXBY::Variant0(m) => SpecCaptureParamAndLocalXBY::Variant0(m@),
+            CaptureParamAndLocalXBY::Variant1(m) => SpecCaptureParamAndLocalXBY::Variant1(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a CaptureParamAndLocalXBY> for CaptureParamAndLocalXBYInnerRef<'a> {
+    fn ex_from(m: &'a CaptureParamAndLocalXBY) -> CaptureParamAndLocalXBYInnerRef<'a> {
+        match m {
+            CaptureParamAndLocalXBY::Variant0(m) => Either::Left(m),
+            CaptureParamAndLocalXBY::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+impl From<CaptureParamAndLocalXBYInner> for CaptureParamAndLocalXBY {
+    fn ex_from(m: CaptureParamAndLocalXBYInner) -> CaptureParamAndLocalXBY {
+        match m {
+            Either::Left(m) => CaptureParamAndLocalXBY::Variant0(m),
+            Either::Right(m) => CaptureParamAndLocalXBY::Variant1(m),
+        }
+    }
+    
+}
+
+
+pub struct CaptureParamAndLocalXBYMapper;
+impl View for CaptureParamAndLocalXBYMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureParamAndLocalXBYMapper {
+    type Src = SpecCaptureParamAndLocalXBYInner;
+    type Dst = SpecCaptureParamAndLocalXBY;
+}
+impl SpecIsoProof for CaptureParamAndLocalXBYMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureParamAndLocalXBYMapper {
+    type Src = CaptureParamAndLocalXBYInner;
+    type Dst = CaptureParamAndLocalXBY;
+    type RefSrc = CaptureParamAndLocalXBYInnerRef<'a>;
+}
+
+type SpecCaptureParamAndLocalXBYCombinatorAlias1 = Choice<Cond<U8>, Cond<U16Le>>;
+pub struct SpecCaptureParamAndLocalXBYCombinator(pub SpecCaptureParamAndLocalXBYCombinatorAlias);
+
+impl SpecCombinator for SpecCaptureParamAndLocalXBYCombinator {
+    type Type = SpecCaptureParamAndLocalXBY;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureParamAndLocalXBYCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureParamAndLocalXBYCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureParamAndLocalXBYCombinatorAlias = Mapped<SpecCaptureParamAndLocalXBYCombinatorAlias1, CaptureParamAndLocalXBYMapper>;
+type CaptureParamAndLocalXBYCombinatorAlias1 = Choice<Cond<U8>, Cond<U16Le>>;
+pub struct CaptureParamAndLocalXBYCombinator1(pub CaptureParamAndLocalXBYCombinatorAlias1);
+impl View for CaptureParamAndLocalXBYCombinator1 {
+    type V = SpecCaptureParamAndLocalXBYCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CaptureParamAndLocalXBYCombinator1, CaptureParamAndLocalXBYCombinatorAlias1);
+
+pub struct CaptureParamAndLocalXBYCombinator(pub CaptureParamAndLocalXBYCombinatorAlias);
+
+impl View for CaptureParamAndLocalXBYCombinator {
+    type V = SpecCaptureParamAndLocalXBYCombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureParamAndLocalXBYCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXBYCombinator {
+    type Type = CaptureParamAndLocalXBY;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureParamAndLocalXBYCombinatorAlias = Mapped<CaptureParamAndLocalXBYCombinator1, CaptureParamAndLocalXBYMapper>;
+
+
+pub open spec fn spec_capture_param_and_local_x_b_y(tag: u8) -> SpecCaptureParamAndLocalXBYCombinator {
+    SpecCaptureParamAndLocalXBYCombinator(Mapped { inner: Choice(Cond { cond: tag == 0, inner: U8 }, Cond { cond: !(tag == 0), inner: U16Le }), mapper: CaptureParamAndLocalXBYMapper })
+}
+
+pub fn capture_param_and_local_x_b_y<'a>(tag: u8) -> (o: CaptureParamAndLocalXBYCombinator)
+
+    ensures o@ == spec_capture_param_and_local_x_b_y(tag@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureParamAndLocalXBYCombinator(Mapped { inner: CaptureParamAndLocalXBYCombinator1(Choice::new(Cond { cond: tag == 0, inner: U8 }, Cond { cond: !(tag == 0), inner: U16Le })), mapper: CaptureParamAndLocalXBYMapper });
+    // assert({
+    //     &&& combinator@ == spec_capture_param_and_local_x_b_y(tag@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_param_and_local_x_b_y<'a>(input: &'a [u8], tag: u8) -> (res: PResult<<CaptureParamAndLocalXBYCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_param_and_local_x_b_y(tag@).spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_param_and_local_x_b_y(tag@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_param_and_local_x_b_y(tag@).spec_parse(input@) is None,
+        spec_capture_param_and_local_x_b_y(tag@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_param_and_local_x_b_y( tag );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_param_and_local_x_b_y<'a>(v: <CaptureParamAndLocalXBYCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, tag: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_param_and_local_x_b_y(tag@).wf(v@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_capture_param_and_local_x_b_y(tag@).spec_serialize(v@).len() <= usize::MAX,
+
+    ensures
+        serialize_len == spec_capture_param_and_local_x_b_y(tag@).spec_serialize(v@).len(),
+{
+    let combinator = capture_param_and_local_x_b_y( tag );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecCaptureParamAndLocalXB {
+    pub tag: u8,
+    pub y: SpecCaptureParamAndLocalXBY,
+}
+
+pub type SpecCaptureParamAndLocalXBInner = (u8, SpecCaptureParamAndLocalXBY);
+
+
+impl SpecFrom<SpecCaptureParamAndLocalXB> for SpecCaptureParamAndLocalXBInner {
+    open spec fn spec_from(m: SpecCaptureParamAndLocalXB) -> SpecCaptureParamAndLocalXBInner {
+        (m.tag, m.y)
+    }
+}
+
+impl SpecFrom<SpecCaptureParamAndLocalXBInner> for SpecCaptureParamAndLocalXB {
+    open spec fn spec_from(m: SpecCaptureParamAndLocalXBInner) -> SpecCaptureParamAndLocalXB {
+        let (tag, y) = m;
+        SpecCaptureParamAndLocalXB { tag, y }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CaptureParamAndLocalXB {
+    pub tag: u8,
+    pub y: CaptureParamAndLocalXBY,
+}
+
+impl View for CaptureParamAndLocalXB {
+    type V = SpecCaptureParamAndLocalXB;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCaptureParamAndLocalXB {
+            tag: self.tag@,
+            y: self.y@,
+        }
+    }
+}
+pub type CaptureParamAndLocalXBInner = (u8, CaptureParamAndLocalXBY);
+
+pub type CaptureParamAndLocalXBInnerRef<'a> = (&'a u8, &'a CaptureParamAndLocalXBY);
+impl<'a> From<&'a CaptureParamAndLocalXB> for CaptureParamAndLocalXBInnerRef<'a> {
+    fn ex_from(m: &'a CaptureParamAndLocalXB) -> CaptureParamAndLocalXBInnerRef<'a> {
+        (&m.tag, &m.y)
+    }
+}
+
+impl From<CaptureParamAndLocalXBInner> for CaptureParamAndLocalXB {
+    fn ex_from(m: CaptureParamAndLocalXBInner) -> CaptureParamAndLocalXB {
+        let (tag, y) = m;
+        CaptureParamAndLocalXB { tag, y }
+    }
+}
+
+pub struct CaptureParamAndLocalXBMapper;
+impl View for CaptureParamAndLocalXBMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureParamAndLocalXBMapper {
+    type Src = SpecCaptureParamAndLocalXBInner;
+    type Dst = SpecCaptureParamAndLocalXB;
+}
+impl SpecIsoProof for CaptureParamAndLocalXBMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureParamAndLocalXBMapper {
+    type Src = CaptureParamAndLocalXBInner;
+    type Dst = CaptureParamAndLocalXB;
+    type RefSrc = CaptureParamAndLocalXBInnerRef<'a>;
+}
+
+pub struct SpecCaptureParamAndLocalXBCombinator(pub SpecCaptureParamAndLocalXBCombinatorAlias);
+
+impl SpecCombinator for SpecCaptureParamAndLocalXBCombinator {
+    type Type = SpecCaptureParamAndLocalXB;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureParamAndLocalXBCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureParamAndLocalXBCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureParamAndLocalXBCombinatorAlias = Mapped<SpecPair<U8, SpecCaptureParamAndLocalXBYCombinator>, CaptureParamAndLocalXBMapper>;
+
+pub struct CaptureParamAndLocalXBCombinator(pub CaptureParamAndLocalXBCombinatorAlias);
+
+impl View for CaptureParamAndLocalXBCombinator {
+    type V = SpecCaptureParamAndLocalXBCombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureParamAndLocalXBCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXBCombinator {
+    type Type = CaptureParamAndLocalXB;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureParamAndLocalXBCombinatorAlias = Mapped<Pair<U8, CaptureParamAndLocalXBYCombinator, CaptureParamAndLocalXBCont0>, CaptureParamAndLocalXBMapper>;
+
+
+pub open spec fn spec_capture_param_and_local_x_b() -> SpecCaptureParamAndLocalXBCombinator {
+    SpecCaptureParamAndLocalXBCombinator(
+    Mapped {
+        inner: Pair::spec_new(U8, |deps| spec_capture_param_and_local_x_b_cont0(deps)),
+        mapper: CaptureParamAndLocalXBMapper,
+    })
+}
+
+pub open spec fn spec_capture_param_and_local_x_b_cont0(deps: u8) -> SpecCaptureParamAndLocalXBYCombinator {
+    let tag = deps;
+    spec_capture_param_and_local_x_b_y(tag)
+}
+
+impl View for CaptureParamAndLocalXBCont0 {
+    type V = spec_fn(u8) -> SpecCaptureParamAndLocalXBYCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_capture_param_and_local_x_b_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn capture_param_and_local_x_b<'a>() -> (o: CaptureParamAndLocalXBCombinator)
+    ensures o@ == spec_capture_param_and_local_x_b(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureParamAndLocalXBCombinator(
+    Mapped {
+        inner: Pair::new(U8, CaptureParamAndLocalXBCont0),
+        mapper: CaptureParamAndLocalXBMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_capture_param_and_local_x_b()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_param_and_local_x_b<'a>(input: &'a [u8]) -> (res: PResult<<CaptureParamAndLocalXBCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_param_and_local_x_b().spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_param_and_local_x_b().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_param_and_local_x_b().spec_parse(input@) is None,
+        spec_capture_param_and_local_x_b().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_param_and_local_x_b();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_param_and_local_x_b<'a>(v: <CaptureParamAndLocalXBCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_param_and_local_x_b().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_capture_param_and_local_x_b().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_capture_param_and_local_x_b().spec_serialize(v@).len(),
+{
+    let combinator = capture_param_and_local_x_b();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct CaptureParamAndLocalXBCont0;
+type CaptureParamAndLocalXBCont0Type<'a, 'b> = &'b u8;
+type CaptureParamAndLocalXBCont0SType<'a, 'x> = &'x u8;
+type CaptureParamAndLocalXBCont0Input<'a, 'b, 'x> = POrSType<CaptureParamAndLocalXBCont0Type<'a, 'b>, CaptureParamAndLocalXBCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CaptureParamAndLocalXBCont0Input<'a, 'b, 'x>> for CaptureParamAndLocalXBCont0 {
+    type Output = CaptureParamAndLocalXBYCombinator;
+
+    open spec fn requires(&self, deps: CaptureParamAndLocalXBCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U8).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CaptureParamAndLocalXBCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_capture_param_and_local_x_b_cont0(deps@)
+    }
+
+    fn apply(&self, deps: CaptureParamAndLocalXBCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let tag = deps;
+                let tag = *tag;
+                capture_param_and_local_x_b_y(tag)
+            }
+            POrSType::S(deps) => {
+                let tag = deps;
+                let tag = *tag;
+                capture_param_and_local_x_b_y(tag)
+            }
+        }
+    }
+}
+                
+
+pub enum SpecCaptureParamAndLocalX {
+    A(SpecCaptureParamAndLocalXA),
+    B(SpecCaptureParamAndLocalXB),
+}
+
+pub type SpecCaptureParamAndLocalXInner = Either<SpecCaptureParamAndLocalXA, SpecCaptureParamAndLocalXB>;
+
+impl SpecFrom<SpecCaptureParamAndLocalX> for SpecCaptureParamAndLocalXInner {
+    open spec fn spec_from(m: SpecCaptureParamAndLocalX) -> SpecCaptureParamAndLocalXInner {
+        match m {
+            SpecCaptureParamAndLocalX::A(m) => Either::Left(m),
+            SpecCaptureParamAndLocalX::B(m) => Either::Right(m),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecCaptureParamAndLocalXInner> for SpecCaptureParamAndLocalX {
+    open spec fn spec_from(m: SpecCaptureParamAndLocalXInner) -> SpecCaptureParamAndLocalX {
+        match m {
+            Either::Left(m) => SpecCaptureParamAndLocalX::A(m),
+            Either::Right(m) => SpecCaptureParamAndLocalX::B(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CaptureParamAndLocalX<'a> {
+    A(CaptureParamAndLocalXA<'a>),
+    B(CaptureParamAndLocalXB),
+}
+
+pub type CaptureParamAndLocalXInner<'a> = Either<CaptureParamAndLocalXA<'a>, CaptureParamAndLocalXB>;
+
+pub type CaptureParamAndLocalXInnerRef<'a> = Either<&'a CaptureParamAndLocalXA<'a>, &'a CaptureParamAndLocalXB>;
+
+
+impl<'a> View for CaptureParamAndLocalX<'a> {
+    type V = SpecCaptureParamAndLocalX;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            CaptureParamAndLocalX::A(m) => SpecCaptureParamAndLocalX::A(m@),
+            CaptureParamAndLocalX::B(m) => SpecCaptureParamAndLocalX::B(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a CaptureParamAndLocalX<'a>> for CaptureParamAndLocalXInnerRef<'a> {
+    fn ex_from(m: &'a CaptureParamAndLocalX<'a>) -> CaptureParamAndLocalXInnerRef<'a> {
+        match m {
+            CaptureParamAndLocalX::A(m) => Either::Left(m),
+            CaptureParamAndLocalX::B(m) => Either::Right(m),
+        }
+    }
+
+}
+
+impl<'a> From<CaptureParamAndLocalXInner<'a>> for CaptureParamAndLocalX<'a> {
+    fn ex_from(m: CaptureParamAndLocalXInner<'a>) -> CaptureParamAndLocalX<'a> {
+        match m {
+            Either::Left(m) => CaptureParamAndLocalX::A(m),
+            Either::Right(m) => CaptureParamAndLocalX::B(m),
+        }
+    }
+    
+}
+
+
+pub struct CaptureParamAndLocalXMapper;
+impl View for CaptureParamAndLocalXMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureParamAndLocalXMapper {
+    type Src = SpecCaptureParamAndLocalXInner;
+    type Dst = SpecCaptureParamAndLocalX;
+}
+impl SpecIsoProof for CaptureParamAndLocalXMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureParamAndLocalXMapper {
+    type Src = CaptureParamAndLocalXInner<'a>;
+    type Dst = CaptureParamAndLocalX<'a>;
+    type RefSrc = CaptureParamAndLocalXInnerRef<'a>;
+}
+
+type SpecCaptureParamAndLocalXCombinatorAlias1 = Choice<Cond<SpecCaptureParamAndLocalXACombinator>, Cond<SpecCaptureParamAndLocalXBCombinator>>;
+pub struct SpecCaptureParamAndLocalXCombinator(pub SpecCaptureParamAndLocalXCombinatorAlias);
+
+impl SpecCombinator for SpecCaptureParamAndLocalXCombinator {
+    type Type = SpecCaptureParamAndLocalX;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureParamAndLocalXCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureParamAndLocalXCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureParamAndLocalXCombinatorAlias = Mapped<SpecCaptureParamAndLocalXCombinatorAlias1, CaptureParamAndLocalXMapper>;
+type CaptureParamAndLocalXCombinatorAlias1 = Choice<Cond<CaptureParamAndLocalXACombinator>, Cond<CaptureParamAndLocalXBCombinator>>;
+pub struct CaptureParamAndLocalXCombinator1(pub CaptureParamAndLocalXCombinatorAlias1);
+impl View for CaptureParamAndLocalXCombinator1 {
+    type V = SpecCaptureParamAndLocalXCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CaptureParamAndLocalXCombinator1, CaptureParamAndLocalXCombinatorAlias1);
+
+pub struct CaptureParamAndLocalXCombinator(pub CaptureParamAndLocalXCombinatorAlias);
+
+impl View for CaptureParamAndLocalXCombinator {
+    type V = SpecCaptureParamAndLocalXCombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureParamAndLocalXCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalXCombinator {
+    type Type = CaptureParamAndLocalX<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureParamAndLocalXCombinatorAlias = Mapped<CaptureParamAndLocalXCombinator1, CaptureParamAndLocalXMapper>;
+
+
+pub open spec fn spec_capture_param_and_local_x(choice1: SpecAOrB, choice2: SpecCOrD) -> SpecCaptureParamAndLocalXCombinator {
+    SpecCaptureParamAndLocalXCombinator(Mapped { inner: Choice(Cond { cond: choice1 == AOrB::A, inner: spec_capture_param_and_local_x_a(choice2) }, Cond { cond: choice1 == AOrB::B, inner: spec_capture_param_and_local_x_b() }), mapper: CaptureParamAndLocalXMapper })
+}
+
+pub fn capture_param_and_local_x<'a>(choice1: AOrB, choice2: COrD) -> (o: CaptureParamAndLocalXCombinator)
+    requires
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures o@ == spec_capture_param_and_local_x(choice1@, choice2@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureParamAndLocalXCombinator(Mapped { inner: CaptureParamAndLocalXCombinator1(Choice::new(Cond { cond: choice1 == AOrB::A, inner: capture_param_and_local_x_a(choice2) }, Cond { cond: choice1 == AOrB::B, inner: capture_param_and_local_x_b() })), mapper: CaptureParamAndLocalXMapper });
+    // assert({
+    //     &&& combinator@ == spec_capture_param_and_local_x(choice1@, choice2@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_param_and_local_x<'a>(input: &'a [u8], choice1: AOrB, choice2: COrD) -> (res: PResult<<CaptureParamAndLocalXCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_param_and_local_x(choice1@, choice2@).spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_param_and_local_x(choice1@, choice2@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_param_and_local_x(choice1@, choice2@).spec_parse(input@) is None,
+        spec_capture_param_and_local_x(choice1@, choice2@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_param_and_local_x( choice1, choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_param_and_local_x<'a>(v: <CaptureParamAndLocalXCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice1: AOrB, choice2: COrD) -> (o: SResult<usize, SerializeError>)
+    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@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_capture_param_and_local_x(choice1@, choice2@).spec_serialize(v@).len() <= usize::MAX,
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        serialize_len == spec_capture_param_and_local_x(choice1@, choice2@).spec_serialize(v@).len(),
+{
+    let combinator = capture_param_and_local_x( choice1, choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub enum SpecNestedInnerChoiceXA {
+    C(u8),
+    D(u16),
+}
+
+pub type SpecNestedInnerChoiceXAInner = Either<u8, u16>;
+
+impl SpecFrom<SpecNestedInnerChoiceXA> for SpecNestedInnerChoiceXAInner {
+    open spec fn spec_from(m: SpecNestedInnerChoiceXA) -> SpecNestedInnerChoiceXAInner {
+        match m {
+            SpecNestedInnerChoiceXA::C(m) => Either::Left(m),
+            SpecNestedInnerChoiceXA::D(m) => Either::Right(m),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecNestedInnerChoiceXAInner> for SpecNestedInnerChoiceXA {
+    open spec fn spec_from(m: SpecNestedInnerChoiceXAInner) -> SpecNestedInnerChoiceXA {
+        match m {
+            Either::Left(m) => SpecNestedInnerChoiceXA::C(m),
+            Either::Right(m) => SpecNestedInnerChoiceXA::D(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum NestedInnerChoiceXA {
+    C(u8),
+    D(u16),
+}
+
+pub type NestedInnerChoiceXAInner = Either<u8, u16>;
+
+pub type NestedInnerChoiceXAInnerRef<'a> = Either<&'a u8, &'a u16>;
+
+
+impl View for NestedInnerChoiceXA {
+    type V = SpecNestedInnerChoiceXA;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            NestedInnerChoiceXA::C(m) => SpecNestedInnerChoiceXA::C(m@),
+            NestedInnerChoiceXA::D(m) => SpecNestedInnerChoiceXA::D(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a NestedInnerChoiceXA> for NestedInnerChoiceXAInnerRef<'a> {
+    fn ex_from(m: &'a NestedInnerChoiceXA) -> NestedInnerChoiceXAInnerRef<'a> {
+        match m {
+            NestedInnerChoiceXA::C(m) => Either::Left(m),
+            NestedInnerChoiceXA::D(m) => Either::Right(m),
+        }
+    }
+
+}
+
+impl From<NestedInnerChoiceXAInner> for NestedInnerChoiceXA {
+    fn ex_from(m: NestedInnerChoiceXAInner) -> NestedInnerChoiceXA {
+        match m {
+            Either::Left(m) => NestedInnerChoiceXA::C(m),
+            Either::Right(m) => NestedInnerChoiceXA::D(m),
+        }
+    }
+    
+}
+
+
+pub struct NestedInnerChoiceXAMapper;
+impl View for NestedInnerChoiceXAMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for NestedInnerChoiceXAMapper {
+    type Src = SpecNestedInnerChoiceXAInner;
+    type Dst = SpecNestedInnerChoiceXA;
+}
+impl SpecIsoProof for NestedInnerChoiceXAMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for NestedInnerChoiceXAMapper {
+    type Src = NestedInnerChoiceXAInner;
+    type Dst = NestedInnerChoiceXA;
+    type RefSrc = NestedInnerChoiceXAInnerRef<'a>;
+}
+
+type SpecNestedInnerChoiceXACombinatorAlias1 = Choice<Cond<U8>, Cond<U16Le>>;
+pub struct SpecNestedInnerChoiceXACombinator(pub SpecNestedInnerChoiceXACombinatorAlias);
+
+impl SpecCombinator for SpecNestedInnerChoiceXACombinator {
+    type Type = SpecNestedInnerChoiceXA;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNestedInnerChoiceXACombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNestedInnerChoiceXACombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNestedInnerChoiceXACombinatorAlias = Mapped<SpecNestedInnerChoiceXACombinatorAlias1, NestedInnerChoiceXAMapper>;
+type NestedInnerChoiceXACombinatorAlias1 = Choice<Cond<U8>, Cond<U16Le>>;
+pub struct NestedInnerChoiceXACombinator1(pub NestedInnerChoiceXACombinatorAlias1);
+impl View for NestedInnerChoiceXACombinator1 {
+    type V = SpecNestedInnerChoiceXACombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(NestedInnerChoiceXACombinator1, NestedInnerChoiceXACombinatorAlias1);
+
+pub struct NestedInnerChoiceXACombinator(pub NestedInnerChoiceXACombinatorAlias);
+
+impl View for NestedInnerChoiceXACombinator {
+    type V = SpecNestedInnerChoiceXACombinator;
+    open spec fn view(&self) -> Self::V { SpecNestedInnerChoiceXACombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceXACombinator {
+    type Type = NestedInnerChoiceXA;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NestedInnerChoiceXACombinatorAlias = Mapped<NestedInnerChoiceXACombinator1, NestedInnerChoiceXAMapper>;
+
+
+pub open spec fn spec_nested_inner_choice_x_a(choice2: SpecCOrD) -> SpecNestedInnerChoiceXACombinator {
+    SpecNestedInnerChoiceXACombinator(Mapped { inner: Choice(Cond { cond: choice2 == COrD::C, inner: U8 }, Cond { cond: choice2 == COrD::D, inner: U16Le }), mapper: NestedInnerChoiceXAMapper })
+}
+
+pub fn nested_inner_choice_x_a<'a>(choice2: COrD) -> (o: NestedInnerChoiceXACombinator)
+    requires
+        spec_c_or_d().wf(choice2@),
+
+    ensures o@ == spec_nested_inner_choice_x_a(choice2@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NestedInnerChoiceXACombinator(Mapped { inner: NestedInnerChoiceXACombinator1(Choice::new(Cond { cond: choice2 == COrD::C, inner: U8 }, Cond { cond: choice2 == COrD::D, inner: U16Le })), mapper: NestedInnerChoiceXAMapper });
+    // assert({
+    //     &&& combinator@ == spec_nested_inner_choice_x_a(choice2@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_nested_inner_choice_x_a<'a>(input: &'a [u8], choice2: COrD) -> (res: PResult<<NestedInnerChoiceXACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_nested_inner_choice_x_a(choice2@).spec_parse(input@) == Some((n as int, v@)),
+        spec_nested_inner_choice_x_a(choice2@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_nested_inner_choice_x_a(choice2@).spec_parse(input@) is None,
+        spec_nested_inner_choice_x_a(choice2@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = nested_inner_choice_x_a( choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_nested_inner_choice_x_a<'a>(v: <NestedInnerChoiceXACombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice2: COrD) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_nested_inner_choice_x_a(choice2@).wf(v@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_nested_inner_choice_x_a(choice2@).spec_serialize(v@).len() <= usize::MAX,
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        serialize_len == spec_nested_inner_choice_x_a(choice2@).spec_serialize(v@).len(),
+{
+    let combinator = nested_inner_choice_x_a( choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1 {
+    pub count: u8,
+    pub items: Seq<u8>,
+}
+
+pub type SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Inner = (u8, Seq<u8>);
+
+
+impl SpecFrom<SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1> for SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Inner {
+    open spec fn spec_from(m: SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1) -> SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Inner {
+        (m.count, m.items)
+    }
+}
+
+impl SpecFrom<SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Inner> for SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1 {
+    open spec fn spec_from(m: SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Inner) -> SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1 {
+        let (count, items) = m;
+        SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1 { count, items }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CaptureOuterAndLocalPayloadAnonInnerBodyChoice1<'a> {
+    pub count: u8,
+    pub items: &'a [u8],
+}
+
+impl View for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1<'_> {
+    type V = SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1 {
+            count: self.count@,
+            items: self.items@,
+        }
+    }
+}
+pub type CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Inner<'a> = (u8, &'a [u8]);
+
+pub type CaptureOuterAndLocalPayloadAnonInnerBodyChoice1InnerRef<'a> = (&'a u8, &'a &'a [u8]);
+impl<'a> From<&'a CaptureOuterAndLocalPayloadAnonInnerBodyChoice1<'a>> for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1InnerRef<'a> {
+    fn ex_from(m: &'a CaptureOuterAndLocalPayloadAnonInnerBodyChoice1) -> CaptureOuterAndLocalPayloadAnonInnerBodyChoice1InnerRef<'a> {
+        (&m.count, &m.items)
+    }
+}
+
+impl<'a> From<CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Inner<'a>> for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1<'a> {
+    fn ex_from(m: CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Inner) -> CaptureOuterAndLocalPayloadAnonInnerBodyChoice1 {
+        let (count, items) = m;
+        CaptureOuterAndLocalPayloadAnonInnerBodyChoice1 { count, items }
+    }
+}
+
+pub struct CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Mapper;
+impl View for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Mapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Mapper {
+    type Src = SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Inner;
+    type Dst = SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1;
+}
+impl SpecIsoProof for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Mapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Mapper {
+    type Src = CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Inner<'a>;
+    type Dst = CaptureOuterAndLocalPayloadAnonInnerBodyChoice1<'a>;
+    type RefSrc = CaptureOuterAndLocalPayloadAnonInnerBodyChoice1InnerRef<'a>;
+}
+
+pub struct SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator(pub SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1CombinatorAlias);
+
+impl SpecCombinator for SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator {
+    type Type = SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1CombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1CombinatorAlias = Mapped<SpecPair<U8, bytes::Variable>, CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Mapper>;
+
+pub struct CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator(pub CaptureOuterAndLocalPayloadAnonInnerBodyChoice1CombinatorAlias);
+
+impl View for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator {
+    type V = SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator {
+    type Type = CaptureOuterAndLocalPayloadAnonInnerBodyChoice1<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureOuterAndLocalPayloadAnonInnerBodyChoice1CombinatorAlias = Mapped<Pair<U8, bytes::Variable, CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0>, CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Mapper>;
+
+
+pub open spec fn spec_capture_outer_and_local_payload_anon_inner_body_choice1() -> SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator {
+    SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator(
+    Mapped {
+        inner: Pair::spec_new(U8, |deps| spec_capture_outer_and_local_payload_anon_inner_body_choice1_cont0(deps)),
+        mapper: CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Mapper,
+    })
+}
+
+pub open spec fn spec_capture_outer_and_local_payload_anon_inner_body_choice1_cont0(deps: u8) -> bytes::Variable {
+    let count = deps;
+    bytes::Variable((usize::spec_from(count)) as usize)
+}
+
+impl View for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0 {
+    type V = spec_fn(u8) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_capture_outer_and_local_payload_anon_inner_body_choice1_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn capture_outer_and_local_payload_anon_inner_body_choice1<'a>() -> (o: CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator)
+    ensures o@ == spec_capture_outer_and_local_payload_anon_inner_body_choice1(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator(
+    Mapped {
+        inner: Pair::new(U8, CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0),
+        mapper: CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Mapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_capture_outer_and_local_payload_anon_inner_body_choice1()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_outer_and_local_payload_anon_inner_body_choice1<'a>(input: &'a [u8]) -> (res: PResult<<CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_outer_and_local_payload_anon_inner_body_choice1().spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_outer_and_local_payload_anon_inner_body_choice1().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_outer_and_local_payload_anon_inner_body_choice1().spec_parse(input@) is None,
+        spec_capture_outer_and_local_payload_anon_inner_body_choice1().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_outer_and_local_payload_anon_inner_body_choice1();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_outer_and_local_payload_anon_inner_body_choice1<'a>(v: <CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_outer_and_local_payload_anon_inner_body_choice1().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_capture_outer_and_local_payload_anon_inner_body_choice1().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_capture_outer_and_local_payload_anon_inner_body_choice1().spec_serialize(v@).len(),
+{
+    let combinator = capture_outer_and_local_payload_anon_inner_body_choice1();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0;
+type CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0Type<'a, 'b> = &'b u8;
+type CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0SType<'a, 'x> = &'x u8;
+type CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0Input<'a, 'b, 'x> = POrSType<CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0Type<'a, 'b>, CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0Input<'a, 'b, 'x>> for CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0 {
+    type Output = bytes::Variable;
+
+    open spec fn requires(&self, deps: CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U8).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_capture_outer_and_local_payload_anon_inner_body_choice1_cont0(deps@)
+    }
+
+    fn apply(&self, deps: CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Cont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let count = deps;
+                let count = *count;
+                bytes::Variable((usize::ex_from(count)) as usize)
+            }
+            POrSType::S(deps) => {
+                let count = deps;
+                let count = *count;
+                bytes::Variable((usize::ex_from(count)) as usize)
+            }
+        }
+    }
+}
+                
+
+pub enum SpecCaptureOuterAndLocalPayloadAnonInnerBody {
+    Variant0(Seq<u8>),
+    Variant1(SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1),
+}
+
+pub type SpecCaptureOuterAndLocalPayloadAnonInnerBodyInner = Either<Seq<u8>, SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1>;
+
+impl SpecFrom<SpecCaptureOuterAndLocalPayloadAnonInnerBody> for SpecCaptureOuterAndLocalPayloadAnonInnerBodyInner {
+    open spec fn spec_from(m: SpecCaptureOuterAndLocalPayloadAnonInnerBody) -> SpecCaptureOuterAndLocalPayloadAnonInnerBodyInner {
+        match m {
+            SpecCaptureOuterAndLocalPayloadAnonInnerBody::Variant0(m) => Either::Left(m),
+            SpecCaptureOuterAndLocalPayloadAnonInnerBody::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecCaptureOuterAndLocalPayloadAnonInnerBodyInner> for SpecCaptureOuterAndLocalPayloadAnonInnerBody {
+    open spec fn spec_from(m: SpecCaptureOuterAndLocalPayloadAnonInnerBodyInner) -> SpecCaptureOuterAndLocalPayloadAnonInnerBody {
+        match m {
+            Either::Left(m) => SpecCaptureOuterAndLocalPayloadAnonInnerBody::Variant0(m),
+            Either::Right(m) => SpecCaptureOuterAndLocalPayloadAnonInnerBody::Variant1(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CaptureOuterAndLocalPayloadAnonInnerBody<'a> {
+    Variant0(&'a [u8]),
+    Variant1(CaptureOuterAndLocalPayloadAnonInnerBodyChoice1<'a>),
+}
+
+pub type CaptureOuterAndLocalPayloadAnonInnerBodyInner<'a> = Either<&'a [u8], CaptureOuterAndLocalPayloadAnonInnerBodyChoice1<'a>>;
+
+pub type CaptureOuterAndLocalPayloadAnonInnerBodyInnerRef<'a> = Either<&'a &'a [u8], &'a CaptureOuterAndLocalPayloadAnonInnerBodyChoice1<'a>>;
+
+
+impl<'a> View for CaptureOuterAndLocalPayloadAnonInnerBody<'a> {
+    type V = SpecCaptureOuterAndLocalPayloadAnonInnerBody;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            CaptureOuterAndLocalPayloadAnonInnerBody::Variant0(m) => SpecCaptureOuterAndLocalPayloadAnonInnerBody::Variant0(m@),
+            CaptureOuterAndLocalPayloadAnonInnerBody::Variant1(m) => SpecCaptureOuterAndLocalPayloadAnonInnerBody::Variant1(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a CaptureOuterAndLocalPayloadAnonInnerBody<'a>> for CaptureOuterAndLocalPayloadAnonInnerBodyInnerRef<'a> {
+    fn ex_from(m: &'a CaptureOuterAndLocalPayloadAnonInnerBody<'a>) -> CaptureOuterAndLocalPayloadAnonInnerBodyInnerRef<'a> {
+        match m {
+            CaptureOuterAndLocalPayloadAnonInnerBody::Variant0(m) => Either::Left(m),
+            CaptureOuterAndLocalPayloadAnonInnerBody::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+impl<'a> From<CaptureOuterAndLocalPayloadAnonInnerBodyInner<'a>> for CaptureOuterAndLocalPayloadAnonInnerBody<'a> {
+    fn ex_from(m: CaptureOuterAndLocalPayloadAnonInnerBodyInner<'a>) -> CaptureOuterAndLocalPayloadAnonInnerBody<'a> {
+        match m {
+            Either::Left(m) => CaptureOuterAndLocalPayloadAnonInnerBody::Variant0(m),
+            Either::Right(m) => CaptureOuterAndLocalPayloadAnonInnerBody::Variant1(m),
+        }
+    }
+    
+}
+
+
+pub struct CaptureOuterAndLocalPayloadAnonInnerBodyMapper;
+impl View for CaptureOuterAndLocalPayloadAnonInnerBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureOuterAndLocalPayloadAnonInnerBodyMapper {
+    type Src = SpecCaptureOuterAndLocalPayloadAnonInnerBodyInner;
+    type Dst = SpecCaptureOuterAndLocalPayloadAnonInnerBody;
+}
+impl SpecIsoProof for CaptureOuterAndLocalPayloadAnonInnerBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureOuterAndLocalPayloadAnonInnerBodyMapper {
+    type Src = CaptureOuterAndLocalPayloadAnonInnerBodyInner<'a>;
+    type Dst = CaptureOuterAndLocalPayloadAnonInnerBody<'a>;
+    type RefSrc = CaptureOuterAndLocalPayloadAnonInnerBodyInnerRef<'a>;
+}
+
+type SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias1 = Choice<Cond<bytes::Variable>, Cond<SpecCaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator>>;
+pub struct SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinator(pub SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias);
+
+impl SpecCombinator for SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinator {
+    type Type = SpecCaptureOuterAndLocalPayloadAnonInnerBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias = Mapped<SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias1, CaptureOuterAndLocalPayloadAnonInnerBodyMapper>;
+type CaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias1 = Choice<Cond<bytes::Variable>, Cond<CaptureOuterAndLocalPayloadAnonInnerBodyChoice1Combinator>>;
+pub struct CaptureOuterAndLocalPayloadAnonInnerBodyCombinator1(pub CaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias1);
+impl View for CaptureOuterAndLocalPayloadAnonInnerBodyCombinator1 {
+    type V = SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CaptureOuterAndLocalPayloadAnonInnerBodyCombinator1, CaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias1);
+
+pub struct CaptureOuterAndLocalPayloadAnonInnerBodyCombinator(pub CaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias);
+
+impl View for CaptureOuterAndLocalPayloadAnonInnerBodyCombinator {
+    type V = SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadAnonInnerBodyCombinator {
+    type Type = CaptureOuterAndLocalPayloadAnonInnerBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureOuterAndLocalPayloadAnonInnerBodyCombinatorAlias = Mapped<CaptureOuterAndLocalPayloadAnonInnerBodyCombinator1, CaptureOuterAndLocalPayloadAnonInnerBodyMapper>;
+
+
+pub open spec fn spec_capture_outer_and_local_payload_anon_inner_body(frame_len: u8, tag: u8) -> SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinator {
+    SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinator(Mapped { inner: Choice(Cond { cond: tag == 0, inner: bytes::Variable(((usize::spec_from(frame_len) - 1)) as usize) }, Cond { cond: !(tag == 0), inner: spec_capture_outer_and_local_payload_anon_inner_body_choice1() }), mapper: CaptureOuterAndLocalPayloadAnonInnerBodyMapper })
+}
+
+pub fn capture_outer_and_local_payload_anon_inner_body<'a>(frame_len: u8, tag: u8) -> (o: CaptureOuterAndLocalPayloadAnonInnerBodyCombinator)
+    requires
+        ((frame_len) >= 1),
+
+    ensures o@ == spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureOuterAndLocalPayloadAnonInnerBodyCombinator(Mapped { inner: CaptureOuterAndLocalPayloadAnonInnerBodyCombinator1(Choice::new(Cond { cond: tag == 0, inner: bytes::Variable(((usize::ex_from(frame_len) - 1)) as usize) }, Cond { cond: !(tag == 0), inner: capture_outer_and_local_payload_anon_inner_body_choice1() })), mapper: CaptureOuterAndLocalPayloadAnonInnerBodyMapper });
+    // assert({
+    //     &&& combinator@ == spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_outer_and_local_payload_anon_inner_body<'a>(input: &'a [u8], frame_len: u8, tag: u8) -> (res: PResult<<CaptureOuterAndLocalPayloadAnonInnerBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((frame_len) >= 1),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).spec_parse(input@) is None,
+        spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_outer_and_local_payload_anon_inner_body( frame_len, tag );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_outer_and_local_payload_anon_inner_body<'a>(v: <CaptureOuterAndLocalPayloadAnonInnerBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, frame_len: u8, tag: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).wf(v@),
+        ((frame_len) >= 1),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).spec_serialize(v@).len() <= usize::MAX,
+        ((frame_len) >= 1),
+
+    ensures
+        serialize_len == spec_capture_outer_and_local_payload_anon_inner_body(frame_len@, tag@).spec_serialize(v@).len(),
+{
+    let combinator = capture_outer_and_local_payload_anon_inner_body( frame_len, tag );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecCaptureOuterAndLocalPayload {
+    pub tag: u8,
+    pub body: SpecCaptureOuterAndLocalPayloadAnonInnerBody,
+}
+
+pub type SpecCaptureOuterAndLocalPayloadInner = (u8, SpecCaptureOuterAndLocalPayloadAnonInnerBody);
+
+
+impl SpecFrom<SpecCaptureOuterAndLocalPayload> for SpecCaptureOuterAndLocalPayloadInner {
+    open spec fn spec_from(m: SpecCaptureOuterAndLocalPayload) -> SpecCaptureOuterAndLocalPayloadInner {
+        (m.tag, m.body)
+    }
+}
+
+impl SpecFrom<SpecCaptureOuterAndLocalPayloadInner> for SpecCaptureOuterAndLocalPayload {
+    open spec fn spec_from(m: SpecCaptureOuterAndLocalPayloadInner) -> SpecCaptureOuterAndLocalPayload {
+        let (tag, body) = m;
+        SpecCaptureOuterAndLocalPayload { tag, body }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CaptureOuterAndLocalPayload<'a> {
+    pub tag: u8,
+    pub body: CaptureOuterAndLocalPayloadAnonInnerBody<'a>,
+}
+
+impl View for CaptureOuterAndLocalPayload<'_> {
+    type V = SpecCaptureOuterAndLocalPayload;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCaptureOuterAndLocalPayload {
+            tag: self.tag@,
+            body: self.body@,
+        }
+    }
+}
+pub type CaptureOuterAndLocalPayloadInner<'a> = (u8, CaptureOuterAndLocalPayloadAnonInnerBody<'a>);
+
+pub type CaptureOuterAndLocalPayloadInnerRef<'a> = (&'a u8, &'a CaptureOuterAndLocalPayloadAnonInnerBody<'a>);
+impl<'a> From<&'a CaptureOuterAndLocalPayload<'a>> for CaptureOuterAndLocalPayloadInnerRef<'a> {
+    fn ex_from(m: &'a CaptureOuterAndLocalPayload) -> CaptureOuterAndLocalPayloadInnerRef<'a> {
+        (&m.tag, &m.body)
+    }
+}
+
+impl<'a> From<CaptureOuterAndLocalPayloadInner<'a>> for CaptureOuterAndLocalPayload<'a> {
+    fn ex_from(m: CaptureOuterAndLocalPayloadInner) -> CaptureOuterAndLocalPayload {
+        let (tag, body) = m;
+        CaptureOuterAndLocalPayload { tag, body }
+    }
+}
+
+pub struct CaptureOuterAndLocalPayloadMapper;
+impl View for CaptureOuterAndLocalPayloadMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureOuterAndLocalPayloadMapper {
+    type Src = SpecCaptureOuterAndLocalPayloadInner;
+    type Dst = SpecCaptureOuterAndLocalPayload;
+}
+impl SpecIsoProof for CaptureOuterAndLocalPayloadMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureOuterAndLocalPayloadMapper {
+    type Src = CaptureOuterAndLocalPayloadInner<'a>;
+    type Dst = CaptureOuterAndLocalPayload<'a>;
+    type RefSrc = CaptureOuterAndLocalPayloadInnerRef<'a>;
+}
+
+pub struct SpecCaptureOuterAndLocalPayloadCombinator(pub SpecCaptureOuterAndLocalPayloadCombinatorAlias);
+
+impl SpecCombinator for SpecCaptureOuterAndLocalPayloadCombinator {
+    type Type = SpecCaptureOuterAndLocalPayload;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureOuterAndLocalPayloadCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureOuterAndLocalPayloadCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureOuterAndLocalPayloadCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecPair<U8, SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinator>, CaptureOuterAndLocalPayloadMapper>>;
+
+pub struct CaptureOuterAndLocalPayloadCombinator(pub CaptureOuterAndLocalPayloadCombinatorAlias);
+
+impl View for CaptureOuterAndLocalPayloadCombinator {
+    type V = SpecCaptureOuterAndLocalPayloadCombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureOuterAndLocalPayloadCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalPayloadCombinator {
+    type Type = CaptureOuterAndLocalPayload<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureOuterAndLocalPayloadCombinatorAlias = AndThen<bytes::Variable, Mapped<Pair<U8, CaptureOuterAndLocalPayloadAnonInnerBodyCombinator, CaptureOuterAndLocalPayloadCont0>, CaptureOuterAndLocalPayloadMapper>>;
+
+
+pub open spec fn spec_capture_outer_and_local_payload(frame_len: u8) -> SpecCaptureOuterAndLocalPayloadCombinator {
+    SpecCaptureOuterAndLocalPayloadCombinator(AndThen(bytes::Variable((usize::spec_from(frame_len)) as usize), 
+    Mapped {
+        inner: Pair::spec_new(U8, |deps| spec_capture_outer_and_local_payload_cont0(frame_len, deps)),
+        mapper: CaptureOuterAndLocalPayloadMapper,
+    }))
+}
+
+pub open spec fn spec_capture_outer_and_local_payload_cont0(frame_len: u8, deps: u8) -> SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinator {
+    let tag = deps;
+    spec_capture_outer_and_local_payload_anon_inner_body(frame_len, tag)
+}
+
+impl View for CaptureOuterAndLocalPayloadCont0 {
+    type V = spec_fn(u8) -> SpecCaptureOuterAndLocalPayloadAnonInnerBodyCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_capture_outer_and_local_payload_cont0(self.frame_len@, deps)
+        }
+    }
+}
+
+pub fn capture_outer_and_local_payload<'a>(frame_len: u8) -> (o: CaptureOuterAndLocalPayloadCombinator)
+    requires
+        ((frame_len) >= 1),
+
+    ensures o@ == spec_capture_outer_and_local_payload(frame_len@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureOuterAndLocalPayloadCombinator(AndThen(bytes::Variable((usize::ex_from(frame_len)) as usize), 
+    Mapped {
+        inner: Pair::new(U8, CaptureOuterAndLocalPayloadCont0 { frame_len }),
+        mapper: CaptureOuterAndLocalPayloadMapper,
+    }));
+    // assert({
+    //     &&& combinator@ == spec_capture_outer_and_local_payload(frame_len@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_outer_and_local_payload<'a>(input: &'a [u8], frame_len: u8) -> (res: PResult<<CaptureOuterAndLocalPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((frame_len) >= 1),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_outer_and_local_payload(frame_len@).spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_outer_and_local_payload(frame_len@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_outer_and_local_payload(frame_len@).spec_parse(input@) is None,
+        spec_capture_outer_and_local_payload(frame_len@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_outer_and_local_payload( frame_len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_outer_and_local_payload<'a>(v: <CaptureOuterAndLocalPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, frame_len: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_outer_and_local_payload(frame_len@).wf(v@),
+        ((frame_len) >= 1),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_capture_outer_and_local_payload(frame_len@).spec_serialize(v@).len() <= usize::MAX,
+        ((frame_len) >= 1),
+
+    ensures
+        serialize_len == spec_capture_outer_and_local_payload(frame_len@).spec_serialize(v@).len(),
+{
+    let combinator = capture_outer_and_local_payload( frame_len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct CaptureOuterAndLocalPayloadCont0 {
+    pub frame_len: u8,
+}
+type CaptureOuterAndLocalPayloadCont0Type<'a, 'b> = &'b u8;
+type CaptureOuterAndLocalPayloadCont0SType<'a, 'x> = &'x u8;
+type CaptureOuterAndLocalPayloadCont0Input<'a, 'b, 'x> = POrSType<CaptureOuterAndLocalPayloadCont0Type<'a, 'b>, CaptureOuterAndLocalPayloadCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CaptureOuterAndLocalPayloadCont0Input<'a, 'b, 'x>> for CaptureOuterAndLocalPayloadCont0 {
+    type Output = CaptureOuterAndLocalPayloadAnonInnerBodyCombinator;
+
+    open spec fn requires(&self, deps: CaptureOuterAndLocalPayloadCont0Input<'a, 'b, 'x>) -> bool {        let frame_len = self.frame_len@;
+
+        &&& ((self.frame_len@) >= 1)
+        &&& (U8).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CaptureOuterAndLocalPayloadCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_capture_outer_and_local_payload_cont0(self.frame_len@, deps@)
+    }
+
+    fn apply(&self, deps: CaptureOuterAndLocalPayloadCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let tag = deps;
+                let frame_len = self.frame_len;
+                let tag = *tag;
+                capture_outer_and_local_payload_anon_inner_body(frame_len, tag)
+            }
+            POrSType::S(deps) => {
+                let tag = deps;
+                let frame_len = self.frame_len;
+                let tag = *tag;
+                capture_outer_and_local_payload_anon_inner_body(frame_len, tag)
+            }
+        }
+    }
+}
+
+pub struct SpecCaptureOuterAndLocal {
+    pub frame_len: u8,
+    pub payload: SpecCaptureOuterAndLocalPayload,
+}
+
+pub type SpecCaptureOuterAndLocalInner = (u8, SpecCaptureOuterAndLocalPayload);
+
+
+impl SpecFrom<SpecCaptureOuterAndLocal> for SpecCaptureOuterAndLocalInner {
+    open spec fn spec_from(m: SpecCaptureOuterAndLocal) -> SpecCaptureOuterAndLocalInner {
+        (m.frame_len, m.payload)
+    }
+}
+
+impl SpecFrom<SpecCaptureOuterAndLocalInner> for SpecCaptureOuterAndLocal {
+    open spec fn spec_from(m: SpecCaptureOuterAndLocalInner) -> SpecCaptureOuterAndLocal {
+        let (frame_len, payload) = m;
+        SpecCaptureOuterAndLocal { frame_len, payload }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CaptureOuterAndLocal<'a> {
+    pub frame_len: u8,
+    pub payload: CaptureOuterAndLocalPayload<'a>,
+}
+
+impl View for CaptureOuterAndLocal<'_> {
+    type V = SpecCaptureOuterAndLocal;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCaptureOuterAndLocal {
+            frame_len: self.frame_len@,
+            payload: self.payload@,
+        }
+    }
+}
+pub type CaptureOuterAndLocalInner<'a> = (u8, CaptureOuterAndLocalPayload<'a>);
+
+pub type CaptureOuterAndLocalInnerRef<'a> = (&'a u8, &'a CaptureOuterAndLocalPayload<'a>);
+impl<'a> From<&'a CaptureOuterAndLocal<'a>> for CaptureOuterAndLocalInnerRef<'a> {
+    fn ex_from(m: &'a CaptureOuterAndLocal) -> CaptureOuterAndLocalInnerRef<'a> {
+        (&m.frame_len, &m.payload)
+    }
+}
+
+impl<'a> From<CaptureOuterAndLocalInner<'a>> for CaptureOuterAndLocal<'a> {
+    fn ex_from(m: CaptureOuterAndLocalInner) -> CaptureOuterAndLocal {
+        let (frame_len, payload) = m;
+        CaptureOuterAndLocal { frame_len, payload }
+    }
+}
+
+pub struct CaptureOuterAndLocalMapper;
+impl View for CaptureOuterAndLocalMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureOuterAndLocalMapper {
+    type Src = SpecCaptureOuterAndLocalInner;
+    type Dst = SpecCaptureOuterAndLocal;
+}
+impl SpecIsoProof for CaptureOuterAndLocalMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureOuterAndLocalMapper {
+    type Src = CaptureOuterAndLocalInner<'a>;
+    type Dst = CaptureOuterAndLocal<'a>;
+    type RefSrc = CaptureOuterAndLocalInnerRef<'a>;
+}
+
+pub struct SpecCaptureOuterAndLocalCombinator(pub SpecCaptureOuterAndLocalCombinatorAlias);
+
+impl SpecCombinator for SpecCaptureOuterAndLocalCombinator {
+    type Type = SpecCaptureOuterAndLocal;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureOuterAndLocalCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureOuterAndLocalCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureOuterAndLocalCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate2172399096230090262>, SpecCaptureOuterAndLocalPayloadCombinator>, CaptureOuterAndLocalMapper>;
+pub struct Predicate2172399096230090262;
+impl View for Predicate2172399096230090262 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate2172399096230090262 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 1)
+    }
+}
+impl SpecPred<u8> for Predicate2172399096230090262 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 1)
+    }
+}
+
+pub struct CaptureOuterAndLocalCombinator(pub CaptureOuterAndLocalCombinatorAlias);
+
+impl View for CaptureOuterAndLocalCombinator {
+    type V = SpecCaptureOuterAndLocalCombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureOuterAndLocalCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureOuterAndLocalCombinator {
+    type Type = CaptureOuterAndLocal<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureOuterAndLocalCombinatorAlias = Mapped<Pair<Refined<U8, Predicate2172399096230090262>, CaptureOuterAndLocalPayloadCombinator, CaptureOuterAndLocalCont0>, CaptureOuterAndLocalMapper>;
+
+
+pub open spec fn spec_capture_outer_and_local() -> SpecCaptureOuterAndLocalCombinator {
+    SpecCaptureOuterAndLocalCombinator(
+    Mapped {
+        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate2172399096230090262 }, |deps| spec_capture_outer_and_local_cont0(deps)),
+        mapper: CaptureOuterAndLocalMapper,
+    })
+}
+
+pub open spec fn spec_capture_outer_and_local_cont0(deps: u8) -> SpecCaptureOuterAndLocalPayloadCombinator {
+    let frame_len = deps;
+    spec_capture_outer_and_local_payload(frame_len)
+}
+
+impl View for CaptureOuterAndLocalCont0 {
+    type V = spec_fn(u8) -> SpecCaptureOuterAndLocalPayloadCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_capture_outer_and_local_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn capture_outer_and_local<'a>() -> (o: CaptureOuterAndLocalCombinator)
+    ensures o@ == spec_capture_outer_and_local(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureOuterAndLocalCombinator(
+    Mapped {
+        inner: Pair::new(Refined { inner: U8, predicate: Predicate2172399096230090262 }, CaptureOuterAndLocalCont0),
+        mapper: CaptureOuterAndLocalMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_capture_outer_and_local()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_outer_and_local<'a>(input: &'a [u8]) -> (res: PResult<<CaptureOuterAndLocalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_outer_and_local().spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_outer_and_local().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_outer_and_local().spec_parse(input@) is None,
+        spec_capture_outer_and_local().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_outer_and_local();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_outer_and_local<'a>(v: <CaptureOuterAndLocalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_outer_and_local().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_capture_outer_and_local().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_capture_outer_and_local().spec_serialize(v@).len(),
+{
+    let combinator = capture_outer_and_local();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct CaptureOuterAndLocalCont0;
+type CaptureOuterAndLocalCont0Type<'a, 'b> = &'b u8;
+type CaptureOuterAndLocalCont0SType<'a, 'x> = &'x u8;
+type CaptureOuterAndLocalCont0Input<'a, 'b, 'x> = POrSType<CaptureOuterAndLocalCont0Type<'a, 'b>, CaptureOuterAndLocalCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CaptureOuterAndLocalCont0Input<'a, 'b, 'x>> for CaptureOuterAndLocalCont0 {
+    type Output = CaptureOuterAndLocalPayloadCombinator;
+
+    open spec fn requires(&self, deps: CaptureOuterAndLocalCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U8, predicate: Predicate2172399096230090262 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CaptureOuterAndLocalCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_capture_outer_and_local_cont0(deps@)
+    }
+
+    fn apply(&self, deps: CaptureOuterAndLocalCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let frame_len = deps;
+                let frame_len = *frame_len;
+                capture_outer_and_local_payload(frame_len)
+            }
+            POrSType::S(deps) => {
+                let frame_len = deps;
+                let frame_len = *frame_len;
+                capture_outer_and_local_payload(frame_len)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecNestedInnerStructAnonInner {
+    pub x: u8,
+    pub y: Seq<u8>,
+}
+
+pub type SpecNestedInnerStructAnonInnerInner = (u8, Seq<u8>);
+
+
+impl SpecFrom<SpecNestedInnerStructAnonInner> for SpecNestedInnerStructAnonInnerInner {
+    open spec fn spec_from(m: SpecNestedInnerStructAnonInner) -> SpecNestedInnerStructAnonInnerInner {
+        (m.x, m.y)
+    }
+}
+
+impl SpecFrom<SpecNestedInnerStructAnonInnerInner> for SpecNestedInnerStructAnonInner {
+    open spec fn spec_from(m: SpecNestedInnerStructAnonInnerInner) -> SpecNestedInnerStructAnonInner {
+        let (x, y) = m;
+        SpecNestedInnerStructAnonInner { x, y }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct NestedInnerStructAnonInner<'a> {
+    pub x: u8,
+    pub y: &'a [u8],
+}
+
+impl View for NestedInnerStructAnonInner<'_> {
+    type V = SpecNestedInnerStructAnonInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecNestedInnerStructAnonInner {
+            x: self.x@,
+            y: self.y@,
+        }
+    }
+}
+pub type NestedInnerStructAnonInnerInner<'a> = (u8, &'a [u8]);
+
+pub type NestedInnerStructAnonInnerInnerRef<'a> = (&'a u8, &'a &'a [u8]);
+impl<'a> From<&'a NestedInnerStructAnonInner<'a>> for NestedInnerStructAnonInnerInnerRef<'a> {
+    fn ex_from(m: &'a NestedInnerStructAnonInner) -> NestedInnerStructAnonInnerInnerRef<'a> {
+        (&m.x, &m.y)
+    }
+}
+
+impl<'a> From<NestedInnerStructAnonInnerInner<'a>> for NestedInnerStructAnonInner<'a> {
+    fn ex_from(m: NestedInnerStructAnonInnerInner) -> NestedInnerStructAnonInner {
+        let (x, y) = m;
+        NestedInnerStructAnonInner { x, y }
+    }
+}
+
+pub struct NestedInnerStructAnonInnerMapper;
+impl View for NestedInnerStructAnonInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for NestedInnerStructAnonInnerMapper {
+    type Src = SpecNestedInnerStructAnonInnerInner;
+    type Dst = SpecNestedInnerStructAnonInner;
+}
+impl SpecIsoProof for NestedInnerStructAnonInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for NestedInnerStructAnonInnerMapper {
+    type Src = NestedInnerStructAnonInnerInner<'a>;
+    type Dst = NestedInnerStructAnonInner<'a>;
+    type RefSrc = NestedInnerStructAnonInnerInnerRef<'a>;
+}
+type SpecNestedInnerStructAnonInnerCombinatorAlias1 = (U8, bytes::Tail);
+pub struct SpecNestedInnerStructAnonInnerCombinator(pub SpecNestedInnerStructAnonInnerCombinatorAlias);
+
+impl SpecCombinator for SpecNestedInnerStructAnonInnerCombinator {
+    type Type = SpecNestedInnerStructAnonInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNestedInnerStructAnonInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNestedInnerStructAnonInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNestedInnerStructAnonInnerCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecNestedInnerStructAnonInnerCombinatorAlias1, NestedInnerStructAnonInnerMapper>>;
+type NestedInnerStructAnonInnerCombinatorAlias1 = (U8, bytes::Tail);
+pub struct NestedInnerStructAnonInnerCombinator1(pub NestedInnerStructAnonInnerCombinatorAlias1);
+impl View for NestedInnerStructAnonInnerCombinator1 {
+    type V = SpecNestedInnerStructAnonInnerCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(NestedInnerStructAnonInnerCombinator1, NestedInnerStructAnonInnerCombinatorAlias1);
+
+pub struct NestedInnerStructAnonInnerCombinator(pub NestedInnerStructAnonInnerCombinatorAlias);
+
+impl View for NestedInnerStructAnonInnerCombinator {
+    type V = SpecNestedInnerStructAnonInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecNestedInnerStructAnonInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerStructAnonInnerCombinator {
+    type Type = NestedInnerStructAnonInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NestedInnerStructAnonInnerCombinatorAlias = AndThen<bytes::Variable, Mapped<NestedInnerStructAnonInnerCombinator1, NestedInnerStructAnonInnerMapper>>;
+
+
+pub open spec fn spec_nested_inner_struct_anon_inner(len: u32) -> SpecNestedInnerStructAnonInnerCombinator {
+    SpecNestedInnerStructAnonInnerCombinator(AndThen(bytes::Variable((usize::spec_from(len)) as usize), 
+    Mapped {
+        inner: (U8, bytes::Tail),
+        mapper: NestedInnerStructAnonInnerMapper,
+    }))
+}
+
+pub fn nested_inner_struct_anon_inner<'a>(len: u32) -> (o: NestedInnerStructAnonInnerCombinator)
+
+    ensures o@ == spec_nested_inner_struct_anon_inner(len@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NestedInnerStructAnonInnerCombinator(AndThen(bytes::Variable((usize::ex_from(len)) as usize), 
+    Mapped {
+        inner: NestedInnerStructAnonInnerCombinator1((U8, bytes::Tail)),
+        mapper: NestedInnerStructAnonInnerMapper,
+    }));
+    // assert({
+    //     &&& combinator@ == spec_nested_inner_struct_anon_inner(len@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_nested_inner_struct_anon_inner<'a>(input: &'a [u8], len: u32) -> (res: PResult<<NestedInnerStructAnonInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+
+    ensures
+        res matches Ok((n, v)) ==> spec_nested_inner_struct_anon_inner(len@).spec_parse(input@) == Some((n as int, v@)),
+        spec_nested_inner_struct_anon_inner(len@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_nested_inner_struct_anon_inner(len@).spec_parse(input@) is None,
+        spec_nested_inner_struct_anon_inner(len@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = nested_inner_struct_anon_inner( len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_nested_inner_struct_anon_inner<'a>(v: <NestedInnerStructAnonInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, len: u32) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_nested_inner_struct_anon_inner(len@).wf(v@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_nested_inner_struct_anon_inner(len@).spec_serialize(v@).len() <= usize::MAX,
+
+    ensures
+        serialize_len == spec_nested_inner_struct_anon_inner(len@).spec_serialize(v@).len(),
+{
+    let combinator = nested_inner_struct_anon_inner( len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecCaptureLocalInAnonStructWrapperValueChoice0 {
+    pub len: u8,
+    pub bytes: Seq<u8>,
+}
+
+pub type SpecCaptureLocalInAnonStructWrapperValueChoice0Inner = (u8, Seq<u8>);
+
+
+impl SpecFrom<SpecCaptureLocalInAnonStructWrapperValueChoice0> for SpecCaptureLocalInAnonStructWrapperValueChoice0Inner {
+    open spec fn spec_from(m: SpecCaptureLocalInAnonStructWrapperValueChoice0) -> SpecCaptureLocalInAnonStructWrapperValueChoice0Inner {
+        (m.len, m.bytes)
+    }
+}
+
+impl SpecFrom<SpecCaptureLocalInAnonStructWrapperValueChoice0Inner> for SpecCaptureLocalInAnonStructWrapperValueChoice0 {
+    open spec fn spec_from(m: SpecCaptureLocalInAnonStructWrapperValueChoice0Inner) -> SpecCaptureLocalInAnonStructWrapperValueChoice0 {
+        let (len, bytes) = m;
+        SpecCaptureLocalInAnonStructWrapperValueChoice0 { len, bytes }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CaptureLocalInAnonStructWrapperValueChoice0<'a> {
+    pub len: u8,
+    pub bytes: &'a [u8],
+}
+
+impl View for CaptureLocalInAnonStructWrapperValueChoice0<'_> {
+    type V = SpecCaptureLocalInAnonStructWrapperValueChoice0;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCaptureLocalInAnonStructWrapperValueChoice0 {
+            len: self.len@,
+            bytes: self.bytes@,
+        }
+    }
+}
+pub type CaptureLocalInAnonStructWrapperValueChoice0Inner<'a> = (u8, &'a [u8]);
+
+pub type CaptureLocalInAnonStructWrapperValueChoice0InnerRef<'a> = (&'a u8, &'a &'a [u8]);
+impl<'a> From<&'a CaptureLocalInAnonStructWrapperValueChoice0<'a>> for CaptureLocalInAnonStructWrapperValueChoice0InnerRef<'a> {
+    fn ex_from(m: &'a CaptureLocalInAnonStructWrapperValueChoice0) -> CaptureLocalInAnonStructWrapperValueChoice0InnerRef<'a> {
+        (&m.len, &m.bytes)
+    }
+}
+
+impl<'a> From<CaptureLocalInAnonStructWrapperValueChoice0Inner<'a>> for CaptureLocalInAnonStructWrapperValueChoice0<'a> {
+    fn ex_from(m: CaptureLocalInAnonStructWrapperValueChoice0Inner) -> CaptureLocalInAnonStructWrapperValueChoice0 {
+        let (len, bytes) = m;
+        CaptureLocalInAnonStructWrapperValueChoice0 { len, bytes }
+    }
+}
+
+pub struct CaptureLocalInAnonStructWrapperValueChoice0Mapper;
+impl View for CaptureLocalInAnonStructWrapperValueChoice0Mapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureLocalInAnonStructWrapperValueChoice0Mapper {
+    type Src = SpecCaptureLocalInAnonStructWrapperValueChoice0Inner;
+    type Dst = SpecCaptureLocalInAnonStructWrapperValueChoice0;
+}
+impl SpecIsoProof for CaptureLocalInAnonStructWrapperValueChoice0Mapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureLocalInAnonStructWrapperValueChoice0Mapper {
+    type Src = CaptureLocalInAnonStructWrapperValueChoice0Inner<'a>;
+    type Dst = CaptureLocalInAnonStructWrapperValueChoice0<'a>;
+    type RefSrc = CaptureLocalInAnonStructWrapperValueChoice0InnerRef<'a>;
+}
+
+pub struct SpecCaptureLocalInAnonStructWrapperValueChoice0Combinator(pub SpecCaptureLocalInAnonStructWrapperValueChoice0CombinatorAlias);
+
+impl SpecCombinator for SpecCaptureLocalInAnonStructWrapperValueChoice0Combinator {
+    type Type = SpecCaptureLocalInAnonStructWrapperValueChoice0;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureLocalInAnonStructWrapperValueChoice0Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureLocalInAnonStructWrapperValueChoice0CombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureLocalInAnonStructWrapperValueChoice0CombinatorAlias = Mapped<SpecPair<U8, bytes::Variable>, CaptureLocalInAnonStructWrapperValueChoice0Mapper>;
+
+pub struct CaptureLocalInAnonStructWrapperValueChoice0Combinator(pub CaptureLocalInAnonStructWrapperValueChoice0CombinatorAlias);
+
+impl View for CaptureLocalInAnonStructWrapperValueChoice0Combinator {
+    type V = SpecCaptureLocalInAnonStructWrapperValueChoice0Combinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureLocalInAnonStructWrapperValueChoice0Combinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperValueChoice0Combinator {
+    type Type = CaptureLocalInAnonStructWrapperValueChoice0<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureLocalInAnonStructWrapperValueChoice0CombinatorAlias = Mapped<Pair<U8, bytes::Variable, CaptureLocalInAnonStructWrapperValueChoice0Cont0>, CaptureLocalInAnonStructWrapperValueChoice0Mapper>;
+
+
+pub open spec fn spec_capture_local_in_anon_struct_wrapper_value_choice0() -> SpecCaptureLocalInAnonStructWrapperValueChoice0Combinator {
+    SpecCaptureLocalInAnonStructWrapperValueChoice0Combinator(
+    Mapped {
+        inner: Pair::spec_new(U8, |deps| spec_capture_local_in_anon_struct_wrapper_value_choice0_cont0(deps)),
+        mapper: CaptureLocalInAnonStructWrapperValueChoice0Mapper,
+    })
+}
+
+pub open spec fn spec_capture_local_in_anon_struct_wrapper_value_choice0_cont0(deps: u8) -> bytes::Variable {
+    let len = deps;
+    bytes::Variable((usize::spec_from(len)) as usize)
+}
+
+impl View for CaptureLocalInAnonStructWrapperValueChoice0Cont0 {
+    type V = spec_fn(u8) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_capture_local_in_anon_struct_wrapper_value_choice0_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn capture_local_in_anon_struct_wrapper_value_choice0<'a>() -> (o: CaptureLocalInAnonStructWrapperValueChoice0Combinator)
+    ensures o@ == spec_capture_local_in_anon_struct_wrapper_value_choice0(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureLocalInAnonStructWrapperValueChoice0Combinator(
+    Mapped {
+        inner: Pair::new(U8, CaptureLocalInAnonStructWrapperValueChoice0Cont0),
+        mapper: CaptureLocalInAnonStructWrapperValueChoice0Mapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_capture_local_in_anon_struct_wrapper_value_choice0()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_local_in_anon_struct_wrapper_value_choice0<'a>(input: &'a [u8]) -> (res: PResult<<CaptureLocalInAnonStructWrapperValueChoice0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_local_in_anon_struct_wrapper_value_choice0().spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_local_in_anon_struct_wrapper_value_choice0().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_local_in_anon_struct_wrapper_value_choice0().spec_parse(input@) is None,
+        spec_capture_local_in_anon_struct_wrapper_value_choice0().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_local_in_anon_struct_wrapper_value_choice0();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_local_in_anon_struct_wrapper_value_choice0<'a>(v: <CaptureLocalInAnonStructWrapperValueChoice0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_local_in_anon_struct_wrapper_value_choice0().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_capture_local_in_anon_struct_wrapper_value_choice0().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_capture_local_in_anon_struct_wrapper_value_choice0().spec_serialize(v@).len(),
+{
+    let combinator = capture_local_in_anon_struct_wrapper_value_choice0();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct CaptureLocalInAnonStructWrapperValueChoice0Cont0;
+type CaptureLocalInAnonStructWrapperValueChoice0Cont0Type<'a, 'b> = &'b u8;
+type CaptureLocalInAnonStructWrapperValueChoice0Cont0SType<'a, 'x> = &'x u8;
+type CaptureLocalInAnonStructWrapperValueChoice0Cont0Input<'a, 'b, 'x> = POrSType<CaptureLocalInAnonStructWrapperValueChoice0Cont0Type<'a, 'b>, CaptureLocalInAnonStructWrapperValueChoice0Cont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CaptureLocalInAnonStructWrapperValueChoice0Cont0Input<'a, 'b, 'x>> for CaptureLocalInAnonStructWrapperValueChoice0Cont0 {
+    type Output = bytes::Variable;
+
+    open spec fn requires(&self, deps: CaptureLocalInAnonStructWrapperValueChoice0Cont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U8).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CaptureLocalInAnonStructWrapperValueChoice0Cont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_capture_local_in_anon_struct_wrapper_value_choice0_cont0(deps@)
+    }
+
+    fn apply(&self, deps: CaptureLocalInAnonStructWrapperValueChoice0Cont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let len = deps;
+                let len = *len;
+                bytes::Variable((usize::ex_from(len)) as usize)
+            }
+            POrSType::S(deps) => {
+                let len = deps;
+                let len = *len;
+                bytes::Variable((usize::ex_from(len)) as usize)
+            }
+        }
+    }
+}
+                
+
+pub enum SpecCaptureLocalInAnonStructWrapperValue {
+    Variant0(SpecCaptureLocalInAnonStructWrapperValueChoice0),
+    Variant1(u16),
+}
+
+pub type SpecCaptureLocalInAnonStructWrapperValueInner = Either<SpecCaptureLocalInAnonStructWrapperValueChoice0, u16>;
+
+impl SpecFrom<SpecCaptureLocalInAnonStructWrapperValue> for SpecCaptureLocalInAnonStructWrapperValueInner {
+    open spec fn spec_from(m: SpecCaptureLocalInAnonStructWrapperValue) -> SpecCaptureLocalInAnonStructWrapperValueInner {
+        match m {
+            SpecCaptureLocalInAnonStructWrapperValue::Variant0(m) => Either::Left(m),
+            SpecCaptureLocalInAnonStructWrapperValue::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecCaptureLocalInAnonStructWrapperValueInner> for SpecCaptureLocalInAnonStructWrapperValue {
+    open spec fn spec_from(m: SpecCaptureLocalInAnonStructWrapperValueInner) -> SpecCaptureLocalInAnonStructWrapperValue {
+        match m {
+            Either::Left(m) => SpecCaptureLocalInAnonStructWrapperValue::Variant0(m),
+            Either::Right(m) => SpecCaptureLocalInAnonStructWrapperValue::Variant1(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CaptureLocalInAnonStructWrapperValue<'a> {
+    Variant0(CaptureLocalInAnonStructWrapperValueChoice0<'a>),
+    Variant1(u16),
+}
+
+pub type CaptureLocalInAnonStructWrapperValueInner<'a> = Either<CaptureLocalInAnonStructWrapperValueChoice0<'a>, u16>;
+
+pub type CaptureLocalInAnonStructWrapperValueInnerRef<'a> = Either<&'a CaptureLocalInAnonStructWrapperValueChoice0<'a>, &'a u16>;
+
+
+impl<'a> View for CaptureLocalInAnonStructWrapperValue<'a> {
+    type V = SpecCaptureLocalInAnonStructWrapperValue;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            CaptureLocalInAnonStructWrapperValue::Variant0(m) => SpecCaptureLocalInAnonStructWrapperValue::Variant0(m@),
+            CaptureLocalInAnonStructWrapperValue::Variant1(m) => SpecCaptureLocalInAnonStructWrapperValue::Variant1(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a CaptureLocalInAnonStructWrapperValue<'a>> for CaptureLocalInAnonStructWrapperValueInnerRef<'a> {
+    fn ex_from(m: &'a CaptureLocalInAnonStructWrapperValue<'a>) -> CaptureLocalInAnonStructWrapperValueInnerRef<'a> {
+        match m {
+            CaptureLocalInAnonStructWrapperValue::Variant0(m) => Either::Left(m),
+            CaptureLocalInAnonStructWrapperValue::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+impl<'a> From<CaptureLocalInAnonStructWrapperValueInner<'a>> for CaptureLocalInAnonStructWrapperValue<'a> {
+    fn ex_from(m: CaptureLocalInAnonStructWrapperValueInner<'a>) -> CaptureLocalInAnonStructWrapperValue<'a> {
+        match m {
+            Either::Left(m) => CaptureLocalInAnonStructWrapperValue::Variant0(m),
+            Either::Right(m) => CaptureLocalInAnonStructWrapperValue::Variant1(m),
+        }
+    }
+    
+}
+
+
+pub struct CaptureLocalInAnonStructWrapperValueMapper;
+impl View for CaptureLocalInAnonStructWrapperValueMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureLocalInAnonStructWrapperValueMapper {
+    type Src = SpecCaptureLocalInAnonStructWrapperValueInner;
+    type Dst = SpecCaptureLocalInAnonStructWrapperValue;
+}
+impl SpecIsoProof for CaptureLocalInAnonStructWrapperValueMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureLocalInAnonStructWrapperValueMapper {
+    type Src = CaptureLocalInAnonStructWrapperValueInner<'a>;
+    type Dst = CaptureLocalInAnonStructWrapperValue<'a>;
+    type RefSrc = CaptureLocalInAnonStructWrapperValueInnerRef<'a>;
+}
+
+type SpecCaptureLocalInAnonStructWrapperValueCombinatorAlias1 = Choice<Cond<SpecCaptureLocalInAnonStructWrapperValueChoice0Combinator>, Cond<U16Le>>;
+pub struct SpecCaptureLocalInAnonStructWrapperValueCombinator(pub SpecCaptureLocalInAnonStructWrapperValueCombinatorAlias);
+
+impl SpecCombinator for SpecCaptureLocalInAnonStructWrapperValueCombinator {
+    type Type = SpecCaptureLocalInAnonStructWrapperValue;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureLocalInAnonStructWrapperValueCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureLocalInAnonStructWrapperValueCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureLocalInAnonStructWrapperValueCombinatorAlias = Mapped<SpecCaptureLocalInAnonStructWrapperValueCombinatorAlias1, CaptureLocalInAnonStructWrapperValueMapper>;
+type CaptureLocalInAnonStructWrapperValueCombinatorAlias1 = Choice<Cond<CaptureLocalInAnonStructWrapperValueChoice0Combinator>, Cond<U16Le>>;
+pub struct CaptureLocalInAnonStructWrapperValueCombinator1(pub CaptureLocalInAnonStructWrapperValueCombinatorAlias1);
+impl View for CaptureLocalInAnonStructWrapperValueCombinator1 {
+    type V = SpecCaptureLocalInAnonStructWrapperValueCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CaptureLocalInAnonStructWrapperValueCombinator1, CaptureLocalInAnonStructWrapperValueCombinatorAlias1);
+
+pub struct CaptureLocalInAnonStructWrapperValueCombinator(pub CaptureLocalInAnonStructWrapperValueCombinatorAlias);
+
+impl View for CaptureLocalInAnonStructWrapperValueCombinator {
+    type V = SpecCaptureLocalInAnonStructWrapperValueCombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureLocalInAnonStructWrapperValueCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperValueCombinator {
+    type Type = CaptureLocalInAnonStructWrapperValue<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureLocalInAnonStructWrapperValueCombinatorAlias = Mapped<CaptureLocalInAnonStructWrapperValueCombinator1, CaptureLocalInAnonStructWrapperValueMapper>;
+
+
+pub open spec fn spec_capture_local_in_anon_struct_wrapper_value(tag: u8) -> SpecCaptureLocalInAnonStructWrapperValueCombinator {
+    SpecCaptureLocalInAnonStructWrapperValueCombinator(Mapped { inner: Choice(Cond { cond: tag == 0, inner: spec_capture_local_in_anon_struct_wrapper_value_choice0() }, Cond { cond: !(tag == 0), inner: U16Le }), mapper: CaptureLocalInAnonStructWrapperValueMapper })
+}
+
+pub fn capture_local_in_anon_struct_wrapper_value<'a>(tag: u8) -> (o: CaptureLocalInAnonStructWrapperValueCombinator)
+
+    ensures o@ == spec_capture_local_in_anon_struct_wrapper_value(tag@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureLocalInAnonStructWrapperValueCombinator(Mapped { inner: CaptureLocalInAnonStructWrapperValueCombinator1(Choice::new(Cond { cond: tag == 0, inner: capture_local_in_anon_struct_wrapper_value_choice0() }, Cond { cond: !(tag == 0), inner: U16Le })), mapper: CaptureLocalInAnonStructWrapperValueMapper });
+    // assert({
+    //     &&& combinator@ == spec_capture_local_in_anon_struct_wrapper_value(tag@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_local_in_anon_struct_wrapper_value<'a>(input: &'a [u8], tag: u8) -> (res: PResult<<CaptureLocalInAnonStructWrapperValueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_local_in_anon_struct_wrapper_value(tag@).spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_local_in_anon_struct_wrapper_value(tag@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_local_in_anon_struct_wrapper_value(tag@).spec_parse(input@) is None,
+        spec_capture_local_in_anon_struct_wrapper_value(tag@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_local_in_anon_struct_wrapper_value( tag );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_local_in_anon_struct_wrapper_value<'a>(v: <CaptureLocalInAnonStructWrapperValueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, tag: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_local_in_anon_struct_wrapper_value(tag@).wf(v@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_capture_local_in_anon_struct_wrapper_value(tag@).spec_serialize(v@).len() <= usize::MAX,
+
+    ensures
+        serialize_len == spec_capture_local_in_anon_struct_wrapper_value(tag@).spec_serialize(v@).len(),
+{
+    let combinator = capture_local_in_anon_struct_wrapper_value( tag );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub enum SpecNestedInnerChoiceX {
+    A(SpecNestedInnerChoiceXA),
+    B(u32),
+}
+
+pub type SpecNestedInnerChoiceXInner = Either<SpecNestedInnerChoiceXA, u32>;
+
+impl SpecFrom<SpecNestedInnerChoiceX> for SpecNestedInnerChoiceXInner {
+    open spec fn spec_from(m: SpecNestedInnerChoiceX) -> SpecNestedInnerChoiceXInner {
+        match m {
+            SpecNestedInnerChoiceX::A(m) => Either::Left(m),
+            SpecNestedInnerChoiceX::B(m) => Either::Right(m),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecNestedInnerChoiceXInner> for SpecNestedInnerChoiceX {
+    open spec fn spec_from(m: SpecNestedInnerChoiceXInner) -> SpecNestedInnerChoiceX {
+        match m {
+            Either::Left(m) => SpecNestedInnerChoiceX::A(m),
+            Either::Right(m) => SpecNestedInnerChoiceX::B(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum NestedInnerChoiceX {
+    A(NestedInnerChoiceXA),
+    B(u32),
+}
+
+pub type NestedInnerChoiceXInner = Either<NestedInnerChoiceXA, u32>;
+
+pub type NestedInnerChoiceXInnerRef<'a> = Either<&'a NestedInnerChoiceXA, &'a u32>;
+
+
+impl View for NestedInnerChoiceX {
+    type V = SpecNestedInnerChoiceX;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            NestedInnerChoiceX::A(m) => SpecNestedInnerChoiceX::A(m@),
+            NestedInnerChoiceX::B(m) => SpecNestedInnerChoiceX::B(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a NestedInnerChoiceX> for NestedInnerChoiceXInnerRef<'a> {
+    fn ex_from(m: &'a NestedInnerChoiceX) -> NestedInnerChoiceXInnerRef<'a> {
+        match m {
+            NestedInnerChoiceX::A(m) => Either::Left(m),
+            NestedInnerChoiceX::B(m) => Either::Right(m),
+        }
+    }
+
+}
+
+impl From<NestedInnerChoiceXInner> for NestedInnerChoiceX {
+    fn ex_from(m: NestedInnerChoiceXInner) -> NestedInnerChoiceX {
+        match m {
+            Either::Left(m) => NestedInnerChoiceX::A(m),
+            Either::Right(m) => NestedInnerChoiceX::B(m),
+        }
+    }
+    
+}
+
+
+pub struct NestedInnerChoiceXMapper;
+impl View for NestedInnerChoiceXMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for NestedInnerChoiceXMapper {
+    type Src = SpecNestedInnerChoiceXInner;
+    type Dst = SpecNestedInnerChoiceX;
+}
+impl SpecIsoProof for NestedInnerChoiceXMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for NestedInnerChoiceXMapper {
+    type Src = NestedInnerChoiceXInner;
+    type Dst = NestedInnerChoiceX;
+    type RefSrc = NestedInnerChoiceXInnerRef<'a>;
+}
+
+type SpecNestedInnerChoiceXCombinatorAlias1 = Choice<Cond<SpecNestedInnerChoiceXACombinator>, Cond<U32Le>>;
+pub struct SpecNestedInnerChoiceXCombinator(pub SpecNestedInnerChoiceXCombinatorAlias);
+
+impl SpecCombinator for SpecNestedInnerChoiceXCombinator {
+    type Type = SpecNestedInnerChoiceX;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNestedInnerChoiceXCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNestedInnerChoiceXCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNestedInnerChoiceXCombinatorAlias = Mapped<SpecNestedInnerChoiceXCombinatorAlias1, NestedInnerChoiceXMapper>;
+type NestedInnerChoiceXCombinatorAlias1 = Choice<Cond<NestedInnerChoiceXACombinator>, Cond<U32Le>>;
+pub struct NestedInnerChoiceXCombinator1(pub NestedInnerChoiceXCombinatorAlias1);
+impl View for NestedInnerChoiceXCombinator1 {
+    type V = SpecNestedInnerChoiceXCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(NestedInnerChoiceXCombinator1, NestedInnerChoiceXCombinatorAlias1);
+
+pub struct NestedInnerChoiceXCombinator(pub NestedInnerChoiceXCombinatorAlias);
+
+impl View for NestedInnerChoiceXCombinator {
+    type V = SpecNestedInnerChoiceXCombinator;
+    open spec fn view(&self) -> Self::V { SpecNestedInnerChoiceXCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceXCombinator {
+    type Type = NestedInnerChoiceX;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NestedInnerChoiceXCombinatorAlias = Mapped<NestedInnerChoiceXCombinator1, NestedInnerChoiceXMapper>;
+
+
+pub open spec fn spec_nested_inner_choice_x(choice1: SpecAOrB, choice2: SpecCOrD) -> SpecNestedInnerChoiceXCombinator {
+    SpecNestedInnerChoiceXCombinator(Mapped { inner: Choice(Cond { cond: choice1 == AOrB::A, inner: spec_nested_inner_choice_x_a(choice2) }, Cond { cond: choice1 == AOrB::B, inner: U32Le }), mapper: NestedInnerChoiceXMapper })
+}
+
+pub fn nested_inner_choice_x<'a>(choice1: AOrB, choice2: COrD) -> (o: NestedInnerChoiceXCombinator)
+    requires
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures o@ == spec_nested_inner_choice_x(choice1@, choice2@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NestedInnerChoiceXCombinator(Mapped { inner: NestedInnerChoiceXCombinator1(Choice::new(Cond { cond: choice1 == AOrB::A, inner: nested_inner_choice_x_a(choice2) }, Cond { cond: choice1 == AOrB::B, inner: U32Le })), mapper: NestedInnerChoiceXMapper });
+    // assert({
+    //     &&& combinator@ == spec_nested_inner_choice_x(choice1@, choice2@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_nested_inner_choice_x<'a>(input: &'a [u8], choice1: AOrB, choice2: COrD) -> (res: PResult<<NestedInnerChoiceXCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_nested_inner_choice_x(choice1@, choice2@).spec_parse(input@) == Some((n as int, v@)),
+        spec_nested_inner_choice_x(choice1@, choice2@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_nested_inner_choice_x(choice1@, choice2@).spec_parse(input@) is None,
+        spec_nested_inner_choice_x(choice1@, choice2@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = nested_inner_choice_x( choice1, choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_nested_inner_choice_x<'a>(v: <NestedInnerChoiceXCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice1: AOrB, choice2: COrD) -> (o: SResult<usize, SerializeError>)
+    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@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_nested_inner_choice_x(choice1@, choice2@).spec_serialize(v@).len() <= usize::MAX,
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        serialize_len == spec_nested_inner_choice_x(choice1@, choice2@).spec_serialize(v@).len(),
+{
+    let combinator = nested_inner_choice_x( choice1, choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecNestedInnerChoice {
+    pub x: SpecNestedInnerChoiceX,
+}
+
+pub type SpecNestedInnerChoiceInner = SpecNestedInnerChoiceX;
+
+
+impl SpecFrom<SpecNestedInnerChoice> for SpecNestedInnerChoiceInner {
+    open spec fn spec_from(m: SpecNestedInnerChoice) -> SpecNestedInnerChoiceInner {
+        m.x
+    }
+}
+
+impl SpecFrom<SpecNestedInnerChoiceInner> for SpecNestedInnerChoice {
+    open spec fn spec_from(m: SpecNestedInnerChoiceInner) -> SpecNestedInnerChoice {
+        let x = m;
+        SpecNestedInnerChoice { x }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct NestedInnerChoice {
+    pub x: NestedInnerChoiceX,
+}
+
+impl View for NestedInnerChoice {
+    type V = SpecNestedInnerChoice;
+
+    open spec fn view(&self) -> Self::V {
+        SpecNestedInnerChoice {
+            x: self.x@,
+        }
+    }
+}
+pub type NestedInnerChoiceInner = NestedInnerChoiceX;
+
+pub type NestedInnerChoiceInnerRef<'a> = &'a NestedInnerChoiceX;
+impl<'a> From<&'a NestedInnerChoice> for NestedInnerChoiceInnerRef<'a> {
+    fn ex_from(m: &'a NestedInnerChoice) -> NestedInnerChoiceInnerRef<'a> {
+        &m.x
+    }
+}
+
+impl From<NestedInnerChoiceInner> for NestedInnerChoice {
+    fn ex_from(m: NestedInnerChoiceInner) -> NestedInnerChoice {
+        let x = m;
+        NestedInnerChoice { x }
+    }
+}
+
+pub struct NestedInnerChoiceMapper;
+impl View for NestedInnerChoiceMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for NestedInnerChoiceMapper {
+    type Src = SpecNestedInnerChoiceInner;
+    type Dst = SpecNestedInnerChoice;
+}
+impl SpecIsoProof for NestedInnerChoiceMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for NestedInnerChoiceMapper {
+    type Src = NestedInnerChoiceInner;
+    type Dst = NestedInnerChoice;
+    type RefSrc = NestedInnerChoiceInnerRef<'a>;
+}
+
+pub struct SpecNestedInnerChoiceCombinator(pub SpecNestedInnerChoiceCombinatorAlias);
+
+impl SpecCombinator for SpecNestedInnerChoiceCombinator {
+    type Type = SpecNestedInnerChoice;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNestedInnerChoiceCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNestedInnerChoiceCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNestedInnerChoiceCombinatorAlias = Mapped<SpecNestedInnerChoiceXCombinator, NestedInnerChoiceMapper>;
+
+pub struct NestedInnerChoiceCombinator(pub NestedInnerChoiceCombinatorAlias);
+
+impl View for NestedInnerChoiceCombinator {
+    type V = SpecNestedInnerChoiceCombinator;
+    open spec fn view(&self) -> Self::V { SpecNestedInnerChoiceCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerChoiceCombinator {
+    type Type = NestedInnerChoice;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NestedInnerChoiceCombinatorAlias = Mapped<NestedInnerChoiceXCombinator, NestedInnerChoiceMapper>;
+
+
+pub open spec fn spec_nested_inner_choice(choice1: SpecAOrB, choice2: SpecCOrD) -> SpecNestedInnerChoiceCombinator {
+    SpecNestedInnerChoiceCombinator(
+    Mapped {
+        inner: spec_nested_inner_choice_x(choice1, choice2),
+        mapper: NestedInnerChoiceMapper,
+    })
+}
+
+pub fn nested_inner_choice<'a>(choice1: AOrB, choice2: COrD) -> (o: NestedInnerChoiceCombinator)
+    requires
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures o@ == spec_nested_inner_choice(choice1@, choice2@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NestedInnerChoiceCombinator(
+    Mapped {
+        inner: nested_inner_choice_x(choice1, choice2),
+        mapper: NestedInnerChoiceMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_nested_inner_choice(choice1@, choice2@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_nested_inner_choice<'a>(input: &'a [u8], choice1: AOrB, choice2: COrD) -> (res: PResult<<NestedInnerChoiceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_nested_inner_choice(choice1@, choice2@).spec_parse(input@) == Some((n as int, v@)),
+        spec_nested_inner_choice(choice1@, choice2@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_nested_inner_choice(choice1@, choice2@).spec_parse(input@) is None,
+        spec_nested_inner_choice(choice1@, choice2@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = nested_inner_choice( choice1, choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_nested_inner_choice<'a>(v: <NestedInnerChoiceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice1: AOrB, choice2: COrD) -> (o: SResult<usize, SerializeError>)
+    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@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_nested_inner_choice(choice1@, choice2@).spec_serialize(v@).len() <= usize::MAX,
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        serialize_len == spec_nested_inner_choice(choice1@, choice2@).spec_serialize(v@).len(),
+{
+    let combinator = nested_inner_choice( choice1, choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecCaptureParamAndLocal {
+    pub x: SpecCaptureParamAndLocalX,
+}
+
+pub type SpecCaptureParamAndLocalInner = SpecCaptureParamAndLocalX;
+
+
+impl SpecFrom<SpecCaptureParamAndLocal> for SpecCaptureParamAndLocalInner {
+    open spec fn spec_from(m: SpecCaptureParamAndLocal) -> SpecCaptureParamAndLocalInner {
+        m.x
+    }
+}
+
+impl SpecFrom<SpecCaptureParamAndLocalInner> for SpecCaptureParamAndLocal {
+    open spec fn spec_from(m: SpecCaptureParamAndLocalInner) -> SpecCaptureParamAndLocal {
+        let x = m;
+        SpecCaptureParamAndLocal { x }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CaptureParamAndLocal<'a> {
+    pub x: CaptureParamAndLocalX<'a>,
+}
+
+impl View for CaptureParamAndLocal<'_> {
+    type V = SpecCaptureParamAndLocal;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCaptureParamAndLocal {
+            x: self.x@,
+        }
+    }
+}
+pub type CaptureParamAndLocalInner<'a> = CaptureParamAndLocalX<'a>;
+
+pub type CaptureParamAndLocalInnerRef<'a> = &'a CaptureParamAndLocalX<'a>;
+impl<'a> From<&'a CaptureParamAndLocal<'a>> for CaptureParamAndLocalInnerRef<'a> {
+    fn ex_from(m: &'a CaptureParamAndLocal) -> CaptureParamAndLocalInnerRef<'a> {
+        &m.x
+    }
+}
+
+impl<'a> From<CaptureParamAndLocalInner<'a>> for CaptureParamAndLocal<'a> {
+    fn ex_from(m: CaptureParamAndLocalInner) -> CaptureParamAndLocal {
+        let x = m;
+        CaptureParamAndLocal { x }
+    }
+}
+
+pub struct CaptureParamAndLocalMapper;
+impl View for CaptureParamAndLocalMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureParamAndLocalMapper {
+    type Src = SpecCaptureParamAndLocalInner;
+    type Dst = SpecCaptureParamAndLocal;
+}
+impl SpecIsoProof for CaptureParamAndLocalMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureParamAndLocalMapper {
+    type Src = CaptureParamAndLocalInner<'a>;
+    type Dst = CaptureParamAndLocal<'a>;
+    type RefSrc = CaptureParamAndLocalInnerRef<'a>;
+}
+
+pub struct SpecCaptureParamAndLocalCombinator(pub SpecCaptureParamAndLocalCombinatorAlias);
+
+impl SpecCombinator for SpecCaptureParamAndLocalCombinator {
+    type Type = SpecCaptureParamAndLocal;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureParamAndLocalCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureParamAndLocalCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureParamAndLocalCombinatorAlias = Mapped<SpecCaptureParamAndLocalXCombinator, CaptureParamAndLocalMapper>;
+
+pub struct CaptureParamAndLocalCombinator(pub CaptureParamAndLocalCombinatorAlias);
+
+impl View for CaptureParamAndLocalCombinator {
+    type V = SpecCaptureParamAndLocalCombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureParamAndLocalCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureParamAndLocalCombinator {
+    type Type = CaptureParamAndLocal<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureParamAndLocalCombinatorAlias = Mapped<CaptureParamAndLocalXCombinator, CaptureParamAndLocalMapper>;
+
+
+pub open spec fn spec_capture_param_and_local(choice1: SpecAOrB, choice2: SpecCOrD) -> SpecCaptureParamAndLocalCombinator {
+    SpecCaptureParamAndLocalCombinator(
+    Mapped {
+        inner: spec_capture_param_and_local_x(choice1, choice2),
+        mapper: CaptureParamAndLocalMapper,
+    })
+}
+
+pub fn capture_param_and_local<'a>(choice1: AOrB, choice2: COrD) -> (o: CaptureParamAndLocalCombinator)
+    requires
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures o@ == spec_capture_param_and_local(choice1@, choice2@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureParamAndLocalCombinator(
+    Mapped {
+        inner: capture_param_and_local_x(choice1, choice2),
+        mapper: CaptureParamAndLocalMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_capture_param_and_local(choice1@, choice2@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_param_and_local<'a>(input: &'a [u8], choice1: AOrB, choice2: COrD) -> (res: PResult<<CaptureParamAndLocalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_param_and_local(choice1@, choice2@).spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_param_and_local(choice1@, choice2@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_param_and_local(choice1@, choice2@).spec_parse(input@) is None,
+        spec_capture_param_and_local(choice1@, choice2@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_param_and_local( choice1, choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_param_and_local<'a>(v: <CaptureParamAndLocalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, choice1: AOrB, choice2: COrD) -> (o: SResult<usize, SerializeError>)
+    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@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_capture_param_and_local(choice1@, choice2@).spec_serialize(v@).len() <= usize::MAX,
+        spec_a_or_b().wf(choice1@),
+        spec_c_or_d().wf(choice2@),
+
+    ensures
+        serialize_len == spec_capture_param_and_local(choice1@, choice2@).spec_serialize(v@).len(),
+{
+    let combinator = capture_param_and_local( choice1, choice2 );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecNestedInnerStruct {
+    pub len: u32,
+    pub inner: SpecNestedInnerStructAnonInner,
+}
+
+pub type SpecNestedInnerStructInner = (u32, SpecNestedInnerStructAnonInner);
+
+
+impl SpecFrom<SpecNestedInnerStruct> for SpecNestedInnerStructInner {
+    open spec fn spec_from(m: SpecNestedInnerStruct) -> SpecNestedInnerStructInner {
+        (m.len, m.inner)
+    }
+}
+
+impl SpecFrom<SpecNestedInnerStructInner> for SpecNestedInnerStruct {
+    open spec fn spec_from(m: SpecNestedInnerStructInner) -> SpecNestedInnerStruct {
+        let (len, inner) = m;
+        SpecNestedInnerStruct { len, inner }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct NestedInnerStruct<'a> {
+    pub len: u32,
+    pub inner: NestedInnerStructAnonInner<'a>,
+}
+
+impl View for NestedInnerStruct<'_> {
+    type V = SpecNestedInnerStruct;
+
+    open spec fn view(&self) -> Self::V {
+        SpecNestedInnerStruct {
+            len: self.len@,
+            inner: self.inner@,
+        }
+    }
+}
+pub type NestedInnerStructInner<'a> = (u32, NestedInnerStructAnonInner<'a>);
+
+pub type NestedInnerStructInnerRef<'a> = (&'a u32, &'a NestedInnerStructAnonInner<'a>);
+impl<'a> From<&'a NestedInnerStruct<'a>> for NestedInnerStructInnerRef<'a> {
+    fn ex_from(m: &'a NestedInnerStruct) -> NestedInnerStructInnerRef<'a> {
+        (&m.len, &m.inner)
+    }
+}
+
+impl<'a> From<NestedInnerStructInner<'a>> for NestedInnerStruct<'a> {
+    fn ex_from(m: NestedInnerStructInner) -> NestedInnerStruct {
+        let (len, inner) = m;
+        NestedInnerStruct { len, inner }
+    }
+}
+
+pub struct NestedInnerStructMapper;
+impl View for NestedInnerStructMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for NestedInnerStructMapper {
+    type Src = SpecNestedInnerStructInner;
+    type Dst = SpecNestedInnerStruct;
+}
+impl SpecIsoProof for NestedInnerStructMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for NestedInnerStructMapper {
+    type Src = NestedInnerStructInner<'a>;
+    type Dst = NestedInnerStruct<'a>;
+    type RefSrc = NestedInnerStructInnerRef<'a>;
+}
+
+pub struct SpecNestedInnerStructCombinator(pub SpecNestedInnerStructCombinatorAlias);
+
+impl SpecCombinator for SpecNestedInnerStructCombinator {
+    type Type = SpecNestedInnerStruct;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNestedInnerStructCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNestedInnerStructCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNestedInnerStructCombinatorAlias = Mapped<SpecPair<U32Le, SpecNestedInnerStructAnonInnerCombinator>, NestedInnerStructMapper>;
+
+pub struct NestedInnerStructCombinator(pub NestedInnerStructCombinatorAlias);
+
+impl View for NestedInnerStructCombinator {
+    type V = SpecNestedInnerStructCombinator;
+    open spec fn view(&self) -> Self::V { SpecNestedInnerStructCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NestedInnerStructCombinator {
+    type Type = NestedInnerStruct<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NestedInnerStructCombinatorAlias = Mapped<Pair<U32Le, NestedInnerStructAnonInnerCombinator, NestedInnerStructCont0>, NestedInnerStructMapper>;
+
+
+pub open spec fn spec_nested_inner_struct() -> SpecNestedInnerStructCombinator {
+    SpecNestedInnerStructCombinator(
+    Mapped {
+        inner: Pair::spec_new(U32Le, |deps| spec_nested_inner_struct_cont0(deps)),
+        mapper: NestedInnerStructMapper,
+    })
+}
+
+pub open spec fn spec_nested_inner_struct_cont0(deps: u32) -> SpecNestedInnerStructAnonInnerCombinator {
+    let len = deps;
+    spec_nested_inner_struct_anon_inner(len)
+}
+
+impl View for NestedInnerStructCont0 {
+    type V = spec_fn(u32) -> SpecNestedInnerStructAnonInnerCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u32| {
+            spec_nested_inner_struct_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn nested_inner_struct<'a>() -> (o: NestedInnerStructCombinator)
+    ensures o@ == spec_nested_inner_struct(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NestedInnerStructCombinator(
+    Mapped {
+        inner: Pair::new(U32Le, NestedInnerStructCont0),
+        mapper: NestedInnerStructMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_nested_inner_struct()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_nested_inner_struct<'a>(input: &'a [u8]) -> (res: PResult<<NestedInnerStructCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_nested_inner_struct().spec_parse(input@) == Some((n as int, v@)),
+        spec_nested_inner_struct().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_nested_inner_struct().spec_parse(input@) is None,
+        spec_nested_inner_struct().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = nested_inner_struct();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_nested_inner_struct<'a>(v: <NestedInnerStructCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_nested_inner_struct().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_nested_inner_struct().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_nested_inner_struct().spec_serialize(v@).len(),
+{
+    let combinator = nested_inner_struct();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct NestedInnerStructCont0;
+type NestedInnerStructCont0Type<'a, 'b> = &'b u32;
+type NestedInnerStructCont0SType<'a, 'x> = &'x u32;
+type NestedInnerStructCont0Input<'a, 'b, 'x> = POrSType<NestedInnerStructCont0Type<'a, 'b>, NestedInnerStructCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<NestedInnerStructCont0Input<'a, 'b, 'x>> for NestedInnerStructCont0 {
+    type Output = NestedInnerStructAnonInnerCombinator;
+
+    open spec fn requires(&self, deps: NestedInnerStructCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U32Le).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: NestedInnerStructCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_nested_inner_struct_cont0(deps@)
+    }
+
+    fn apply(&self, deps: NestedInnerStructCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let len = deps;
+                let len = *len;
+                nested_inner_struct_anon_inner(len)
+            }
+            POrSType::S(deps) => {
+                let len = deps;
+                let len = *len;
+                nested_inner_struct_anon_inner(len)
+            }
+        }
+    }
+}
+                
+
+pub spec const SPEC_COrD_C: u8 = 1;
+pub spec const SPEC_COrD_D: u8 = 2;
+pub exec static EXEC_COrD_C: u8 ensures EXEC_COrD_C == SPEC_COrD_C { 1 }
+pub exec static EXEC_COrD_D: u8 ensures EXEC_COrD_D == SPEC_COrD_D { 2 }
+
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum COrD {
+    C = 1,
+D = 2
+}
+pub type SpecCOrD = COrD;
+
+pub type COrDInner = u8;
+
+pub type COrDInnerRef<'a> = &'a u8;
+
+impl View for COrD {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecTryFrom<COrDInner> for COrD {
+    type Error = ();
+
+    open spec fn spec_try_from(v: COrDInner) -> Result<COrD, ()> {
+        match v {
+            1u8 => Ok(COrD::C),
+            2u8 => Ok(COrD::D),
+            _ => Err(()),
+        }
+    }
+}
+
+impl SpecTryFrom<COrD> for COrDInner {
+    type Error = ();
+
+    open spec fn spec_try_from(v: COrD) -> Result<COrDInner, ()> {
+        match v {
+            COrD::C => Ok(SPEC_COrD_C),
+            COrD::D => Ok(SPEC_COrD_D),
+        }
+    }
+}
+
+impl TryFrom<COrDInner> for COrD {
+    type Error = ();
+
+    fn ex_try_from(v: COrDInner) -> Result<COrD, ()> {
+        match v {
+            1u8 => Ok(COrD::C),
+            2u8 => Ok(COrD::D),
+            _ => Err(()),
+        }
+    }
+}
+
+impl<'a> TryFrom<&'a COrD> for COrDInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a COrD) -> Result<COrDInnerRef<'a>, ()> {
+        match v {
+            COrD::C => Ok(&EXEC_COrD_C),
+            COrD::D => Ok(&EXEC_COrD_D),
+        }
+    }
+}
+
+pub struct COrDMapper;
+
+impl View for COrDMapper {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecPartialIso for COrDMapper {
+    type Src = COrDInner;
+    type Dst = COrD;
+}
+
+impl SpecPartialIsoProof for COrDMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+}
+
+impl<'a> PartialIso<'a> for COrDMapper {
+    type Src = COrDInner;
+    type Dst = COrD;
+    type RefSrc = COrDInnerRef<'a>;
+}
+
+
+pub struct SpecCOrDCombinator(pub SpecCOrDCombinatorAlias);
+
+impl SpecCombinator for SpecCOrDCombinator {
+    type Type = SpecCOrD;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCOrDCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCOrDCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCOrDCombinatorAlias = TryMap<U8, COrDMapper>;
+
+pub struct COrDCombinator(pub COrDCombinatorAlias);
+
+impl View for COrDCombinator {
+    type V = SpecCOrDCombinator;
+    open spec fn view(&self) -> Self::V { SpecCOrDCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for COrDCombinator {
+    type Type = COrD;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type COrDCombinatorAlias = TryMap<U8, COrDMapper>;
+
+
+pub open spec fn spec_c_or_d() -> SpecCOrDCombinator {
+    SpecCOrDCombinator(TryMap { inner: U8, mapper: COrDMapper })
+}
+
+                
+pub fn c_or_d<'a>() -> (o: COrDCombinator)
+    ensures o@ == spec_c_or_d(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = COrDCombinator(TryMap { inner: U8, mapper: COrDMapper });
+    // assert({
+    //     &&& combinator@ == spec_c_or_d()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_c_or_d<'a>(input: &'a [u8]) -> (res: PResult<<COrDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_c_or_d().spec_parse(input@) == Some((n as int, v@)),
+        spec_c_or_d().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_c_or_d().spec_parse(input@) is None,
+        spec_c_or_d().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = c_or_d();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_c_or_d<'a>(v: <COrDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_c_or_d().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_c_or_d().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_c_or_d().spec_serialize(v@).len(),
+{
+    let combinator = c_or_d();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecCaptureLocalInAnonStructWrapper {
+    pub tag: u8,
+    pub value: SpecCaptureLocalInAnonStructWrapperValue,
+}
+
+pub type SpecCaptureLocalInAnonStructWrapperInner = (u8, SpecCaptureLocalInAnonStructWrapperValue);
+
+
+impl SpecFrom<SpecCaptureLocalInAnonStructWrapper> for SpecCaptureLocalInAnonStructWrapperInner {
+    open spec fn spec_from(m: SpecCaptureLocalInAnonStructWrapper) -> SpecCaptureLocalInAnonStructWrapperInner {
+        (m.tag, m.value)
+    }
+}
+
+impl SpecFrom<SpecCaptureLocalInAnonStructWrapperInner> for SpecCaptureLocalInAnonStructWrapper {
+    open spec fn spec_from(m: SpecCaptureLocalInAnonStructWrapperInner) -> SpecCaptureLocalInAnonStructWrapper {
+        let (tag, value) = m;
+        SpecCaptureLocalInAnonStructWrapper { tag, value }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CaptureLocalInAnonStructWrapper<'a> {
+    pub tag: u8,
+    pub value: CaptureLocalInAnonStructWrapperValue<'a>,
+}
+
+impl View for CaptureLocalInAnonStructWrapper<'_> {
+    type V = SpecCaptureLocalInAnonStructWrapper;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCaptureLocalInAnonStructWrapper {
+            tag: self.tag@,
+            value: self.value@,
+        }
+    }
+}
+pub type CaptureLocalInAnonStructWrapperInner<'a> = (u8, CaptureLocalInAnonStructWrapperValue<'a>);
+
+pub type CaptureLocalInAnonStructWrapperInnerRef<'a> = (&'a u8, &'a CaptureLocalInAnonStructWrapperValue<'a>);
+impl<'a> From<&'a CaptureLocalInAnonStructWrapper<'a>> for CaptureLocalInAnonStructWrapperInnerRef<'a> {
+    fn ex_from(m: &'a CaptureLocalInAnonStructWrapper) -> CaptureLocalInAnonStructWrapperInnerRef<'a> {
+        (&m.tag, &m.value)
+    }
+}
+
+impl<'a> From<CaptureLocalInAnonStructWrapperInner<'a>> for CaptureLocalInAnonStructWrapper<'a> {
+    fn ex_from(m: CaptureLocalInAnonStructWrapperInner) -> CaptureLocalInAnonStructWrapper {
+        let (tag, value) = m;
+        CaptureLocalInAnonStructWrapper { tag, value }
+    }
+}
+
+pub struct CaptureLocalInAnonStructWrapperMapper;
+impl View for CaptureLocalInAnonStructWrapperMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureLocalInAnonStructWrapperMapper {
+    type Src = SpecCaptureLocalInAnonStructWrapperInner;
+    type Dst = SpecCaptureLocalInAnonStructWrapper;
+}
+impl SpecIsoProof for CaptureLocalInAnonStructWrapperMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureLocalInAnonStructWrapperMapper {
+    type Src = CaptureLocalInAnonStructWrapperInner<'a>;
+    type Dst = CaptureLocalInAnonStructWrapper<'a>;
+    type RefSrc = CaptureLocalInAnonStructWrapperInnerRef<'a>;
+}
+
+pub struct SpecCaptureLocalInAnonStructWrapperCombinator(pub SpecCaptureLocalInAnonStructWrapperCombinatorAlias);
+
+impl SpecCombinator for SpecCaptureLocalInAnonStructWrapperCombinator {
+    type Type = SpecCaptureLocalInAnonStructWrapper;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureLocalInAnonStructWrapperCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureLocalInAnonStructWrapperCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureLocalInAnonStructWrapperCombinatorAlias = Mapped<SpecPair<U8, SpecCaptureLocalInAnonStructWrapperValueCombinator>, CaptureLocalInAnonStructWrapperMapper>;
+
+pub struct CaptureLocalInAnonStructWrapperCombinator(pub CaptureLocalInAnonStructWrapperCombinatorAlias);
+
+impl View for CaptureLocalInAnonStructWrapperCombinator {
+    type V = SpecCaptureLocalInAnonStructWrapperCombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureLocalInAnonStructWrapperCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructWrapperCombinator {
+    type Type = CaptureLocalInAnonStructWrapper<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureLocalInAnonStructWrapperCombinatorAlias = Mapped<Pair<U8, CaptureLocalInAnonStructWrapperValueCombinator, CaptureLocalInAnonStructWrapperCont0>, CaptureLocalInAnonStructWrapperMapper>;
+
+
+pub open spec fn spec_capture_local_in_anon_struct_wrapper() -> SpecCaptureLocalInAnonStructWrapperCombinator {
+    SpecCaptureLocalInAnonStructWrapperCombinator(
+    Mapped {
+        inner: Pair::spec_new(U8, |deps| spec_capture_local_in_anon_struct_wrapper_cont0(deps)),
+        mapper: CaptureLocalInAnonStructWrapperMapper,
+    })
+}
+
+pub open spec fn spec_capture_local_in_anon_struct_wrapper_cont0(deps: u8) -> SpecCaptureLocalInAnonStructWrapperValueCombinator {
+    let tag = deps;
+    spec_capture_local_in_anon_struct_wrapper_value(tag)
+}
+
+impl View for CaptureLocalInAnonStructWrapperCont0 {
+    type V = spec_fn(u8) -> SpecCaptureLocalInAnonStructWrapperValueCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_capture_local_in_anon_struct_wrapper_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn capture_local_in_anon_struct_wrapper<'a>() -> (o: CaptureLocalInAnonStructWrapperCombinator)
+    ensures o@ == spec_capture_local_in_anon_struct_wrapper(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureLocalInAnonStructWrapperCombinator(
+    Mapped {
+        inner: Pair::new(U8, CaptureLocalInAnonStructWrapperCont0),
+        mapper: CaptureLocalInAnonStructWrapperMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_capture_local_in_anon_struct_wrapper()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_local_in_anon_struct_wrapper<'a>(input: &'a [u8]) -> (res: PResult<<CaptureLocalInAnonStructWrapperCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_local_in_anon_struct_wrapper().spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_local_in_anon_struct_wrapper().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_local_in_anon_struct_wrapper().spec_parse(input@) is None,
+        spec_capture_local_in_anon_struct_wrapper().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_local_in_anon_struct_wrapper();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_local_in_anon_struct_wrapper<'a>(v: <CaptureLocalInAnonStructWrapperCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_local_in_anon_struct_wrapper().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_capture_local_in_anon_struct_wrapper().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_capture_local_in_anon_struct_wrapper().spec_serialize(v@).len(),
+{
+    let combinator = capture_local_in_anon_struct_wrapper();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct CaptureLocalInAnonStructWrapperCont0;
+type CaptureLocalInAnonStructWrapperCont0Type<'a, 'b> = &'b u8;
+type CaptureLocalInAnonStructWrapperCont0SType<'a, 'x> = &'x u8;
+type CaptureLocalInAnonStructWrapperCont0Input<'a, 'b, 'x> = POrSType<CaptureLocalInAnonStructWrapperCont0Type<'a, 'b>, CaptureLocalInAnonStructWrapperCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CaptureLocalInAnonStructWrapperCont0Input<'a, 'b, 'x>> for CaptureLocalInAnonStructWrapperCont0 {
+    type Output = CaptureLocalInAnonStructWrapperValueCombinator;
+
+    open spec fn requires(&self, deps: CaptureLocalInAnonStructWrapperCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U8).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CaptureLocalInAnonStructWrapperCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_capture_local_in_anon_struct_wrapper_cont0(deps@)
+    }
+
+    fn apply(&self, deps: CaptureLocalInAnonStructWrapperCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let tag = deps;
+                let tag = *tag;
+                capture_local_in_anon_struct_wrapper_value(tag)
+            }
+            POrSType::S(deps) => {
+                let tag = deps;
+                let tag = *tag;
+                capture_local_in_anon_struct_wrapper_value(tag)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecCaptureLocalInAnonStruct {
+    pub wrapper: SpecCaptureLocalInAnonStructWrapper,
+}
+
+pub type SpecCaptureLocalInAnonStructInner = SpecCaptureLocalInAnonStructWrapper;
+
+
+impl SpecFrom<SpecCaptureLocalInAnonStruct> for SpecCaptureLocalInAnonStructInner {
+    open spec fn spec_from(m: SpecCaptureLocalInAnonStruct) -> SpecCaptureLocalInAnonStructInner {
+        m.wrapper
+    }
+}
+
+impl SpecFrom<SpecCaptureLocalInAnonStructInner> for SpecCaptureLocalInAnonStruct {
+    open spec fn spec_from(m: SpecCaptureLocalInAnonStructInner) -> SpecCaptureLocalInAnonStruct {
+        let wrapper = m;
+        SpecCaptureLocalInAnonStruct { wrapper }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CaptureLocalInAnonStruct<'a> {
+    pub wrapper: CaptureLocalInAnonStructWrapper<'a>,
+}
+
+impl View for CaptureLocalInAnonStruct<'_> {
+    type V = SpecCaptureLocalInAnonStruct;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCaptureLocalInAnonStruct {
+            wrapper: self.wrapper@,
+        }
+    }
+}
+pub type CaptureLocalInAnonStructInner<'a> = CaptureLocalInAnonStructWrapper<'a>;
+
+pub type CaptureLocalInAnonStructInnerRef<'a> = &'a CaptureLocalInAnonStructWrapper<'a>;
+impl<'a> From<&'a CaptureLocalInAnonStruct<'a>> for CaptureLocalInAnonStructInnerRef<'a> {
+    fn ex_from(m: &'a CaptureLocalInAnonStruct) -> CaptureLocalInAnonStructInnerRef<'a> {
+        &m.wrapper
+    }
+}
+
+impl<'a> From<CaptureLocalInAnonStructInner<'a>> for CaptureLocalInAnonStruct<'a> {
+    fn ex_from(m: CaptureLocalInAnonStructInner) -> CaptureLocalInAnonStruct {
+        let wrapper = m;
+        CaptureLocalInAnonStruct { wrapper }
+    }
+}
+
+pub struct CaptureLocalInAnonStructMapper;
+impl View for CaptureLocalInAnonStructMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CaptureLocalInAnonStructMapper {
+    type Src = SpecCaptureLocalInAnonStructInner;
+    type Dst = SpecCaptureLocalInAnonStruct;
+}
+impl SpecIsoProof for CaptureLocalInAnonStructMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CaptureLocalInAnonStructMapper {
+    type Src = CaptureLocalInAnonStructInner<'a>;
+    type Dst = CaptureLocalInAnonStruct<'a>;
+    type RefSrc = CaptureLocalInAnonStructInnerRef<'a>;
+}
+
+pub struct SpecCaptureLocalInAnonStructCombinator(pub SpecCaptureLocalInAnonStructCombinatorAlias);
+
+impl SpecCombinator for SpecCaptureLocalInAnonStructCombinator {
+    type Type = SpecCaptureLocalInAnonStruct;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCaptureLocalInAnonStructCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCaptureLocalInAnonStructCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCaptureLocalInAnonStructCombinatorAlias = Mapped<SpecCaptureLocalInAnonStructWrapperCombinator, CaptureLocalInAnonStructMapper>;
+
+pub struct CaptureLocalInAnonStructCombinator(pub CaptureLocalInAnonStructCombinatorAlias);
+
+impl View for CaptureLocalInAnonStructCombinator {
+    type V = SpecCaptureLocalInAnonStructCombinator;
+    open spec fn view(&self) -> Self::V { SpecCaptureLocalInAnonStructCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CaptureLocalInAnonStructCombinator {
+    type Type = CaptureLocalInAnonStruct<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CaptureLocalInAnonStructCombinatorAlias = Mapped<CaptureLocalInAnonStructWrapperCombinator, CaptureLocalInAnonStructMapper>;
+
+
+pub open spec fn spec_capture_local_in_anon_struct() -> SpecCaptureLocalInAnonStructCombinator {
+    SpecCaptureLocalInAnonStructCombinator(
+    Mapped {
+        inner: spec_capture_local_in_anon_struct_wrapper(),
+        mapper: CaptureLocalInAnonStructMapper,
+    })
+}
+
+                
+pub fn capture_local_in_anon_struct<'a>() -> (o: CaptureLocalInAnonStructCombinator)
+    ensures o@ == spec_capture_local_in_anon_struct(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CaptureLocalInAnonStructCombinator(
+    Mapped {
+        inner: capture_local_in_anon_struct_wrapper(),
+        mapper: CaptureLocalInAnonStructMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_capture_local_in_anon_struct()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_capture_local_in_anon_struct<'a>(input: &'a [u8]) -> (res: PResult<<CaptureLocalInAnonStructCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_capture_local_in_anon_struct().spec_parse(input@) == Some((n as int, v@)),
+        spec_capture_local_in_anon_struct().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_capture_local_in_anon_struct().spec_parse(input@) is None,
+        spec_capture_local_in_anon_struct().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = capture_local_in_anon_struct();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_capture_local_in_anon_struct<'a>(v: <CaptureLocalInAnonStructCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_capture_local_in_anon_struct().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_capture_local_in_anon_struct().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_capture_local_in_anon_struct().spec_serialize(v@).len(),
+{
+    let combinator = capture_local_in_anon_struct();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub spec const SPEC_AOrB_A: u8 = 1;
+pub spec const SPEC_AOrB_B: u8 = 2;
+pub exec static EXEC_AOrB_A: u8 ensures EXEC_AOrB_A == SPEC_AOrB_A { 1 }
+pub exec static EXEC_AOrB_B: u8 ensures EXEC_AOrB_B == SPEC_AOrB_B { 2 }
+
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum AOrB {
+    A = 1,
+B = 2
+}
+pub type SpecAOrB = AOrB;
+
+pub type AOrBInner = u8;
+
+pub type AOrBInnerRef<'a> = &'a u8;
+
+impl View for AOrB {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecTryFrom<AOrBInner> for AOrB {
+    type Error = ();
+
+    open spec fn spec_try_from(v: AOrBInner) -> Result<AOrB, ()> {
+        match v {
+            1u8 => Ok(AOrB::A),
+            2u8 => Ok(AOrB::B),
+            _ => Err(()),
+        }
+    }
+}
+
+impl SpecTryFrom<AOrB> for AOrBInner {
+    type Error = ();
+
+    open spec fn spec_try_from(v: AOrB) -> Result<AOrBInner, ()> {
+        match v {
+            AOrB::A => Ok(SPEC_AOrB_A),
+            AOrB::B => Ok(SPEC_AOrB_B),
+        }
+    }
+}
+
+impl TryFrom<AOrBInner> for AOrB {
+    type Error = ();
+
+    fn ex_try_from(v: AOrBInner) -> Result<AOrB, ()> {
+        match v {
+            1u8 => Ok(AOrB::A),
+            2u8 => Ok(AOrB::B),
+            _ => Err(()),
+        }
+    }
+}
+
+impl<'a> TryFrom<&'a AOrB> for AOrBInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a AOrB) -> Result<AOrBInnerRef<'a>, ()> {
+        match v {
+            AOrB::A => Ok(&EXEC_AOrB_A),
+            AOrB::B => Ok(&EXEC_AOrB_B),
+        }
+    }
+}
+
+pub struct AOrBMapper;
+
+impl View for AOrBMapper {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecPartialIso for AOrBMapper {
+    type Src = AOrBInner;
+    type Dst = AOrB;
+}
+
+impl SpecPartialIsoProof for AOrBMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+}
+
+impl<'a> PartialIso<'a> for AOrBMapper {
+    type Src = AOrBInner;
+    type Dst = AOrB;
+    type RefSrc = AOrBInnerRef<'a>;
+}
+
+
+pub struct SpecAOrBCombinator(pub SpecAOrBCombinatorAlias);
+
+impl SpecCombinator for SpecAOrBCombinator {
+    type Type = SpecAOrB;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecAOrBCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecAOrBCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecAOrBCombinatorAlias = TryMap<U8, AOrBMapper>;
+
+pub struct AOrBCombinator(pub AOrBCombinatorAlias);
+
+impl View for AOrBCombinator {
+    type V = SpecAOrBCombinator;
+    open spec fn view(&self) -> Self::V { SpecAOrBCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AOrBCombinator {
+    type Type = AOrB;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type AOrBCombinatorAlias = TryMap<U8, AOrBMapper>;
+
+
+pub open spec fn spec_a_or_b() -> SpecAOrBCombinator {
+    SpecAOrBCombinator(TryMap { inner: U8, mapper: AOrBMapper })
+}
+
+                
+pub fn a_or_b<'a>() -> (o: AOrBCombinator)
+    ensures o@ == spec_a_or_b(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = AOrBCombinator(TryMap { inner: U8, mapper: AOrBMapper });
+    // assert({
+    //     &&& combinator@ == spec_a_or_b()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_a_or_b<'a>(input: &'a [u8]) -> (res: PResult<<AOrBCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_a_or_b().spec_parse(input@) == Some((n as int, v@)),
+        spec_a_or_b().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_a_or_b().spec_parse(input@) is None,
+        spec_a_or_b().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = a_or_b();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_a_or_b<'a>(v: <AOrBCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_a_or_b().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_a_or_b().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_a_or_b().spec_serialize(v@).len(),
+{
+    let combinator = a_or_b();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+}
diff --git a/vest-dsl/test/src/anonymous_nested.vest b/vest-dsl/test/src/anonymous_nested.vest
new file mode 100644
index 00000000..123f4c9a
--- /dev/null
+++ b/vest-dsl/test/src/anonymous_nested.vest
@@ -0,0 +1,75 @@
+!LITTLE_ENDIAN
+
+a_or_b = enum {
+  A = 1,
+  B = 2,
+}
+
+c_or_d = enum {
+  C = 1,
+  D = 2,
+}
+
+nested_inner_struct = {
+  @len: u32,
+  inner: [u8; @len] >>= {
+    x: u8,
+    y: Tail,
+  },
+}
+
+nested_inner_choice(@choice1: a_or_b, @choice2: c_or_d) = {
+  x: choose(@choice1) {
+    A => choose(@choice2) {
+      C => u8,
+      D => u16,
+    },
+    B => u32,
+  },
+}
+
+capture_outer_and_local = {
+  @frame_len: u8 | { 1.. },
+  payload: [u8; @frame_len] >>= {
+    @tag: u8,
+    body: choose(@tag) {
+      0 => [u8; @frame_len - |u8|],
+      _ => {
+        @count: u8,
+        items: [u8; @count],
+      },
+    },
+  },
+}
+
+capture_local_in_anon_struct = {
+  wrapper: {
+    @tag: u8,
+    value: choose(@tag) {
+      0 => {
+        @len: u8,
+        bytes: [u8; @len],
+      },
+      _ => u16,
+    },
+  },
+}
+
+capture_param_and_local(@choice1: a_or_b, @choice2: c_or_d) = {
+  x: choose(@choice1) {
+    A => {
+      @len: u8,
+      payload: choose(@choice2) {
+        C => [u8; @len],
+        D => [u8; @len],
+      },
+    },
+    B => {
+      @tag: u8,
+      y: choose(@tag) {
+        0 => u8,
+        _ => u16,
+      },
+    },
+  },
+}
diff --git a/vest-dsl/test/src/codegen.rs b/vest-dsl/test/src/codegen.rs
index 842b2b44..e9785fcc 100644
--- a/vest-dsl/test/src/codegen.rs
+++ b/vest-dsl/test/src/codegen.rs
@@ -1021,6 +1021,9 @@ pub open spec fn spec_msg4_v(t: SpecAType) -> SpecMsg4VCombinator {
 }
 
 pub fn msg4_v<'a>(t: AType) -> (o: Msg4VCombinator)
+    requires
+        spec_a_type().wf(t@),
+
     ensures o@ == spec_msg4_v(t@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
@@ -1037,6 +1040,8 @@ pub fn msg4_v<'a>(t: AType) -> (o: Msg4VCombinator)
 pub fn parse_msg4_v<'a>(input: &'a [u8], t: AType) -> (res: PResult<<Msg4VCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_a_type().wf(t@),
+
     ensures
         res matches Ok((n, v)) ==> spec_msg4_v(t@).spec_parse(input@) == Some((n as int, v@)),
         spec_msg4_v(t@).spec_parse(input@) matches Some((n, v))
@@ -1052,6 +1057,8 @@ pub fn serialize_msg4_v<'a>(v: <Msg4VCombinator as Combinator<'a, &'a [u8], Vec<
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_msg4_v(t@).wf(v@),
+        spec_a_type().wf(t@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -1068,6 +1075,8 @@ pub fn msg4_v_len<'a>(v: <Msg4VCombinator as Combinator<'a, &'a [u8], Vec<u8>>>:
     requires
         spec_msg4_v(t@).wf(v@),
         spec_msg4_v(t@).spec_serialize(v@).len() <= usize::MAX,
+        spec_a_type().wf(t@),
+
     ensures
         serialize_len == spec_msg4_v(t@).spec_serialize(v@).len(),
 {
@@ -1299,16 +1308,20 @@ type Msg4Cont0Input<'a, 'b, 'x> = POrSType<Msg4Cont0Type<'a, 'b>, Msg4Cont0SType
 impl<'a, 'b, 'x> Continuation<Msg4Cont0Input<'a, 'b, 'x>> for Msg4Cont0 {
     type Output = (Msg4VCombinator, bytes::Tail);
 
-    open spec fn requires(&self, deps: Msg4Cont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: Msg4Cont0Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_a_type()).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: Msg4Cont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_msg4_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_msg4_cont0(deps@)
     }
 
     fn apply(&self, deps: Msg4Cont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let t = *deps;
+                let t = deps;
+                let t = *t;
                 (msg4_v(t), bytes::Tail)
             }
             POrSType::S(deps) => {
diff --git a/vest-dsl/test/src/elab.rs b/vest-dsl/test/src/elab.rs
index 5ee1b596..6acfebe0 100644
--- a/vest-dsl/test/src/elab.rs
+++ b/vest-dsl/test/src/elab.rs
@@ -92,15 +92,16 @@ pub type Content0CombinatorAlias = bytes::Variable;
 
 
 pub open spec fn spec_content_0(num: u24) -> SpecContent0Combinator {
-    SpecContent0Combinator(bytes::Variable(num.spec_into()))
+    SpecContent0Combinator(bytes::Variable((usize::spec_from(num)) as usize))
 }
 
 pub fn content_0<'a>(num: u24) -> (o: Content0Combinator)
+
     ensures o@ == spec_content_0(num@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = Content0Combinator(bytes::Variable(num.ex_into()));
+    let combinator = Content0Combinator(bytes::Variable((usize::ex_from(num)) as usize));
     // assert({
     //     &&& combinator@ == spec_content_0(num@)
     //     &&& combinator@.requires()
@@ -112,6 +113,7 @@ pub fn content_0<'a>(num: u24) -> (o: Content0Combinator)
 pub fn parse_content_0<'a>(input: &'a [u8], num: u24) -> (res: PResult<<Content0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
         res matches Ok((n, v)) ==> spec_content_0(num@).spec_parse(input@) == Some((n as int, v@)),
         spec_content_0(num@).spec_parse(input@) matches Some((n, v))
@@ -127,6 +129,7 @@ pub fn serialize_content_0<'a>(v: <Content0Combinator as Combinator<'a, &'a [u8]
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_content_0(num@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -143,6 +146,7 @@ pub fn content_0_len<'a>(v: <Content0Combinator as Combinator<'a, &'a [u8], Vec<
     requires
         spec_content_0(num@).wf(v@),
         spec_content_0(num@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
         serialize_len == spec_content_0(num@).spec_serialize(v@).len(),
 {
@@ -465,62 +469,71 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MsgCF4Combinator {
 pub type MsgCF4CombinatorAlias = AndThen<bytes::Variable, Mapped<MsgCF4Combinator3, MsgCF4Mapper>>;
 
 
-pub open spec fn spec_msg_c_f4(f3: u24, f2: u8) -> SpecMsgCF4Combinator {
-    SpecMsgCF4Combinator(AndThen(bytes::Variable(f3.spec_into()), Mapped { inner: Choice(Cond { cond: f2 == ContentType::SPEC_C0, inner: spec_content_0(f3) }, Choice(Cond { cond: f2 == ContentType::SPEC_C1, inner: U16Be }, Choice(Cond { cond: f2 == ContentType::SPEC_C2, inner: U32Be }, Cond { cond: !(f2 == ContentType::SPEC_C0 || f2 == ContentType::SPEC_C1 || f2 == ContentType::SPEC_C2), inner: bytes::Tail }))), mapper: MsgCF4Mapper }))
+pub open spec fn spec_msg_c_f4(f2: u8, f3: u24) -> SpecMsgCF4Combinator {
+    SpecMsgCF4Combinator(AndThen(bytes::Variable((usize::spec_from(f3)) as usize), Mapped { inner: Choice(Cond { cond: f2 == ContentType::SPEC_C0, inner: spec_content_0(f3) }, Choice(Cond { cond: f2 == ContentType::SPEC_C1, inner: U16Be }, Choice(Cond { cond: f2 == ContentType::SPEC_C2, inner: U32Be }, Cond { cond: !(f2 == ContentType::SPEC_C0 || f2 == ContentType::SPEC_C1 || f2 == ContentType::SPEC_C2), inner: bytes::Tail }))), mapper: MsgCF4Mapper }))
 }
 
-pub fn msg_c_f4<'a>(f3: u24, f2: u8) -> (o: MsgCF4Combinator)
-    ensures o@ == spec_msg_c_f4(f3@, f2@),
+pub fn msg_c_f4<'a>(f2: u8, f3: u24) -> (o: MsgCF4Combinator)
+    requires
+        spec_content_type().wf(f2@),
+
+    ensures o@ == spec_msg_c_f4(f2@, f3@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = MsgCF4Combinator(AndThen(bytes::Variable(f3.ex_into()), Mapped { inner: MsgCF4Combinator3(Choice::new(Cond { cond: f2 == ContentType::C0, inner: content_0(f3) }, MsgCF4Combinator2(Choice::new(Cond { cond: f2 == ContentType::C1, inner: U16Be }, MsgCF4Combinator1(Choice::new(Cond { cond: f2 == ContentType::C2, inner: U32Be }, Cond { cond: !(f2 == ContentType::C0 || f2 == ContentType::C1 || f2 == ContentType::C2), inner: bytes::Tail })))))), mapper: MsgCF4Mapper }));
+    let combinator = MsgCF4Combinator(AndThen(bytes::Variable((usize::ex_from(f3)) as usize), Mapped { inner: MsgCF4Combinator3(Choice::new(Cond { cond: f2 == ContentType::C0, inner: content_0(f3) }, MsgCF4Combinator2(Choice::new(Cond { cond: f2 == ContentType::C1, inner: U16Be }, MsgCF4Combinator1(Choice::new(Cond { cond: f2 == ContentType::C2, inner: U32Be }, Cond { cond: !(f2 == ContentType::C0 || f2 == ContentType::C1 || f2 == ContentType::C2), inner: bytes::Tail })))))), mapper: MsgCF4Mapper }));
     // assert({
-    //     &&& combinator@ == spec_msg_c_f4(f3@, f2@)
+    //     &&& combinator@ == spec_msg_c_f4(f2@, f3@)
     //     &&& combinator@.requires()
     //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
     // });
     combinator
 }
 
-pub fn parse_msg_c_f4<'a>(input: &'a [u8], f3: u24, f2: u8) -> (res: PResult<<MsgCF4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_msg_c_f4<'a>(input: &'a [u8], f2: u8, f3: u24) -> (res: PResult<<MsgCF4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_content_type().wf(f2@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_msg_c_f4(f3@, f2@).spec_parse(input@) == Some((n as int, v@)),
-        spec_msg_c_f4(f3@, f2@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_msg_c_f4(f2@, f3@).spec_parse(input@) == Some((n as int, v@)),
+        spec_msg_c_f4(f2@, f3@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_msg_c_f4(f3@, f2@).spec_parse(input@) is None,
-        spec_msg_c_f4(f3@, f2@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_msg_c_f4(f2@, f3@).spec_parse(input@) is None,
+        spec_msg_c_f4(f2@, f3@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = msg_c_f4( f3, f2 );
+    let combinator = msg_c_f4( f2, f3 );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_msg_c_f4<'a>(v: <MsgCF4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, f3: u24, f2: u8) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_msg_c_f4<'a>(v: <MsgCF4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, f2: u8, f3: u24) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_msg_c_f4(f3@, f2@).wf(v@),
+        spec_msg_c_f4(f2@, f3@).wf(v@),
+        spec_content_type().wf(f2@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_msg_c_f4(f3@, f2@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_msg_c_f4(f3@, f2@).spec_serialize(v@))
+            &&& 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( f3, f2 );
+    let combinator = msg_c_f4( f2, f3 );
     combinator.serialize(v, data, pos)
 }
 
-pub fn msg_c_f4_len<'a>(v: <MsgCF4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, f3: u24, f2: u8) -> (serialize_len: usize)
+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(f3@, f2@).wf(v@),
-        spec_msg_c_f4(f3@, f2@).spec_serialize(v@).len() <= usize::MAX,
+        spec_msg_c_f4(f2@, f3@).wf(v@),
+        spec_msg_c_f4(f2@, f3@).spec_serialize(v@).len() <= usize::MAX,
+        spec_content_type().wf(f2@),
+
     ensures
-        serialize_len == spec_msg_c_f4(f3@, f2@).spec_serialize(v@).len(),
+        serialize_len == spec_msg_c_f4(f2@, f3@).spec_serialize(v@).len(),
 {
-    let combinator = msg_c_f4( f3, f2 );
+    let combinator = msg_c_f4( f2, f3 );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
@@ -1314,7 +1327,7 @@ impl View for MsgCCont1 {
 
 pub open spec fn spec_msg_c_cont0(deps: (u8, u24)) -> SpecMsgCF4Combinator {
     let (f2, f3) = deps;
-    spec_msg_c_f4(f3, f2)
+    spec_msg_c_f4(f2, f3)
 }
 
 impl View for MsgCCont0 {
@@ -1394,16 +1407,20 @@ type MsgCCont1Input<'a, 'b, 'x> = POrSType<MsgCCont1Type<'a, 'b>, MsgCCont1SType
 impl<'a, 'b, 'x> Continuation<MsgCCont1Input<'a, 'b, 'x>> for MsgCCont1 {
     type Output = U24Be;
 
-    open spec fn requires(&self, deps: MsgCCont1Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: MsgCCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_content_type()).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: MsgCCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_msg_c_cont1(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_msg_c_cont1(deps@)
     }
 
     fn apply(&self, deps: MsgCCont1Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let f2 = *deps;
+                let f2 = deps;
+                let f2 = *f2;
                 U24Be
             }
             POrSType::S(deps) => {
@@ -1421,22 +1438,28 @@ type MsgCCont0Input<'a, 'b, 'x> = POrSType<MsgCCont0Type<'a, 'b>, MsgCCont0SType
 impl<'a, 'b, 'x> Continuation<MsgCCont0Input<'a, 'b, 'x>> for MsgCCont0 {
     type Output = MsgCF4Combinator;
 
-    open spec fn requires(&self, deps: MsgCCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: MsgCCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_content_type(), |deps| spec_msg_c_cont1(deps))).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: MsgCCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_msg_c_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_msg_c_cont0(deps@)
     }
 
     fn apply(&self, deps: MsgCCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let (f2, f3) = *deps;
-                msg_c_f4(f3, f2)
+                let (f2, f3) = deps;
+                let f2 = *f2;
+                let f3 = *f3;
+                msg_c_f4(f2, f3)
             }
             POrSType::S(deps) => {
                 let (f2, f3) = deps;
-                let (f2, f3) = (*f2, *f3);
-                msg_c_f4(f3, f2)
+                let f2 = *f2;
+                let f3 = *f3;
+                msg_c_f4(f2, f3)
             }
         }
     }
diff --git a/vest-dsl/test/src/enums.rs b/vest-dsl/test/src/enums.rs
index fa5fe335..9c730cbc 100644
--- a/vest-dsl/test/src/enums.rs
+++ b/vest-dsl/test/src/enums.rs
@@ -214,6 +214,9 @@ pub open spec fn spec_a_typed_choose(e: SpecATypedClosedEnum) -> SpecATypedChoos
 }
 
 pub fn a_typed_choose<'a>(e: ATypedClosedEnum) -> (o: ATypedChooseCombinator)
+    requires
+        spec_a_typed_closed_enum().wf(e@),
+
     ensures o@ == spec_a_typed_choose(e@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
@@ -230,6 +233,8 @@ pub fn a_typed_choose<'a>(e: ATypedClosedEnum) -> (o: ATypedChooseCombinator)
 pub fn parse_a_typed_choose<'a>(input: &'a [u8], e: ATypedClosedEnum) -> (res: PResult<<ATypedChooseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_a_typed_closed_enum().wf(e@),
+
     ensures
         res matches Ok((n, v)) ==> spec_a_typed_choose(e@).spec_parse(input@) == Some((n as int, v@)),
         spec_a_typed_choose(e@).spec_parse(input@) matches Some((n, v))
@@ -245,6 +250,8 @@ pub fn serialize_a_typed_choose<'a>(v: <ATypedChooseCombinator as Combinator<'a,
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_a_typed_choose(e@).wf(v@),
+        spec_a_typed_closed_enum().wf(e@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -261,6 +268,8 @@ pub fn a_typed_choose_len<'a>(v: <ATypedChooseCombinator as Combinator<'a, &'a [
     requires
         spec_a_typed_choose(e@).wf(v@),
         spec_a_typed_choose(e@).spec_serialize(v@).len() <= usize::MAX,
+        spec_a_typed_closed_enum().wf(e@),
+
     ensures
         serialize_len == spec_a_typed_choose(e@).spec_serialize(v@).len(),
 {
@@ -868,6 +877,9 @@ pub open spec fn spec_a_regular_choose(e: SpecAClosedEnum) -> SpecARegularChoose
 }
 
 pub fn a_regular_choose<'a>(e: AClosedEnum) -> (o: ARegularChooseCombinator)
+    requires
+        spec_a_closed_enum().wf(e@),
+
     ensures o@ == spec_a_regular_choose(e@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
@@ -884,6 +896,8 @@ pub fn a_regular_choose<'a>(e: AClosedEnum) -> (o: ARegularChooseCombinator)
 pub fn parse_a_regular_choose<'a>(input: &'a [u8], e: AClosedEnum) -> (res: PResult<<ARegularChooseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_a_closed_enum().wf(e@),
+
     ensures
         res matches Ok((n, v)) ==> spec_a_regular_choose(e@).spec_parse(input@) == Some((n as int, v@)),
         spec_a_regular_choose(e@).spec_parse(input@) matches Some((n, v))
@@ -899,6 +913,8 @@ pub fn serialize_a_regular_choose<'a>(v: <ARegularChooseCombinator as Combinator
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_a_regular_choose(e@).wf(v@),
+        spec_a_closed_enum().wf(e@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -915,6 +931,8 @@ pub fn a_regular_choose_len<'a>(v: <ARegularChooseCombinator as Combinator<'a, &
     requires
         spec_a_regular_choose(e@).wf(v@),
         spec_a_regular_choose(e@).spec_serialize(v@).len() <= usize::MAX,
+        spec_a_closed_enum().wf(e@),
+
     ensures
         serialize_len == spec_a_regular_choose(e@).spec_serialize(v@).len(),
 {
@@ -1935,6 +1953,9 @@ pub open spec fn spec_a_typed_choose_with_default(e: u32) -> SpecATypedChooseWit
 }
 
 pub fn a_typed_choose_with_default<'a>(e: u32) -> (o: ATypedChooseWithDefaultCombinator)
+    requires
+        spec_a_typed_open_enum().wf(e@),
+
     ensures o@ == spec_a_typed_choose_with_default(e@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
@@ -1951,6 +1972,8 @@ pub fn a_typed_choose_with_default<'a>(e: u32) -> (o: ATypedChooseWithDefaultCom
 pub fn parse_a_typed_choose_with_default<'a>(input: &'a [u8], e: u32) -> (res: PResult<<ATypedChooseWithDefaultCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_a_typed_open_enum().wf(e@),
+
     ensures
         res matches Ok((n, v)) ==> spec_a_typed_choose_with_default(e@).spec_parse(input@) == Some((n as int, v@)),
         spec_a_typed_choose_with_default(e@).spec_parse(input@) matches Some((n, v))
@@ -1966,6 +1989,8 @@ pub fn serialize_a_typed_choose_with_default<'a>(v: <ATypedChooseWithDefaultComb
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_a_typed_choose_with_default(e@).wf(v@),
+        spec_a_typed_open_enum().wf(e@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -1982,6 +2007,8 @@ pub fn a_typed_choose_with_default_len<'a>(v: <ATypedChooseWithDefaultCombinator
     requires
         spec_a_typed_choose_with_default(e@).wf(v@),
         spec_a_typed_choose_with_default(e@).spec_serialize(v@).len() <= usize::MAX,
+        spec_a_typed_open_enum().wf(e@),
+
     ensures
         serialize_len == spec_a_typed_choose_with_default(e@).spec_serialize(v@).len(),
 {
@@ -2185,6 +2212,9 @@ pub open spec fn spec_a_choose_with_default(e: u8) -> SpecAChooseWithDefaultComb
 }
 
 pub fn a_choose_with_default<'a>(e: u8) -> (o: AChooseWithDefaultCombinator)
+    requires
+        spec_an_open_enum().wf(e@),
+
     ensures o@ == spec_a_choose_with_default(e@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
@@ -2201,6 +2231,8 @@ pub fn a_choose_with_default<'a>(e: u8) -> (o: AChooseWithDefaultCombinator)
 pub fn parse_a_choose_with_default<'a>(input: &'a [u8], e: u8) -> (res: PResult<<AChooseWithDefaultCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_an_open_enum().wf(e@),
+
     ensures
         res matches Ok((n, v)) ==> spec_a_choose_with_default(e@).spec_parse(input@) == Some((n as int, v@)),
         spec_a_choose_with_default(e@).spec_parse(input@) matches Some((n, v))
@@ -2216,6 +2248,8 @@ pub fn serialize_a_choose_with_default<'a>(v: <AChooseWithDefaultCombinator as C
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_a_choose_with_default(e@).wf(v@),
+        spec_an_open_enum().wf(e@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -2232,6 +2266,8 @@ pub fn a_choose_with_default_len<'a>(v: <AChooseWithDefaultCombinator as Combina
     requires
         spec_a_choose_with_default(e@).wf(v@),
         spec_a_choose_with_default(e@).spec_serialize(v@).len() <= usize::MAX,
+        spec_an_open_enum().wf(e@),
+
     ensures
         serialize_len == spec_a_choose_with_default(e@).spec_serialize(v@).len(),
 {
diff --git a/vest-dsl/test/src/ikev2.rs b/vest-dsl/test/src/ikev2.rs
new file mode 100644
index 00000000..2eba4416
--- /dev/null
+++ b/vest-dsl/test/src/ikev2.rs
@@ -0,0 +1,19142 @@
+
+#![allow(warnings)]
+#![allow(unused)]
+use vstd::prelude::*;
+use vest_lib::regular::modifier::*;
+use vest_lib::regular::bytes;
+use vest_lib::regular::variant::*;
+use vest_lib::regular::sequence::*;
+use vest_lib::regular::repetition::*;
+use vest_lib::regular::disjoint::DisjointFrom;
+use vest_lib::regular::tag::*;
+use vest_lib::regular::uints::*;
+use vest_lib::utils::*;
+use vest_lib::properties::*;
+use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
+use vest_lib::regular::leb128::*;
+
+macro_rules! impl_wrapper_combinator {
+    ($combinator:ty, $combinator_alias:ty) => {
+        ::vstd::prelude::verus! {
+            impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for $combinator {
+                type Type = <$combinator_alias as Combinator<'a, &'a [u8], Vec<u8>>>::Type;
+                type SType = <$combinator_alias as Combinator<'a, &'a [u8], Vec<u8>>>::SType;
+                fn length(&self, v: Self::SType) -> usize
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+                open spec fn ex_requires(&self) -> bool
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+                fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&self.0, s) }
+                fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+            }
+        } // verus!
+    };
+}
+verus!{
+pub mod IkeProtocolId {
+    use super::*;
+    pub spec const SPEC_IKE: u8 = 1;
+    pub spec const SPEC_AH: u8 = 2;
+    pub spec const SPEC_ESP: u8 = 3;
+    pub exec const IKE: u8 ensures IKE == SPEC_IKE { 1 }
+    pub exec const AH: u8 ensures AH == SPEC_AH { 2 }
+    pub exec const ESP: u8 ensures ESP == SPEC_ESP { 3 }
+}
+
+
+pub struct SpecIkeProtocolIdCombinator(pub SpecIkeProtocolIdCombinatorAlias);
+
+impl SpecCombinator for SpecIkeProtocolIdCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkeProtocolIdCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkeProtocolIdCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkeProtocolIdCombinatorAlias = U8;
+
+pub struct IkeProtocolIdCombinator(pub IkeProtocolIdCombinatorAlias);
+
+impl View for IkeProtocolIdCombinator {
+    type V = SpecIkeProtocolIdCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkeProtocolIdCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeProtocolIdCombinator {
+    type Type = u8;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type IkeProtocolIdCombinatorAlias = U8;
+
+
+pub open spec fn spec_ike_protocol_id() -> SpecIkeProtocolIdCombinator {
+    SpecIkeProtocolIdCombinator(U8)
+}
+
+                
+pub fn ike_protocol_id<'a>() -> (o: IkeProtocolIdCombinator)
+    ensures o@ == spec_ike_protocol_id(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = IkeProtocolIdCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_ike_protocol_id()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ike_protocol_id<'a>(input: &'a [u8]) -> (res: PResult<<IkeProtocolIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ike_protocol_id().spec_parse(input@) == Some((n as int, v@)),
+        spec_ike_protocol_id().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ike_protocol_id().spec_parse(input@) is None,
+        spec_ike_protocol_id().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ike_protocol_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ike_protocol_id<'a>(v: <IkeProtocolIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ike_protocol_id().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ike_protocol_id().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ike_protocol_id().spec_serialize(v@).len(),
+{
+    let combinator = ike_protocol_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub type SpecProposalSpiSizeByte = u8;
+pub type ProposalSpiSizeByte = u8;
+pub type ProposalSpiSizeByteRef<'a> = &'a u8;
+
+
+pub struct SpecProposalSpiSizeByteCombinator(pub SpecProposalSpiSizeByteCombinatorAlias);
+
+impl SpecCombinator for SpecProposalSpiSizeByteCombinator {
+    type Type = SpecProposalSpiSizeByte;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecProposalSpiSizeByteCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecProposalSpiSizeByteCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecProposalSpiSizeByteCombinatorAlias = Refined<U8, Predicate7607843399309189603>;
+pub struct Predicate7607843399309189603;
+impl View for Predicate7607843399309189603 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate7607843399309189603 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 0) || (i == 4) || (i == 8)
+    }
+}
+impl SpecPred<u8> for Predicate7607843399309189603 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 0) || (i == 4) || (i == 8)
+    }
+}
+
+pub struct ProposalSpiSizeByteCombinator(pub ProposalSpiSizeByteCombinatorAlias);
+
+impl View for ProposalSpiSizeByteCombinator {
+    type V = SpecProposalSpiSizeByteCombinator;
+    open spec fn view(&self) -> Self::V { SpecProposalSpiSizeByteCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalSpiSizeByteCombinator {
+    type Type = ProposalSpiSizeByte;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ProposalSpiSizeByteCombinatorAlias = Refined<U8, Predicate7607843399309189603>;
+
+
+pub open spec fn spec_proposal_spi_size_byte() -> SpecProposalSpiSizeByteCombinator {
+    SpecProposalSpiSizeByteCombinator(Refined { inner: U8, predicate: Predicate7607843399309189603 })
+}
+
+                
+pub fn proposal_spi_size_byte<'a>() -> (o: ProposalSpiSizeByteCombinator)
+    ensures o@ == spec_proposal_spi_size_byte(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ProposalSpiSizeByteCombinator(Refined { inner: U8, predicate: Predicate7607843399309189603 });
+    // assert({
+    //     &&& combinator@ == spec_proposal_spi_size_byte()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_proposal_spi_size_byte<'a>(input: &'a [u8]) -> (res: PResult<<ProposalSpiSizeByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_proposal_spi_size_byte().spec_parse(input@) == Some((n as int, v@)),
+        spec_proposal_spi_size_byte().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_proposal_spi_size_byte().spec_parse(input@) is None,
+        spec_proposal_spi_size_byte().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = proposal_spi_size_byte();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_proposal_spi_size_byte<'a>(v: <ProposalSpiSizeByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_proposal_spi_size_byte().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_proposal_spi_size_byte().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_proposal_spi_size_byte().spec_serialize(v@).len(),
+{
+    let combinator = proposal_spi_size_byte();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub mod TransformType {
+    use super::*;
+    pub spec const SPEC_ENCR: u8 = 1;
+    pub spec const SPEC_PRF: u8 = 2;
+    pub spec const SPEC_INTEG: u8 = 3;
+    pub spec const SPEC_DH: u8 = 4;
+    pub spec const SPEC_ESN: u8 = 5;
+    pub exec const ENCR: u8 ensures ENCR == SPEC_ENCR { 1 }
+    pub exec const PRF: u8 ensures PRF == SPEC_PRF { 2 }
+    pub exec const INTEG: u8 ensures INTEG == SPEC_INTEG { 3 }
+    pub exec const DH: u8 ensures DH == SPEC_DH { 4 }
+    pub exec const ESN: u8 ensures ESN == SPEC_ESN { 5 }
+}
+
+
+pub struct SpecTransformTypeCombinator(pub SpecTransformTypeCombinatorAlias);
+
+impl SpecCombinator for SpecTransformTypeCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTransformTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTransformTypeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTransformTypeCombinatorAlias = U8;
+
+pub struct TransformTypeCombinator(pub TransformTypeCombinatorAlias);
+
+impl View for TransformTypeCombinator {
+    type V = SpecTransformTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecTransformTypeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformTypeCombinator {
+    type Type = u8;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TransformTypeCombinatorAlias = U8;
+
+
+pub open spec fn spec_transform_type() -> SpecTransformTypeCombinator {
+    SpecTransformTypeCombinator(U8)
+}
+
+                
+pub fn transform_type<'a>() -> (o: TransformTypeCombinator)
+    ensures o@ == spec_transform_type(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TransformTypeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_transform_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_transform_type<'a>(input: &'a [u8]) -> (res: PResult<<TransformTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_transform_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_transform_type().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_transform_type().spec_parse(input@) is None,
+        spec_transform_type().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = transform_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_transform_type<'a>(v: <TransformTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_type().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_transform_type().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_transform_type().spec_serialize(v@).len(),
+{
+    let combinator = transform_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub mod EncrId {
+    use super::*;
+    pub spec const SPEC_ENCR_DES_IV64: u16 = 1;
+    pub spec const SPEC_ENCR_DES: u16 = 2;
+    pub spec const SPEC_ENCR_3DES: u16 = 3;
+    pub spec const SPEC_ENCR_RC5: u16 = 4;
+    pub spec const SPEC_ENCR_IDEA: u16 = 5;
+    pub spec const SPEC_ENCR_CAST: u16 = 6;
+    pub spec const SPEC_ENCR_BLOWFISH: u16 = 7;
+    pub spec const SPEC_ENCR_3IDEA: u16 = 8;
+    pub spec const SPEC_ENCR_DES_IV32: u16 = 9;
+    pub spec const SPEC_ENCR_NULL: u16 = 11;
+    pub spec const SPEC_ENCR_AES_CBC: u16 = 12;
+    pub spec const SPEC_ENCR_AES_CTR: u16 = 13;
+    pub exec const ENCR_DES_IV64: u16 ensures ENCR_DES_IV64 == SPEC_ENCR_DES_IV64 { 1 }
+    pub exec const ENCR_DES: u16 ensures ENCR_DES == SPEC_ENCR_DES { 2 }
+    pub exec const ENCR_3DES: u16 ensures ENCR_3DES == SPEC_ENCR_3DES { 3 }
+    pub exec const ENCR_RC5: u16 ensures ENCR_RC5 == SPEC_ENCR_RC5 { 4 }
+    pub exec const ENCR_IDEA: u16 ensures ENCR_IDEA == SPEC_ENCR_IDEA { 5 }
+    pub exec const ENCR_CAST: u16 ensures ENCR_CAST == SPEC_ENCR_CAST { 6 }
+    pub exec const ENCR_BLOWFISH: u16 ensures ENCR_BLOWFISH == SPEC_ENCR_BLOWFISH { 7 }
+    pub exec const ENCR_3IDEA: u16 ensures ENCR_3IDEA == SPEC_ENCR_3IDEA { 8 }
+    pub exec const ENCR_DES_IV32: u16 ensures ENCR_DES_IV32 == SPEC_ENCR_DES_IV32 { 9 }
+    pub exec const ENCR_NULL: u16 ensures ENCR_NULL == SPEC_ENCR_NULL { 11 }
+    pub exec const ENCR_AES_CBC: u16 ensures ENCR_AES_CBC == SPEC_ENCR_AES_CBC { 12 }
+    pub exec const ENCR_AES_CTR: u16 ensures ENCR_AES_CTR == SPEC_ENCR_AES_CTR { 13 }
+}
+
+
+pub struct SpecEncrIdCombinator(pub SpecEncrIdCombinatorAlias);
+
+impl SpecCombinator for SpecEncrIdCombinator {
+    type Type = u16;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecEncrIdCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEncrIdCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecEncrIdCombinatorAlias = U16Be;
+
+pub struct EncrIdCombinator(pub EncrIdCombinatorAlias);
+
+impl View for EncrIdCombinator {
+    type V = SpecEncrIdCombinator;
+    open spec fn view(&self) -> Self::V { SpecEncrIdCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EncrIdCombinator {
+    type Type = u16;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type EncrIdCombinatorAlias = U16Be;
+
+
+pub open spec fn spec_encr_id() -> SpecEncrIdCombinator {
+    SpecEncrIdCombinator(U16Be)
+}
+
+                
+pub fn encr_id<'a>() -> (o: EncrIdCombinator)
+    ensures o@ == spec_encr_id(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = EncrIdCombinator(U16Be);
+    // assert({
+    //     &&& combinator@ == spec_encr_id()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_encr_id<'a>(input: &'a [u8]) -> (res: PResult<<EncrIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_encr_id().spec_parse(input@) == Some((n as int, v@)),
+        spec_encr_id().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_encr_id().spec_parse(input@) is None,
+        spec_encr_id().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = encr_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_encr_id<'a>(v: <EncrIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_encr_id().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_encr_id().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_encr_id().spec_serialize(v@).len(),
+{
+    let combinator = encr_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub mod PrfId {
+    use super::*;
+    pub spec const SPEC_PRF_HMAC_MD5: u16 = 1;
+    pub spec const SPEC_PRF_HMAC_SHA1: u16 = 2;
+    pub spec const SPEC_PRF_HMAC_TIGER: u16 = 3;
+    pub exec const PRF_HMAC_MD5: u16 ensures PRF_HMAC_MD5 == SPEC_PRF_HMAC_MD5 { 1 }
+    pub exec const PRF_HMAC_SHA1: u16 ensures PRF_HMAC_SHA1 == SPEC_PRF_HMAC_SHA1 { 2 }
+    pub exec const PRF_HMAC_TIGER: u16 ensures PRF_HMAC_TIGER == SPEC_PRF_HMAC_TIGER { 3 }
+}
+
+
+pub struct SpecPrfIdCombinator(pub SpecPrfIdCombinatorAlias);
+
+impl SpecCombinator for SpecPrfIdCombinator {
+    type Type = u16;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecPrfIdCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPrfIdCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecPrfIdCombinatorAlias = U16Be;
+
+pub struct PrfIdCombinator(pub PrfIdCombinatorAlias);
+
+impl View for PrfIdCombinator {
+    type V = SpecPrfIdCombinator;
+    open spec fn view(&self) -> Self::V { SpecPrfIdCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PrfIdCombinator {
+    type Type = u16;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type PrfIdCombinatorAlias = U16Be;
+
+
+pub open spec fn spec_prf_id() -> SpecPrfIdCombinator {
+    SpecPrfIdCombinator(U16Be)
+}
+
+                
+pub fn prf_id<'a>() -> (o: PrfIdCombinator)
+    ensures o@ == spec_prf_id(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = PrfIdCombinator(U16Be);
+    // assert({
+    //     &&& combinator@ == spec_prf_id()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_prf_id<'a>(input: &'a [u8]) -> (res: PResult<<PrfIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_prf_id().spec_parse(input@) == Some((n as int, v@)),
+        spec_prf_id().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_prf_id().spec_parse(input@) is None,
+        spec_prf_id().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = prf_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_prf_id<'a>(v: <PrfIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_prf_id().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_prf_id().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_prf_id().spec_serialize(v@).len(),
+{
+    let combinator = prf_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub mod IntegId {
+    use super::*;
+    pub spec const SPEC_INTEG_NONE: u16 = 0;
+    pub spec const SPEC_AUTH_HMAC_MD5_96: u16 = 1;
+    pub spec const SPEC_AUTH_HMAC_SHA1_96: u16 = 2;
+    pub spec const SPEC_AUTH_DES_MAC: u16 = 3;
+    pub spec const SPEC_AUTH_KPDK_MD5: u16 = 4;
+    pub spec const SPEC_AUTH_AES_XCBC_96: u16 = 5;
+    pub exec const INTEG_NONE: u16 ensures INTEG_NONE == SPEC_INTEG_NONE { 0 }
+    pub exec const AUTH_HMAC_MD5_96: u16 ensures AUTH_HMAC_MD5_96 == SPEC_AUTH_HMAC_MD5_96 { 1 }
+    pub exec const AUTH_HMAC_SHA1_96: u16 ensures AUTH_HMAC_SHA1_96 == SPEC_AUTH_HMAC_SHA1_96 { 2 }
+    pub exec const AUTH_DES_MAC: u16 ensures AUTH_DES_MAC == SPEC_AUTH_DES_MAC { 3 }
+    pub exec const AUTH_KPDK_MD5: u16 ensures AUTH_KPDK_MD5 == SPEC_AUTH_KPDK_MD5 { 4 }
+    pub exec const AUTH_AES_XCBC_96: u16 ensures AUTH_AES_XCBC_96 == SPEC_AUTH_AES_XCBC_96 { 5 }
+}
+
+
+pub struct SpecIntegIdCombinator(pub SpecIntegIdCombinatorAlias);
+
+impl SpecCombinator for SpecIntegIdCombinator {
+    type Type = u16;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIntegIdCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIntegIdCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIntegIdCombinatorAlias = U16Be;
+
+pub struct IntegIdCombinator(pub IntegIdCombinatorAlias);
+
+impl View for IntegIdCombinator {
+    type V = SpecIntegIdCombinator;
+    open spec fn view(&self) -> Self::V { SpecIntegIdCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IntegIdCombinator {
+    type Type = u16;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type IntegIdCombinatorAlias = U16Be;
+
+
+pub open spec fn spec_integ_id() -> SpecIntegIdCombinator {
+    SpecIntegIdCombinator(U16Be)
+}
+
+                
+pub fn integ_id<'a>() -> (o: IntegIdCombinator)
+    ensures o@ == spec_integ_id(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = IntegIdCombinator(U16Be);
+    // assert({
+    //     &&& combinator@ == spec_integ_id()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_integ_id<'a>(input: &'a [u8]) -> (res: PResult<<IntegIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_integ_id().spec_parse(input@) == Some((n as int, v@)),
+        spec_integ_id().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_integ_id().spec_parse(input@) is None,
+        spec_integ_id().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = integ_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_integ_id<'a>(v: <IntegIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_integ_id().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_integ_id().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_integ_id().spec_serialize(v@).len(),
+{
+    let combinator = integ_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub mod DhId {
+    use super::*;
+    pub spec const SPEC_DH_NONE: u16 = 0;
+    pub spec const SPEC_MODP_768: u16 = 1;
+    pub spec const SPEC_MODP_1024: u16 = 2;
+    pub spec const SPEC_MODP_1536: u16 = 5;
+    pub spec const SPEC_MODP_2048: u16 = 14;
+    pub spec const SPEC_MODP_3072: u16 = 15;
+    pub spec const SPEC_MODP_4096: u16 = 16;
+    pub spec const SPEC_MODP_6144: u16 = 17;
+    pub spec const SPEC_MODP_8192: u16 = 18;
+    pub exec const DH_NONE: u16 ensures DH_NONE == SPEC_DH_NONE { 0 }
+    pub exec const MODP_768: u16 ensures MODP_768 == SPEC_MODP_768 { 1 }
+    pub exec const MODP_1024: u16 ensures MODP_1024 == SPEC_MODP_1024 { 2 }
+    pub exec const MODP_1536: u16 ensures MODP_1536 == SPEC_MODP_1536 { 5 }
+    pub exec const MODP_2048: u16 ensures MODP_2048 == SPEC_MODP_2048 { 14 }
+    pub exec const MODP_3072: u16 ensures MODP_3072 == SPEC_MODP_3072 { 15 }
+    pub exec const MODP_4096: u16 ensures MODP_4096 == SPEC_MODP_4096 { 16 }
+    pub exec const MODP_6144: u16 ensures MODP_6144 == SPEC_MODP_6144 { 17 }
+    pub exec const MODP_8192: u16 ensures MODP_8192 == SPEC_MODP_8192 { 18 }
+}
+
+
+pub struct SpecDhIdCombinator(pub SpecDhIdCombinatorAlias);
+
+impl SpecCombinator for SpecDhIdCombinator {
+    type Type = u16;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecDhIdCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDhIdCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecDhIdCombinatorAlias = U16Be;
+
+pub struct DhIdCombinator(pub DhIdCombinatorAlias);
+
+impl View for DhIdCombinator {
+    type V = SpecDhIdCombinator;
+    open spec fn view(&self) -> Self::V { SpecDhIdCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DhIdCombinator {
+    type Type = u16;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type DhIdCombinatorAlias = U16Be;
+
+
+pub open spec fn spec_dh_id() -> SpecDhIdCombinator {
+    SpecDhIdCombinator(U16Be)
+}
+
+                
+pub fn dh_id<'a>() -> (o: DhIdCombinator)
+    ensures o@ == spec_dh_id(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = DhIdCombinator(U16Be);
+    // assert({
+    //     &&& combinator@ == spec_dh_id()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_dh_id<'a>(input: &'a [u8]) -> (res: PResult<<DhIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_dh_id().spec_parse(input@) == Some((n as int, v@)),
+        spec_dh_id().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_dh_id().spec_parse(input@) is None,
+        spec_dh_id().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = dh_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_dh_id<'a>(v: <DhIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_dh_id().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_dh_id().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_dh_id().spec_serialize(v@).len(),
+{
+    let combinator = dh_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub mod EsnId {
+    use super::*;
+    pub spec const SPEC_NoESN: u16 = 0;
+    pub spec const SPEC_ESN: u16 = 1;
+    pub exec const NoESN: u16 ensures NoESN == SPEC_NoESN { 0 }
+    pub exec const ESN: u16 ensures ESN == SPEC_ESN { 1 }
+}
+
+
+pub struct SpecEsnIdCombinator(pub SpecEsnIdCombinatorAlias);
+
+impl SpecCombinator for SpecEsnIdCombinator {
+    type Type = u16;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecEsnIdCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEsnIdCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecEsnIdCombinatorAlias = U16Be;
+
+pub struct EsnIdCombinator(pub EsnIdCombinatorAlias);
+
+impl View for EsnIdCombinator {
+    type V = SpecEsnIdCombinator;
+    open spec fn view(&self) -> Self::V { SpecEsnIdCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EsnIdCombinator {
+    type Type = u16;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type EsnIdCombinatorAlias = U16Be;
+
+
+pub open spec fn spec_esn_id() -> SpecEsnIdCombinator {
+    SpecEsnIdCombinator(U16Be)
+}
+
+                
+pub fn esn_id<'a>() -> (o: EsnIdCombinator)
+    ensures o@ == spec_esn_id(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = EsnIdCombinator(U16Be);
+    // assert({
+    //     &&& combinator@ == spec_esn_id()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_esn_id<'a>(input: &'a [u8]) -> (res: PResult<<EsnIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_esn_id().spec_parse(input@) == Some((n as int, v@)),
+        spec_esn_id().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_esn_id().spec_parse(input@) is None,
+        spec_esn_id().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = esn_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_esn_id<'a>(v: <EsnIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_esn_id().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_esn_id().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_esn_id().spec_serialize(v@).len(),
+{
+    let combinator = esn_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub enum SpecTransformIdValue {
+    ENCR(u16),
+    PRF(u16),
+    INTEG(u16),
+    DH(u16),
+    ESN(u16),
+    Unrecognized(u16),
+}
+
+pub type SpecTransformIdValueInner = Either<u16, Either<u16, Either<u16, Either<u16, Either<u16, u16>>>>>;
+
+impl SpecFrom<SpecTransformIdValue> for SpecTransformIdValueInner {
+    open spec fn spec_from(m: SpecTransformIdValue) -> SpecTransformIdValueInner {
+        match m {
+            SpecTransformIdValue::ENCR(m) => Either::Left(m),
+            SpecTransformIdValue::PRF(m) => Either::Right(Either::Left(m)),
+            SpecTransformIdValue::INTEG(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecTransformIdValue::DH(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecTransformIdValue::ESN(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecTransformIdValue::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecTransformIdValueInner> for SpecTransformIdValue {
+    open spec fn spec_from(m: SpecTransformIdValueInner) -> SpecTransformIdValue {
+        match m {
+            Either::Left(m) => SpecTransformIdValue::ENCR(m),
+            Either::Right(Either::Left(m)) => SpecTransformIdValue::PRF(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecTransformIdValue::INTEG(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecTransformIdValue::DH(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecTransformIdValue::ESN(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))) => SpecTransformIdValue::Unrecognized(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TransformIdValue {
+    ENCR(u16),
+    PRF(u16),
+    INTEG(u16),
+    DH(u16),
+    ESN(u16),
+    Unrecognized(u16),
+}
+
+pub type TransformIdValueInner = Either<u16, Either<u16, Either<u16, Either<u16, Either<u16, u16>>>>>;
+
+pub type TransformIdValueInnerRef<'a> = Either<&'a u16, Either<&'a u16, Either<&'a u16, Either<&'a u16, Either<&'a u16, &'a u16>>>>>;
+
+
+impl View for TransformIdValue {
+    type V = SpecTransformIdValue;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            TransformIdValue::ENCR(m) => SpecTransformIdValue::ENCR(m@),
+            TransformIdValue::PRF(m) => SpecTransformIdValue::PRF(m@),
+            TransformIdValue::INTEG(m) => SpecTransformIdValue::INTEG(m@),
+            TransformIdValue::DH(m) => SpecTransformIdValue::DH(m@),
+            TransformIdValue::ESN(m) => SpecTransformIdValue::ESN(m@),
+            TransformIdValue::Unrecognized(m) => SpecTransformIdValue::Unrecognized(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a TransformIdValue> for TransformIdValueInnerRef<'a> {
+    fn ex_from(m: &'a TransformIdValue) -> TransformIdValueInnerRef<'a> {
+        match m {
+            TransformIdValue::ENCR(m) => Either::Left(m),
+            TransformIdValue::PRF(m) => Either::Right(Either::Left(m)),
+            TransformIdValue::INTEG(m) => Either::Right(Either::Right(Either::Left(m))),
+            TransformIdValue::DH(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            TransformIdValue::ESN(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            TransformIdValue::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))),
+        }
+    }
+
+}
+
+impl From<TransformIdValueInner> for TransformIdValue {
+    fn ex_from(m: TransformIdValueInner) -> TransformIdValue {
+        match m {
+            Either::Left(m) => TransformIdValue::ENCR(m),
+            Either::Right(Either::Left(m)) => TransformIdValue::PRF(m),
+            Either::Right(Either::Right(Either::Left(m))) => TransformIdValue::INTEG(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => TransformIdValue::DH(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => TransformIdValue::ESN(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))) => TransformIdValue::Unrecognized(m),
+        }
+    }
+    
+}
+
+
+pub struct TransformIdValueMapper;
+impl View for TransformIdValueMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TransformIdValueMapper {
+    type Src = SpecTransformIdValueInner;
+    type Dst = SpecTransformIdValue;
+}
+impl SpecIsoProof for TransformIdValueMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TransformIdValueMapper {
+    type Src = TransformIdValueInner;
+    type Dst = TransformIdValue;
+    type RefSrc = TransformIdValueInnerRef<'a>;
+}
+
+type SpecTransformIdValueCombinatorAlias1 = Choice<Cond<SpecEsnIdCombinator>, Cond<U16Be>>;
+type SpecTransformIdValueCombinatorAlias2 = Choice<Cond<SpecDhIdCombinator>, SpecTransformIdValueCombinatorAlias1>;
+type SpecTransformIdValueCombinatorAlias3 = Choice<Cond<SpecIntegIdCombinator>, SpecTransformIdValueCombinatorAlias2>;
+type SpecTransformIdValueCombinatorAlias4 = Choice<Cond<SpecPrfIdCombinator>, SpecTransformIdValueCombinatorAlias3>;
+type SpecTransformIdValueCombinatorAlias5 = Choice<Cond<SpecEncrIdCombinator>, SpecTransformIdValueCombinatorAlias4>;
+pub struct SpecTransformIdValueCombinator(pub SpecTransformIdValueCombinatorAlias);
+
+impl SpecCombinator for SpecTransformIdValueCombinator {
+    type Type = SpecTransformIdValue;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTransformIdValueCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTransformIdValueCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTransformIdValueCombinatorAlias = Mapped<SpecTransformIdValueCombinatorAlias5, TransformIdValueMapper>;
+type TransformIdValueCombinatorAlias1 = Choice<Cond<EsnIdCombinator>, Cond<U16Be>>;
+type TransformIdValueCombinatorAlias2 = Choice<Cond<DhIdCombinator>, TransformIdValueCombinator1>;
+type TransformIdValueCombinatorAlias3 = Choice<Cond<IntegIdCombinator>, TransformIdValueCombinator2>;
+type TransformIdValueCombinatorAlias4 = Choice<Cond<PrfIdCombinator>, TransformIdValueCombinator3>;
+type TransformIdValueCombinatorAlias5 = Choice<Cond<EncrIdCombinator>, TransformIdValueCombinator4>;
+pub struct TransformIdValueCombinator1(pub TransformIdValueCombinatorAlias1);
+impl View for TransformIdValueCombinator1 {
+    type V = SpecTransformIdValueCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TransformIdValueCombinator1, TransformIdValueCombinatorAlias1);
+
+pub struct TransformIdValueCombinator2(pub TransformIdValueCombinatorAlias2);
+impl View for TransformIdValueCombinator2 {
+    type V = SpecTransformIdValueCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TransformIdValueCombinator2, TransformIdValueCombinatorAlias2);
+
+pub struct TransformIdValueCombinator3(pub TransformIdValueCombinatorAlias3);
+impl View for TransformIdValueCombinator3 {
+    type V = SpecTransformIdValueCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TransformIdValueCombinator3, TransformIdValueCombinatorAlias3);
+
+pub struct TransformIdValueCombinator4(pub TransformIdValueCombinatorAlias4);
+impl View for TransformIdValueCombinator4 {
+    type V = SpecTransformIdValueCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TransformIdValueCombinator4, TransformIdValueCombinatorAlias4);
+
+pub struct TransformIdValueCombinator5(pub TransformIdValueCombinatorAlias5);
+impl View for TransformIdValueCombinator5 {
+    type V = SpecTransformIdValueCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TransformIdValueCombinator5, TransformIdValueCombinatorAlias5);
+
+pub struct TransformIdValueCombinator(pub TransformIdValueCombinatorAlias);
+
+impl View for TransformIdValueCombinator {
+    type V = SpecTransformIdValueCombinator;
+    open spec fn view(&self) -> Self::V { SpecTransformIdValueCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformIdValueCombinator {
+    type Type = TransformIdValue;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TransformIdValueCombinatorAlias = Mapped<TransformIdValueCombinator5, TransformIdValueMapper>;
+
+
+pub open spec fn spec_transform_id_value(kind: u8) -> SpecTransformIdValueCombinator {
+    SpecTransformIdValueCombinator(Mapped { inner: Choice(Cond { cond: kind == TransformType::SPEC_ENCR, inner: spec_encr_id() }, Choice(Cond { cond: kind == TransformType::SPEC_PRF, inner: spec_prf_id() }, Choice(Cond { cond: kind == TransformType::SPEC_INTEG, inner: spec_integ_id() }, Choice(Cond { cond: kind == TransformType::SPEC_DH, inner: spec_dh_id() }, Choice(Cond { cond: kind == TransformType::SPEC_ESN, inner: spec_esn_id() }, Cond { cond: !(kind == TransformType::SPEC_ENCR || kind == TransformType::SPEC_PRF || kind == TransformType::SPEC_INTEG || kind == TransformType::SPEC_DH || kind == TransformType::SPEC_ESN), inner: U16Be }))))), mapper: TransformIdValueMapper })
+}
+
+pub fn transform_id_value<'a>(kind: u8) -> (o: TransformIdValueCombinator)
+    requires
+        spec_transform_type().wf(kind@),
+
+    ensures o@ == spec_transform_id_value(kind@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TransformIdValueCombinator(Mapped { inner: TransformIdValueCombinator5(Choice::new(Cond { cond: kind == TransformType::ENCR, inner: encr_id() }, TransformIdValueCombinator4(Choice::new(Cond { cond: kind == TransformType::PRF, inner: prf_id() }, TransformIdValueCombinator3(Choice::new(Cond { cond: kind == TransformType::INTEG, inner: integ_id() }, TransformIdValueCombinator2(Choice::new(Cond { cond: kind == TransformType::DH, inner: dh_id() }, TransformIdValueCombinator1(Choice::new(Cond { cond: kind == TransformType::ESN, inner: esn_id() }, Cond { cond: !(kind == TransformType::ENCR || kind == TransformType::PRF || kind == TransformType::INTEG || kind == TransformType::DH || kind == TransformType::ESN), inner: U16Be })))))))))), mapper: TransformIdValueMapper });
+    // assert({
+    //     &&& combinator@ == spec_transform_id_value(kind@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_transform_id_value<'a>(input: &'a [u8], kind: u8) -> (res: PResult<<TransformIdValueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_transform_type().wf(kind@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_transform_id_value(kind@).spec_parse(input@) == Some((n as int, v@)),
+        spec_transform_id_value(kind@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_transform_id_value(kind@).spec_parse(input@) is None,
+        spec_transform_id_value(kind@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = transform_id_value( kind );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_transform_id_value<'a>(v: <TransformIdValueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, kind: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_id_value(kind@).wf(v@),
+        spec_transform_type().wf(kind@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_transform_id_value(kind@).spec_serialize(v@).len() <= usize::MAX,
+        spec_transform_type().wf(kind@),
+
+    ensures
+        serialize_len == spec_transform_id_value(kind@).spec_serialize(v@).len(),
+{
+    let combinator = transform_id_value( kind );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecTransformAttrKeyLength {
+    pub attr_type_and_af: u16,
+    pub key_length_bits: u16,
+}
+
+pub type SpecTransformAttrKeyLengthInner = (u16, u16);
+
+
+impl SpecFrom<SpecTransformAttrKeyLength> for SpecTransformAttrKeyLengthInner {
+    open spec fn spec_from(m: SpecTransformAttrKeyLength) -> SpecTransformAttrKeyLengthInner {
+        (m.attr_type_and_af, m.key_length_bits)
+    }
+}
+
+impl SpecFrom<SpecTransformAttrKeyLengthInner> for SpecTransformAttrKeyLength {
+    open spec fn spec_from(m: SpecTransformAttrKeyLengthInner) -> SpecTransformAttrKeyLength {
+        let (attr_type_and_af, key_length_bits) = m;
+        SpecTransformAttrKeyLength { attr_type_and_af, key_length_bits }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct TransformAttrKeyLength {
+    pub attr_type_and_af: u16,
+    pub key_length_bits: u16,
+}
+
+impl View for TransformAttrKeyLength {
+    type V = SpecTransformAttrKeyLength;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTransformAttrKeyLength {
+            attr_type_and_af: self.attr_type_and_af@,
+            key_length_bits: self.key_length_bits@,
+        }
+    }
+}
+pub type TransformAttrKeyLengthInner = (u16, u16);
+
+pub type TransformAttrKeyLengthInnerRef<'a> = (&'a u16, &'a u16);
+impl<'a> From<&'a TransformAttrKeyLength> for TransformAttrKeyLengthInnerRef<'a> {
+    fn ex_from(m: &'a TransformAttrKeyLength) -> TransformAttrKeyLengthInnerRef<'a> {
+        (&m.attr_type_and_af, &m.key_length_bits)
+    }
+}
+
+impl From<TransformAttrKeyLengthInner> for TransformAttrKeyLength {
+    fn ex_from(m: TransformAttrKeyLengthInner) -> TransformAttrKeyLength {
+        let (attr_type_and_af, key_length_bits) = m;
+        TransformAttrKeyLength { attr_type_and_af, key_length_bits }
+    }
+}
+
+pub struct TransformAttrKeyLengthMapper;
+impl View for TransformAttrKeyLengthMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TransformAttrKeyLengthMapper {
+    type Src = SpecTransformAttrKeyLengthInner;
+    type Dst = SpecTransformAttrKeyLength;
+}
+impl SpecIsoProof for TransformAttrKeyLengthMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TransformAttrKeyLengthMapper {
+    type Src = TransformAttrKeyLengthInner;
+    type Dst = TransformAttrKeyLength;
+    type RefSrc = TransformAttrKeyLengthInnerRef<'a>;
+}
+pub const TRANSFORMATTRKEYLENGTHATTR_TYPE_AND_AF_CONST: u16 = 32782;
+type SpecTransformAttrKeyLengthCombinatorAlias1 = (Refined<U16Be, TagPred<u16>>, U16Be);
+pub struct SpecTransformAttrKeyLengthCombinator(pub SpecTransformAttrKeyLengthCombinatorAlias);
+
+impl SpecCombinator for SpecTransformAttrKeyLengthCombinator {
+    type Type = SpecTransformAttrKeyLength;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTransformAttrKeyLengthCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTransformAttrKeyLengthCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTransformAttrKeyLengthCombinatorAlias = Mapped<SpecTransformAttrKeyLengthCombinatorAlias1, TransformAttrKeyLengthMapper>;
+type TransformAttrKeyLengthCombinatorAlias1 = (Refined<U16Be, TagPred<u16>>, U16Be);
+pub struct TransformAttrKeyLengthCombinator1(pub TransformAttrKeyLengthCombinatorAlias1);
+impl View for TransformAttrKeyLengthCombinator1 {
+    type V = SpecTransformAttrKeyLengthCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TransformAttrKeyLengthCombinator1, TransformAttrKeyLengthCombinatorAlias1);
+
+pub struct TransformAttrKeyLengthCombinator(pub TransformAttrKeyLengthCombinatorAlias);
+
+impl View for TransformAttrKeyLengthCombinator {
+    type V = SpecTransformAttrKeyLengthCombinator;
+    open spec fn view(&self) -> Self::V { SpecTransformAttrKeyLengthCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrKeyLengthCombinator {
+    type Type = TransformAttrKeyLength;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TransformAttrKeyLengthCombinatorAlias = Mapped<TransformAttrKeyLengthCombinator1, TransformAttrKeyLengthMapper>;
+
+
+pub open spec fn spec_transform_attr_key_length() -> SpecTransformAttrKeyLengthCombinator {
+    SpecTransformAttrKeyLengthCombinator(
+    Mapped {
+        inner: (Refined { inner: U16Be, predicate: TagPred(TRANSFORMATTRKEYLENGTHATTR_TYPE_AND_AF_CONST) }, U16Be),
+        mapper: TransformAttrKeyLengthMapper,
+    })
+}
+
+                
+pub fn transform_attr_key_length<'a>() -> (o: TransformAttrKeyLengthCombinator)
+    ensures o@ == spec_transform_attr_key_length(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TransformAttrKeyLengthCombinator(
+    Mapped {
+        inner: TransformAttrKeyLengthCombinator1((Refined { inner: U16Be, predicate: TagPred(TRANSFORMATTRKEYLENGTHATTR_TYPE_AND_AF_CONST) }, U16Be)),
+        mapper: TransformAttrKeyLengthMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_transform_attr_key_length()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_transform_attr_key_length<'a>(input: &'a [u8]) -> (res: PResult<<TransformAttrKeyLengthCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_transform_attr_key_length().spec_parse(input@) == Some((n as int, v@)),
+        spec_transform_attr_key_length().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_transform_attr_key_length().spec_parse(input@) is None,
+        spec_transform_attr_key_length().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = transform_attr_key_length();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_transform_attr_key_length<'a>(v: <TransformAttrKeyLengthCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_attr_key_length().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_transform_attr_key_length().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_transform_attr_key_length().spec_serialize(v@).len(),
+{
+    let combinator = transform_attr_key_length();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecTransformAttrTv {
+    pub type_and_af: u16,
+    pub value: u16,
+}
+
+pub type SpecTransformAttrTvInner = (u16, u16);
+
+
+impl SpecFrom<SpecTransformAttrTv> for SpecTransformAttrTvInner {
+    open spec fn spec_from(m: SpecTransformAttrTv) -> SpecTransformAttrTvInner {
+        (m.type_and_af, m.value)
+    }
+}
+
+impl SpecFrom<SpecTransformAttrTvInner> for SpecTransformAttrTv {
+    open spec fn spec_from(m: SpecTransformAttrTvInner) -> SpecTransformAttrTv {
+        let (type_and_af, value) = m;
+        SpecTransformAttrTv { type_and_af, value }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct TransformAttrTv {
+    pub type_and_af: u16,
+    pub value: u16,
+}
+
+impl View for TransformAttrTv {
+    type V = SpecTransformAttrTv;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTransformAttrTv {
+            type_and_af: self.type_and_af@,
+            value: self.value@,
+        }
+    }
+}
+pub type TransformAttrTvInner = (u16, u16);
+
+pub type TransformAttrTvInnerRef<'a> = (&'a u16, &'a u16);
+impl<'a> From<&'a TransformAttrTv> for TransformAttrTvInnerRef<'a> {
+    fn ex_from(m: &'a TransformAttrTv) -> TransformAttrTvInnerRef<'a> {
+        (&m.type_and_af, &m.value)
+    }
+}
+
+impl From<TransformAttrTvInner> for TransformAttrTv {
+    fn ex_from(m: TransformAttrTvInner) -> TransformAttrTv {
+        let (type_and_af, value) = m;
+        TransformAttrTv { type_and_af, value }
+    }
+}
+
+pub struct TransformAttrTvMapper;
+impl View for TransformAttrTvMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TransformAttrTvMapper {
+    type Src = SpecTransformAttrTvInner;
+    type Dst = SpecTransformAttrTv;
+}
+impl SpecIsoProof for TransformAttrTvMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TransformAttrTvMapper {
+    type Src = TransformAttrTvInner;
+    type Dst = TransformAttrTv;
+    type RefSrc = TransformAttrTvInnerRef<'a>;
+}
+
+pub struct SpecTransformAttrTvCombinator(pub SpecTransformAttrTvCombinatorAlias);
+
+impl SpecCombinator for SpecTransformAttrTvCombinator {
+    type Type = SpecTransformAttrTv;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTransformAttrTvCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTransformAttrTvCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTransformAttrTvCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate11909926070075194211>, U16Be>, TransformAttrTvMapper>;
+pub struct Predicate11909926070075194211;
+impl View for Predicate11909926070075194211 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate11909926070075194211 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 32768 && i <= 32781) || (i >= 32783 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate11909926070075194211 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 32768 && i <= 32781) || (i >= 32783 && i <= 65535)
+    }
+}
+
+pub struct TransformAttrTvCombinator(pub TransformAttrTvCombinatorAlias);
+
+impl View for TransformAttrTvCombinator {
+    type V = SpecTransformAttrTvCombinator;
+    open spec fn view(&self) -> Self::V { SpecTransformAttrTvCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrTvCombinator {
+    type Type = TransformAttrTv;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TransformAttrTvCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate11909926070075194211>, U16Be, TransformAttrTvCont0>, TransformAttrTvMapper>;
+
+
+pub open spec fn spec_transform_attr_tv() -> SpecTransformAttrTvCombinator {
+    SpecTransformAttrTvCombinator(
+    Mapped {
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate11909926070075194211 }, |deps| spec_transform_attr_tv_cont0(deps)),
+        mapper: TransformAttrTvMapper,
+    })
+}
+
+pub open spec fn spec_transform_attr_tv_cont0(deps: u16) -> U16Be {
+    let type_and_af = deps;
+    U16Be
+}
+
+impl View for TransformAttrTvCont0 {
+    type V = spec_fn(u16) -> U16Be;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_transform_attr_tv_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn transform_attr_tv<'a>() -> (o: TransformAttrTvCombinator)
+    ensures o@ == spec_transform_attr_tv(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TransformAttrTvCombinator(
+    Mapped {
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate11909926070075194211 }, TransformAttrTvCont0),
+        mapper: TransformAttrTvMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_transform_attr_tv()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_transform_attr_tv<'a>(input: &'a [u8]) -> (res: PResult<<TransformAttrTvCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_transform_attr_tv().spec_parse(input@) == Some((n as int, v@)),
+        spec_transform_attr_tv().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_transform_attr_tv().spec_parse(input@) is None,
+        spec_transform_attr_tv().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = transform_attr_tv();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_transform_attr_tv<'a>(v: <TransformAttrTvCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_attr_tv().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_transform_attr_tv().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_transform_attr_tv().spec_serialize(v@).len(),
+{
+    let combinator = transform_attr_tv();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct TransformAttrTvCont0;
+type TransformAttrTvCont0Type<'a, 'b> = &'b u16;
+type TransformAttrTvCont0SType<'a, 'x> = &'x u16;
+type TransformAttrTvCont0Input<'a, 'b, 'x> = POrSType<TransformAttrTvCont0Type<'a, 'b>, TransformAttrTvCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TransformAttrTvCont0Input<'a, 'b, 'x>> for TransformAttrTvCont0 {
+    type Output = U16Be;
+
+    open spec fn requires(&self, deps: TransformAttrTvCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate11909926070075194211 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: TransformAttrTvCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_transform_attr_tv_cont0(deps@)
+    }
+
+    fn apply(&self, deps: TransformAttrTvCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let type_and_af = deps;
+                let type_and_af = *type_and_af;
+                U16Be
+            }
+            POrSType::S(deps) => {
+                let type_and_af = deps;
+                let type_and_af = *type_and_af;
+                U16Be
+            }
+        }
+    }
+}
+                
+
+pub struct SpecTransformAttrTlv {
+    pub type_and_af: u16,
+    pub length: u16,
+    pub value: Seq<u8>,
+}
+
+pub type SpecTransformAttrTlvInner = ((u16, u16), Seq<u8>);
+
+
+impl SpecFrom<SpecTransformAttrTlv> for SpecTransformAttrTlvInner {
+    open spec fn spec_from(m: SpecTransformAttrTlv) -> SpecTransformAttrTlvInner {
+        ((m.type_and_af, m.length), m.value)
+    }
+}
+
+impl SpecFrom<SpecTransformAttrTlvInner> for SpecTransformAttrTlv {
+    open spec fn spec_from(m: SpecTransformAttrTlvInner) -> SpecTransformAttrTlv {
+        let ((type_and_af, length), value) = m;
+        SpecTransformAttrTlv { type_and_af, length, value }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct TransformAttrTlv<'a> {
+    pub type_and_af: u16,
+    pub length: u16,
+    pub value: &'a [u8],
+}
+
+impl View for TransformAttrTlv<'_> {
+    type V = SpecTransformAttrTlv;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTransformAttrTlv {
+            type_and_af: self.type_and_af@,
+            length: self.length@,
+            value: self.value@,
+        }
+    }
+}
+pub type TransformAttrTlvInner<'a> = ((u16, u16), &'a [u8]);
+
+pub type TransformAttrTlvInnerRef<'a> = ((&'a u16, &'a u16), &'a &'a [u8]);
+impl<'a> From<&'a TransformAttrTlv<'a>> for TransformAttrTlvInnerRef<'a> {
+    fn ex_from(m: &'a TransformAttrTlv) -> TransformAttrTlvInnerRef<'a> {
+        ((&m.type_and_af, &m.length), &m.value)
+    }
+}
+
+impl<'a> From<TransformAttrTlvInner<'a>> for TransformAttrTlv<'a> {
+    fn ex_from(m: TransformAttrTlvInner) -> TransformAttrTlv {
+        let ((type_and_af, length), value) = m;
+        TransformAttrTlv { type_and_af, length, value }
+    }
+}
+
+pub struct TransformAttrTlvMapper;
+impl View for TransformAttrTlvMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TransformAttrTlvMapper {
+    type Src = SpecTransformAttrTlvInner;
+    type Dst = SpecTransformAttrTlv;
+}
+impl SpecIsoProof for TransformAttrTlvMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TransformAttrTlvMapper {
+    type Src = TransformAttrTlvInner<'a>;
+    type Dst = TransformAttrTlv<'a>;
+    type RefSrc = TransformAttrTlvInnerRef<'a>;
+}
+
+pub struct SpecTransformAttrTlvCombinator(pub SpecTransformAttrTlvCombinatorAlias);
+
+impl SpecCombinator for SpecTransformAttrTlvCombinator {
+    type Type = SpecTransformAttrTlv;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTransformAttrTlvCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTransformAttrTlvCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTransformAttrTlvCombinatorAlias = Mapped<SpecPair<SpecPair<Refined<U16Be, Predicate5630542192344936318>, U16Be>, bytes::Variable>, TransformAttrTlvMapper>;
+pub struct Predicate5630542192344936318;
+impl View for Predicate5630542192344936318 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate5630542192344936318 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 0 && i <= 32767)
+    }
+}
+impl SpecPred<u16> for Predicate5630542192344936318 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 0 && i <= 32767)
+    }
+}
+
+pub struct TransformAttrTlvCombinator(pub TransformAttrTlvCombinatorAlias);
+
+impl View for TransformAttrTlvCombinator {
+    type V = SpecTransformAttrTlvCombinator;
+    open spec fn view(&self) -> Self::V { SpecTransformAttrTlvCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrTlvCombinator {
+    type Type = TransformAttrTlv<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TransformAttrTlvCombinatorAlias = Mapped<Pair<Pair<Refined<U16Be, Predicate5630542192344936318>, U16Be, TransformAttrTlvCont1>, bytes::Variable, TransformAttrTlvCont0>, TransformAttrTlvMapper>;
+
+
+pub open spec fn spec_transform_attr_tlv() -> SpecTransformAttrTlvCombinator {
+    SpecTransformAttrTlvCombinator(
+    Mapped {
+        inner: Pair::spec_new(Pair::spec_new(Refined { inner: U16Be, predicate: Predicate5630542192344936318 }, |deps| spec_transform_attr_tlv_cont1(deps)), |deps| spec_transform_attr_tlv_cont0(deps)),
+        mapper: TransformAttrTlvMapper,
+    })
+}
+
+pub open spec fn spec_transform_attr_tlv_cont1(deps: u16) -> U16Be {
+    let type_and_af = deps;
+    U16Be
+}
+
+impl View for TransformAttrTlvCont1 {
+    type V = spec_fn(u16) -> U16Be;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_transform_attr_tlv_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_transform_attr_tlv_cont0(deps: (u16, u16)) -> bytes::Variable {
+    let (type_and_af, length) = deps;
+    bytes::Variable((usize::spec_from(length)) as usize)
+}
+
+impl View for TransformAttrTlvCont0 {
+    type V = spec_fn((u16, u16)) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u16, u16)| {
+            spec_transform_attr_tlv_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn transform_attr_tlv<'a>() -> (o: TransformAttrTlvCombinator)
+    ensures o@ == spec_transform_attr_tlv(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TransformAttrTlvCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(Refined { inner: U16Be, predicate: Predicate5630542192344936318 }, TransformAttrTlvCont1), TransformAttrTlvCont0),
+        mapper: TransformAttrTlvMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_transform_attr_tlv()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_transform_attr_tlv<'a>(input: &'a [u8]) -> (res: PResult<<TransformAttrTlvCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_transform_attr_tlv().spec_parse(input@) == Some((n as int, v@)),
+        spec_transform_attr_tlv().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_transform_attr_tlv().spec_parse(input@) is None,
+        spec_transform_attr_tlv().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = transform_attr_tlv();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_transform_attr_tlv<'a>(v: <TransformAttrTlvCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_attr_tlv().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_transform_attr_tlv().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_transform_attr_tlv().spec_serialize(v@).len(),
+{
+    let combinator = transform_attr_tlv();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct TransformAttrTlvCont1;
+type TransformAttrTlvCont1Type<'a, 'b> = &'b u16;
+type TransformAttrTlvCont1SType<'a, 'x> = &'x u16;
+type TransformAttrTlvCont1Input<'a, 'b, 'x> = POrSType<TransformAttrTlvCont1Type<'a, 'b>, TransformAttrTlvCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TransformAttrTlvCont1Input<'a, 'b, 'x>> for TransformAttrTlvCont1 {
+    type Output = U16Be;
+
+    open spec fn requires(&self, deps: TransformAttrTlvCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate5630542192344936318 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: TransformAttrTlvCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_transform_attr_tlv_cont1(deps@)
+    }
+
+    fn apply(&self, deps: TransformAttrTlvCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let type_and_af = deps;
+                let type_and_af = *type_and_af;
+                U16Be
+            }
+            POrSType::S(deps) => {
+                let type_and_af = deps;
+                let type_and_af = *type_and_af;
+                U16Be
+            }
+        }
+    }
+}
+pub struct TransformAttrTlvCont0;
+type TransformAttrTlvCont0Type<'a, 'b> = &'b (u16, u16);
+type TransformAttrTlvCont0SType<'a, 'x> = (&'x u16, &'x u16);
+type TransformAttrTlvCont0Input<'a, 'b, 'x> = POrSType<TransformAttrTlvCont0Type<'a, 'b>, TransformAttrTlvCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TransformAttrTlvCont0Input<'a, 'b, 'x>> for TransformAttrTlvCont0 {
+    type Output = bytes::Variable;
+
+    open spec fn requires(&self, deps: TransformAttrTlvCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(Refined { inner: U16Be, predicate: Predicate5630542192344936318 }, |deps| spec_transform_attr_tlv_cont1(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: TransformAttrTlvCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_transform_attr_tlv_cont0(deps@)
+    }
+
+    fn apply(&self, deps: TransformAttrTlvCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (type_and_af, length) = deps;
+                let type_and_af = *type_and_af;
+                let length = *length;
+                bytes::Variable((usize::ex_from(length)) as usize)
+            }
+            POrSType::S(deps) => {
+                let (type_and_af, length) = deps;
+                let type_and_af = *type_and_af;
+                let length = *length;
+                bytes::Variable((usize::ex_from(length)) as usize)
+            }
+        }
+    }
+}
+                
+
+pub enum SpecTransformAttr {
+    KeyLength(SpecTransformAttrKeyLength),
+    TV(SpecTransformAttrTv),
+    TLV(SpecTransformAttrTlv),
+}
+
+pub type SpecTransformAttrInner = Either<SpecTransformAttrKeyLength, Either<SpecTransformAttrTv, SpecTransformAttrTlv>>;
+
+impl SpecFrom<SpecTransformAttr> for SpecTransformAttrInner {
+    open spec fn spec_from(m: SpecTransformAttr) -> SpecTransformAttrInner {
+        match m {
+            SpecTransformAttr::KeyLength(m) => Either::Left(m),
+            SpecTransformAttr::TV(m) => Either::Right(Either::Left(m)),
+            SpecTransformAttr::TLV(m) => Either::Right(Either::Right(m)),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecTransformAttrInner> for SpecTransformAttr {
+    open spec fn spec_from(m: SpecTransformAttrInner) -> SpecTransformAttr {
+        match m {
+            Either::Left(m) => SpecTransformAttr::KeyLength(m),
+            Either::Right(Either::Left(m)) => SpecTransformAttr::TV(m),
+            Either::Right(Either::Right(m)) => SpecTransformAttr::TLV(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TransformAttr<'a> {
+    KeyLength(TransformAttrKeyLength),
+    TV(TransformAttrTv),
+    TLV(TransformAttrTlv<'a>),
+}
+
+pub type TransformAttrInner<'a> = Either<TransformAttrKeyLength, Either<TransformAttrTv, TransformAttrTlv<'a>>>;
+
+pub type TransformAttrInnerRef<'a> = Either<&'a TransformAttrKeyLength, Either<&'a TransformAttrTv, &'a TransformAttrTlv<'a>>>;
+
+
+impl<'a> View for TransformAttr<'a> {
+    type V = SpecTransformAttr;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            TransformAttr::KeyLength(m) => SpecTransformAttr::KeyLength(m@),
+            TransformAttr::TV(m) => SpecTransformAttr::TV(m@),
+            TransformAttr::TLV(m) => SpecTransformAttr::TLV(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a TransformAttr<'a>> for TransformAttrInnerRef<'a> {
+    fn ex_from(m: &'a TransformAttr<'a>) -> TransformAttrInnerRef<'a> {
+        match m {
+            TransformAttr::KeyLength(m) => Either::Left(m),
+            TransformAttr::TV(m) => Either::Right(Either::Left(m)),
+            TransformAttr::TLV(m) => Either::Right(Either::Right(m)),
+        }
+    }
+
+}
+
+impl<'a> From<TransformAttrInner<'a>> for TransformAttr<'a> {
+    fn ex_from(m: TransformAttrInner<'a>) -> TransformAttr<'a> {
+        match m {
+            Either::Left(m) => TransformAttr::KeyLength(m),
+            Either::Right(Either::Left(m)) => TransformAttr::TV(m),
+            Either::Right(Either::Right(m)) => TransformAttr::TLV(m),
+        }
+    }
+    
+}
+
+
+pub struct TransformAttrMapper;
+impl View for TransformAttrMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TransformAttrMapper {
+    type Src = SpecTransformAttrInner;
+    type Dst = SpecTransformAttr;
+}
+impl SpecIsoProof for TransformAttrMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TransformAttrMapper {
+    type Src = TransformAttrInner<'a>;
+    type Dst = TransformAttr<'a>;
+    type RefSrc = TransformAttrInnerRef<'a>;
+}
+
+type SpecTransformAttrCombinatorAlias1 = Choice<SpecTransformAttrTvCombinator, SpecTransformAttrTlvCombinator>;
+type SpecTransformAttrCombinatorAlias2 = Choice<SpecTransformAttrKeyLengthCombinator, SpecTransformAttrCombinatorAlias1>;
+impl DisjointFrom<SpecTransformAttrKeyLengthCombinator> for SpecTransformAttrTvCombinator {
+    open spec fn disjoint_from(&self, other: &SpecTransformAttrKeyLengthCombinator) -> bool
+    { self.0.disjoint_from(&other.0) }
+    proof fn parse_disjoint_on(&self, other: &SpecTransformAttrKeyLengthCombinator, buf: Seq<u8>)
+    { self.0.parse_disjoint_on(&other.0, buf); }
+}
+
+impl DisjointFrom<SpecTransformAttrKeyLengthCombinator> for SpecTransformAttrTlvCombinator {
+    open spec fn disjoint_from(&self, other: &SpecTransformAttrKeyLengthCombinator) -> bool
+    { self.0.disjoint_from(&other.0) }
+    proof fn parse_disjoint_on(&self, other: &SpecTransformAttrKeyLengthCombinator, buf: Seq<u8>)
+    { self.0.parse_disjoint_on(&other.0, buf); }
+}
+
+impl DisjointFrom<SpecTransformAttrTvCombinator> for SpecTransformAttrTlvCombinator {
+    open spec fn disjoint_from(&self, other: &SpecTransformAttrTvCombinator) -> bool
+    { self.0.disjoint_from(&other.0) }
+    proof fn parse_disjoint_on(&self, other: &SpecTransformAttrTvCombinator, buf: Seq<u8>)
+    { self.0.parse_disjoint_on(&other.0, buf); }
+}
+pub struct SpecTransformAttrCombinator(pub SpecTransformAttrCombinatorAlias);
+
+impl SpecCombinator for SpecTransformAttrCombinator {
+    type Type = SpecTransformAttr;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTransformAttrCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTransformAttrCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTransformAttrCombinatorAlias = Mapped<SpecTransformAttrCombinatorAlias2, TransformAttrMapper>;
+type TransformAttrCombinatorAlias1 = Choice<TransformAttrTvCombinator, TransformAttrTlvCombinator>;
+type TransformAttrCombinatorAlias2 = Choice<TransformAttrKeyLengthCombinator, TransformAttrCombinator1>;
+pub struct TransformAttrCombinator1(pub TransformAttrCombinatorAlias1);
+impl View for TransformAttrCombinator1 {
+    type V = SpecTransformAttrCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TransformAttrCombinator1, TransformAttrCombinatorAlias1);
+
+pub struct TransformAttrCombinator2(pub TransformAttrCombinatorAlias2);
+impl View for TransformAttrCombinator2 {
+    type V = SpecTransformAttrCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TransformAttrCombinator2, TransformAttrCombinatorAlias2);
+
+pub struct TransformAttrCombinator(pub TransformAttrCombinatorAlias);
+
+impl View for TransformAttrCombinator {
+    type V = SpecTransformAttrCombinator;
+    open spec fn view(&self) -> Self::V { SpecTransformAttrCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformAttrCombinator {
+    type Type = TransformAttr<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TransformAttrCombinatorAlias = Mapped<TransformAttrCombinator2, TransformAttrMapper>;
+
+
+pub open spec fn spec_transform_attr() -> SpecTransformAttrCombinator {
+    SpecTransformAttrCombinator(Mapped { inner: Choice(spec_transform_attr_key_length(), Choice(spec_transform_attr_tv(), spec_transform_attr_tlv())), mapper: TransformAttrMapper })
+}
+
+                
+pub fn transform_attr<'a>() -> (o: TransformAttrCombinator)
+    ensures o@ == spec_transform_attr(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TransformAttrCombinator(Mapped { inner: TransformAttrCombinator2(Choice::new(transform_attr_key_length(), TransformAttrCombinator1(Choice::new(transform_attr_tv(), transform_attr_tlv())))), mapper: TransformAttrMapper });
+    // assert({
+    //     &&& combinator@ == spec_transform_attr()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_transform_attr<'a>(input: &'a [u8]) -> (res: PResult<<TransformAttrCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_transform_attr().spec_parse(input@) == Some((n as int, v@)),
+        spec_transform_attr().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_transform_attr().spec_parse(input@) is None,
+        spec_transform_attr().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = transform_attr();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_transform_attr<'a>(v: <TransformAttrCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform_attr().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_transform_attr().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_transform_attr().spec_serialize(v@).len(),
+{
+    let combinator = transform_attr();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecTransform {
+    pub last_or_more: u8,
+    pub reserved: u8,
+    pub transform_length: u16,
+    pub transform_type: u8,
+    pub reserved2: u8,
+    pub transform_id: SpecTransformIdValue,
+    pub attrs: Seq<SpecTransformAttr>,
+}
+
+pub type SpecTransformInner = (((u8, (u8, u16)), u8), (u8, (SpecTransformIdValue, Seq<SpecTransformAttr>)));
+
+
+impl SpecFrom<SpecTransform> for SpecTransformInner {
+    open spec fn spec_from(m: SpecTransform) -> SpecTransformInner {
+        (((m.last_or_more, (m.reserved, m.transform_length)), m.transform_type), (m.reserved2, (m.transform_id, m.attrs)))
+    }
+}
+
+impl SpecFrom<SpecTransformInner> for SpecTransform {
+    open spec fn spec_from(m: SpecTransformInner) -> SpecTransform {
+        let (((last_or_more, (reserved, transform_length)), transform_type), (reserved2, (transform_id, attrs))) = m;
+        SpecTransform { last_or_more, reserved, transform_length, transform_type, reserved2, transform_id, attrs }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Transform<'a> {
+    pub last_or_more: u8,
+    pub reserved: u8,
+    pub transform_length: u16,
+    pub transform_type: u8,
+    pub reserved2: u8,
+    pub transform_id: TransformIdValue,
+    pub attrs: RepeatResult<TransformAttr<'a>>,
+}
+
+impl View for Transform<'_> {
+    type V = SpecTransform;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTransform {
+            last_or_more: self.last_or_more@,
+            reserved: self.reserved@,
+            transform_length: self.transform_length@,
+            transform_type: self.transform_type@,
+            reserved2: self.reserved2@,
+            transform_id: self.transform_id@,
+            attrs: self.attrs@,
+        }
+    }
+}
+pub type TransformInner<'a> = (((u8, (u8, u16)), u8), (u8, (TransformIdValue, RepeatResult<TransformAttr<'a>>)));
+
+pub type TransformInnerRef<'a> = (((&'a u8, (&'a u8, &'a u16)), &'a u8), (&'a u8, (&'a TransformIdValue, &'a RepeatResult<TransformAttr<'a>>)));
+impl<'a> From<&'a Transform<'a>> for TransformInnerRef<'a> {
+    fn ex_from(m: &'a Transform) -> TransformInnerRef<'a> {
+        (((&m.last_or_more, (&m.reserved, &m.transform_length)), &m.transform_type), (&m.reserved2, (&m.transform_id, &m.attrs)))
+    }
+}
+
+impl<'a> From<TransformInner<'a>> for Transform<'a> {
+    fn ex_from(m: TransformInner) -> Transform {
+        let (((last_or_more, (reserved, transform_length)), transform_type), (reserved2, (transform_id, attrs))) = m;
+        Transform { last_or_more, reserved, transform_length, transform_type, reserved2, transform_id, attrs }
+    }
+}
+
+pub struct TransformMapper;
+impl View for TransformMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TransformMapper {
+    type Src = SpecTransformInner;
+    type Dst = SpecTransform;
+}
+impl SpecIsoProof for TransformMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TransformMapper {
+    type Src = TransformInner<'a>;
+    type Dst = Transform<'a>;
+    type RefSrc = TransformInnerRef<'a>;
+}
+pub const TRANSFORMRESERVED_CONST: u8 = 0;
+pub const TRANSFORMRESERVED2_CONST: u8 = 0;
+
+pub struct SpecTransformCombinator(pub SpecTransformCombinatorAlias);
+
+impl SpecCombinator for SpecTransformCombinator {
+    type Type = SpecTransform;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTransformCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTransformCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTransformCombinatorAlias = Mapped<SpecPair<SpecPair<(Refined<U8, Predicate11363499016643468509>, (Refined<U8, TagPred<u8>>, Refined<U16Be, Predicate18193225726552524852>)), SpecTransformTypeCombinator>, (Refined<U8, TagPred<u8>>, (SpecTransformIdValueCombinator, AndThen<bytes::Variable, Repeat<SpecTransformAttrCombinator>>))>, TransformMapper>;
+pub struct Predicate11363499016643468509;
+impl View for Predicate11363499016643468509 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate11363499016643468509 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 0) || (i == 3)
+    }
+}
+impl SpecPred<u8> for Predicate11363499016643468509 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 0) || (i == 3)
+    }
+}
+pub struct Predicate18193225726552524852;
+impl View for Predicate18193225726552524852 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate18193225726552524852 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 8 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate18193225726552524852 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 8 && i <= 65535)
+    }
+}
+
+pub struct TransformCombinator(pub TransformCombinatorAlias);
+
+impl View for TransformCombinator {
+    type V = SpecTransformCombinator;
+    open spec fn view(&self) -> Self::V { SpecTransformCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TransformCombinator {
+    type Type = Transform<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::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>;
+
+
+pub open spec fn spec_transform() -> SpecTransformCombinator {
+    SpecTransformCombinator(
+    Mapped {
+        inner: Pair::spec_new(Pair::spec_new((Refined { inner: U8, predicate: Predicate11363499016643468509 }, (Refined { inner: U8, predicate: TagPred(TRANSFORMRESERVED_CONST) }, Refined { inner: U16Be, predicate: Predicate18193225726552524852 })), |deps| spec_transform_cont1(deps)), |deps| spec_transform_cont0(deps)),
+        mapper: TransformMapper,
+    })
+}
+
+pub open spec fn spec_transform_cont1(deps: (u8, (u8, u16))) -> SpecTransformTypeCombinator {
+    let (_, (_, transform_length)) = deps;
+    spec_transform_type()
+}
+
+impl View for TransformCont1 {
+    type V = spec_fn((u8, (u8, u16))) -> SpecTransformTypeCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u8, (u8, u16))| {
+            spec_transform_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_transform_cont0(deps: ((u8, (u8, u16)), u8)) -> (Refined<U8, TagPred<u8>>, (SpecTransformIdValueCombinator, AndThen<bytes::Variable, Repeat<SpecTransformAttrCombinator>>)) {
+    let ((_, (_, transform_length)), transform_type) = deps;
+    (Refined { inner: U8, predicate: TagPred(TRANSFORMRESERVED2_CONST) }, (spec_transform_id_value(transform_type), AndThen(bytes::Variable(((usize::spec_from(transform_length) - 8)) as usize), Repeat(spec_transform_attr()))))
+}
+
+impl View for TransformCont0 {
+    type V = spec_fn(((u8, (u8, u16)), u8)) -> (Refined<U8, TagPred<u8>>, (SpecTransformIdValueCombinator, AndThen<bytes::Variable, Repeat<SpecTransformAttrCombinator>>));
+
+    open spec fn view(&self) -> Self::V {
+        |deps: ((u8, (u8, u16)), u8)| {
+            spec_transform_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn transform<'a>() -> (o: TransformCombinator)
+    ensures o@ == spec_transform(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TransformCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new((Refined { inner: U8, predicate: Predicate11363499016643468509 }, (Refined { inner: U8, predicate: TagPred(TRANSFORMRESERVED_CONST) }, Refined { inner: U16Be, predicate: Predicate18193225726552524852 })), TransformCont1), TransformCont0),
+        mapper: TransformMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_transform()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_transform<'a>(input: &'a [u8]) -> (res: PResult<<TransformCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_transform().spec_parse(input@) == Some((n as int, v@)),
+        spec_transform().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_transform().spec_parse(input@) is None,
+        spec_transform().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = transform();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_transform<'a>(v: <TransformCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_transform().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_transform().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_transform().spec_serialize(v@).len(),
+{
+    let combinator = transform();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct TransformCont1;
+type TransformCont1Type<'a, 'b> = &'b (u8, (u8, u16));
+type TransformCont1SType<'a, 'x> = (&'x u8, (&'x u8, &'x u16));
+type TransformCont1Input<'a, 'b, 'x> = POrSType<TransformCont1Type<'a, 'b>, TransformCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TransformCont1Input<'a, 'b, 'x>> for TransformCont1 {
+    type Output = TransformTypeCombinator;
+
+    open spec fn requires(&self, deps: TransformCont1Input<'a, 'b, 'x>) -> bool {
+        &&& ((Refined { inner: U8, predicate: Predicate11363499016643468509 }, (Refined { inner: U8, predicate: TagPred(TRANSFORMRESERVED_CONST) }, Refined { inner: U16Be, predicate: Predicate18193225726552524852 }))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: TransformCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_transform_cont1(deps@)
+    }
+
+    fn apply(&self, deps: TransformCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (_, (_, transform_length)) = deps;
+                let transform_length = *transform_length;
+                transform_type()
+            }
+            POrSType::S(deps) => {
+                let (_, (_, transform_length)) = deps;
+                let transform_length = *transform_length;
+                transform_type()
+            }
+        }
+    }
+}
+pub struct TransformCont0;
+type TransformCont0Type<'a, 'b> = &'b ((u8, (u8, u16)), u8);
+type TransformCont0SType<'a, 'x> = ((&'x u8, (&'x u8, &'x u16)), &'x u8);
+type TransformCont0Input<'a, 'b, 'x> = POrSType<TransformCont0Type<'a, 'b>, TransformCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TransformCont0Input<'a, 'b, 'x>> for TransformCont0 {
+    type Output = (Refined<U8, TagPred<u8>>, (TransformIdValueCombinator, AndThen<bytes::Variable, Repeat<TransformAttrCombinator>>));
+
+    open spec fn requires(&self, deps: TransformCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new((Refined { inner: U8, predicate: Predicate11363499016643468509 }, (Refined { inner: U8, predicate: TagPred(TRANSFORMRESERVED_CONST) }, Refined { inner: U16Be, predicate: Predicate18193225726552524852 })), |deps| spec_transform_cont1(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: TransformCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_transform_cont0(deps@)
+    }
+
+    fn apply(&self, deps: TransformCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let ((_, (_, transform_length)), transform_type) = deps;
+                let transform_length = *transform_length;
+                let transform_type = *transform_type;
+                (Refined { inner: U8, predicate: TagPred(TRANSFORMRESERVED2_CONST) }, (transform_id_value(transform_type), AndThen(bytes::Variable(((usize::ex_from(transform_length) - 8)) as usize), Repeat::new(transform_attr()))))
+            }
+            POrSType::S(deps) => {
+                let ((_, (_, transform_length)), transform_type) = deps;
+                let transform_length = *transform_length;
+                let transform_type = *transform_type;
+                (Refined { inner: U8, predicate: TagPred(TRANSFORMRESERVED2_CONST) }, (transform_id_value(transform_type), AndThen(bytes::Variable(((usize::ex_from(transform_length) - 8)) as usize), Repeat::new(transform_attr()))))
+            }
+        }
+    }
+}
+                
+
+pub struct SpecProposalBodySpi0 {
+    pub spi: Seq<u8>,
+    pub transforms: Seq<SpecTransform>,
+}
+
+pub type SpecProposalBodySpi0Inner = (Seq<u8>, Seq<SpecTransform>);
+
+
+impl SpecFrom<SpecProposalBodySpi0> for SpecProposalBodySpi0Inner {
+    open spec fn spec_from(m: SpecProposalBodySpi0) -> SpecProposalBodySpi0Inner {
+        (m.spi, m.transforms)
+    }
+}
+
+impl SpecFrom<SpecProposalBodySpi0Inner> for SpecProposalBodySpi0 {
+    open spec fn spec_from(m: SpecProposalBodySpi0Inner) -> SpecProposalBodySpi0 {
+        let (spi, transforms) = m;
+        SpecProposalBodySpi0 { spi, transforms }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct ProposalBodySpi0<'a> {
+    pub spi: &'a [u8],
+    pub transforms: RepeatResult<Transform<'a>>,
+}
+
+impl View for ProposalBodySpi0<'_> {
+    type V = SpecProposalBodySpi0;
+
+    open spec fn view(&self) -> Self::V {
+        SpecProposalBodySpi0 {
+            spi: self.spi@,
+            transforms: self.transforms@,
+        }
+    }
+}
+pub type ProposalBodySpi0Inner<'a> = (&'a [u8], RepeatResult<Transform<'a>>);
+
+pub type ProposalBodySpi0InnerRef<'a> = (&'a &'a [u8], &'a RepeatResult<Transform<'a>>);
+impl<'a> From<&'a ProposalBodySpi0<'a>> for ProposalBodySpi0InnerRef<'a> {
+    fn ex_from(m: &'a ProposalBodySpi0) -> ProposalBodySpi0InnerRef<'a> {
+        (&m.spi, &m.transforms)
+    }
+}
+
+impl<'a> From<ProposalBodySpi0Inner<'a>> for ProposalBodySpi0<'a> {
+    fn ex_from(m: ProposalBodySpi0Inner) -> ProposalBodySpi0 {
+        let (spi, transforms) = m;
+        ProposalBodySpi0 { spi, transforms }
+    }
+}
+
+pub struct ProposalBodySpi0Mapper;
+impl View for ProposalBodySpi0Mapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ProposalBodySpi0Mapper {
+    type Src = SpecProposalBodySpi0Inner;
+    type Dst = SpecProposalBodySpi0;
+}
+impl SpecIsoProof for ProposalBodySpi0Mapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ProposalBodySpi0Mapper {
+    type Src = ProposalBodySpi0Inner<'a>;
+    type Dst = ProposalBodySpi0<'a>;
+    type RefSrc = ProposalBodySpi0InnerRef<'a>;
+}
+type SpecProposalBodySpi0CombinatorAlias1 = (bytes::Fixed<0>, AndThen<bytes::Tail, RepeatN<SpecTransformCombinator>>);
+pub struct SpecProposalBodySpi0Combinator(pub SpecProposalBodySpi0CombinatorAlias);
+
+impl SpecCombinator for SpecProposalBodySpi0Combinator {
+    type Type = SpecProposalBodySpi0;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecProposalBodySpi0Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecProposalBodySpi0CombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecProposalBodySpi0CombinatorAlias = Mapped<SpecProposalBodySpi0CombinatorAlias1, ProposalBodySpi0Mapper>;
+type ProposalBodySpi0CombinatorAlias1 = (bytes::Fixed<0>, AndThen<bytes::Tail, RepeatN<TransformCombinator>>);
+pub struct ProposalBodySpi0Combinator1(pub ProposalBodySpi0CombinatorAlias1);
+impl View for ProposalBodySpi0Combinator1 {
+    type V = SpecProposalBodySpi0CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ProposalBodySpi0Combinator1, ProposalBodySpi0CombinatorAlias1);
+
+pub struct ProposalBodySpi0Combinator(pub ProposalBodySpi0CombinatorAlias);
+
+impl View for ProposalBodySpi0Combinator {
+    type V = SpecProposalBodySpi0Combinator;
+    open spec fn view(&self) -> Self::V { SpecProposalBodySpi0Combinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodySpi0Combinator {
+    type Type = ProposalBodySpi0<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ProposalBodySpi0CombinatorAlias = Mapped<ProposalBodySpi0Combinator1, ProposalBodySpi0Mapper>;
+
+
+pub open spec fn spec_proposal_body_spi0(num_transforms: u8) -> SpecProposalBodySpi0Combinator {
+    SpecProposalBodySpi0Combinator(
+    Mapped {
+        inner: (bytes::Fixed::<0>, AndThen(bytes::Tail, RepeatN(spec_transform(), (usize::spec_from(num_transforms)) as usize))),
+        mapper: ProposalBodySpi0Mapper,
+    })
+}
+
+pub fn proposal_body_spi0<'a>(num_transforms: u8) -> (o: ProposalBodySpi0Combinator)
+    requires
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures o@ == spec_proposal_body_spi0(num_transforms@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ProposalBodySpi0Combinator(
+    Mapped {
+        inner: ProposalBodySpi0Combinator1((bytes::Fixed::<0>, AndThen(bytes::Tail, RepeatN(transform(), (usize::ex_from(num_transforms)) as usize)))),
+        mapper: ProposalBodySpi0Mapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_proposal_body_spi0(num_transforms@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_proposal_body_spi0<'a>(input: &'a [u8], num_transforms: u8) -> (res: PResult<<ProposalBodySpi0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_proposal_body_spi0(num_transforms@).spec_parse(input@) == Some((n as int, v@)),
+        spec_proposal_body_spi0(num_transforms@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_proposal_body_spi0(num_transforms@).spec_parse(input@) is None,
+        spec_proposal_body_spi0(num_transforms@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = proposal_body_spi0( num_transforms );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_proposal_body_spi0<'a>(v: <ProposalBodySpi0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num_transforms: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_proposal_body_spi0(num_transforms@).wf(v@),
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_proposal_body_spi0(num_transforms@).spec_serialize(v@).len() <= usize::MAX,
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures
+        serialize_len == spec_proposal_body_spi0(num_transforms@).spec_serialize(v@).len(),
+{
+    let combinator = proposal_body_spi0( num_transforms );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecProposalBodySpi4 {
+    pub spi: Seq<u8>,
+    pub transforms: Seq<SpecTransform>,
+}
+
+pub type SpecProposalBodySpi4Inner = (Seq<u8>, Seq<SpecTransform>);
+
+
+impl SpecFrom<SpecProposalBodySpi4> for SpecProposalBodySpi4Inner {
+    open spec fn spec_from(m: SpecProposalBodySpi4) -> SpecProposalBodySpi4Inner {
+        (m.spi, m.transforms)
+    }
+}
+
+impl SpecFrom<SpecProposalBodySpi4Inner> for SpecProposalBodySpi4 {
+    open spec fn spec_from(m: SpecProposalBodySpi4Inner) -> SpecProposalBodySpi4 {
+        let (spi, transforms) = m;
+        SpecProposalBodySpi4 { spi, transforms }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct ProposalBodySpi4<'a> {
+    pub spi: &'a [u8],
+    pub transforms: RepeatResult<Transform<'a>>,
+}
+
+impl View for ProposalBodySpi4<'_> {
+    type V = SpecProposalBodySpi4;
+
+    open spec fn view(&self) -> Self::V {
+        SpecProposalBodySpi4 {
+            spi: self.spi@,
+            transforms: self.transforms@,
+        }
+    }
+}
+pub type ProposalBodySpi4Inner<'a> = (&'a [u8], RepeatResult<Transform<'a>>);
+
+pub type ProposalBodySpi4InnerRef<'a> = (&'a &'a [u8], &'a RepeatResult<Transform<'a>>);
+impl<'a> From<&'a ProposalBodySpi4<'a>> for ProposalBodySpi4InnerRef<'a> {
+    fn ex_from(m: &'a ProposalBodySpi4) -> ProposalBodySpi4InnerRef<'a> {
+        (&m.spi, &m.transforms)
+    }
+}
+
+impl<'a> From<ProposalBodySpi4Inner<'a>> for ProposalBodySpi4<'a> {
+    fn ex_from(m: ProposalBodySpi4Inner) -> ProposalBodySpi4 {
+        let (spi, transforms) = m;
+        ProposalBodySpi4 { spi, transforms }
+    }
+}
+
+pub struct ProposalBodySpi4Mapper;
+impl View for ProposalBodySpi4Mapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ProposalBodySpi4Mapper {
+    type Src = SpecProposalBodySpi4Inner;
+    type Dst = SpecProposalBodySpi4;
+}
+impl SpecIsoProof for ProposalBodySpi4Mapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ProposalBodySpi4Mapper {
+    type Src = ProposalBodySpi4Inner<'a>;
+    type Dst = ProposalBodySpi4<'a>;
+    type RefSrc = ProposalBodySpi4InnerRef<'a>;
+}
+type SpecProposalBodySpi4CombinatorAlias1 = (bytes::Fixed<4>, AndThen<bytes::Tail, RepeatN<SpecTransformCombinator>>);
+pub struct SpecProposalBodySpi4Combinator(pub SpecProposalBodySpi4CombinatorAlias);
+
+impl SpecCombinator for SpecProposalBodySpi4Combinator {
+    type Type = SpecProposalBodySpi4;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecProposalBodySpi4Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecProposalBodySpi4CombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecProposalBodySpi4CombinatorAlias = Mapped<SpecProposalBodySpi4CombinatorAlias1, ProposalBodySpi4Mapper>;
+type ProposalBodySpi4CombinatorAlias1 = (bytes::Fixed<4>, AndThen<bytes::Tail, RepeatN<TransformCombinator>>);
+pub struct ProposalBodySpi4Combinator1(pub ProposalBodySpi4CombinatorAlias1);
+impl View for ProposalBodySpi4Combinator1 {
+    type V = SpecProposalBodySpi4CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ProposalBodySpi4Combinator1, ProposalBodySpi4CombinatorAlias1);
+
+pub struct ProposalBodySpi4Combinator(pub ProposalBodySpi4CombinatorAlias);
+
+impl View for ProposalBodySpi4Combinator {
+    type V = SpecProposalBodySpi4Combinator;
+    open spec fn view(&self) -> Self::V { SpecProposalBodySpi4Combinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodySpi4Combinator {
+    type Type = ProposalBodySpi4<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ProposalBodySpi4CombinatorAlias = Mapped<ProposalBodySpi4Combinator1, ProposalBodySpi4Mapper>;
+
+
+pub open spec fn spec_proposal_body_spi4(num_transforms: u8) -> SpecProposalBodySpi4Combinator {
+    SpecProposalBodySpi4Combinator(
+    Mapped {
+        inner: (bytes::Fixed::<4>, AndThen(bytes::Tail, RepeatN(spec_transform(), (usize::spec_from(num_transforms)) as usize))),
+        mapper: ProposalBodySpi4Mapper,
+    })
+}
+
+pub fn proposal_body_spi4<'a>(num_transforms: u8) -> (o: ProposalBodySpi4Combinator)
+    requires
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures o@ == spec_proposal_body_spi4(num_transforms@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ProposalBodySpi4Combinator(
+    Mapped {
+        inner: ProposalBodySpi4Combinator1((bytes::Fixed::<4>, AndThen(bytes::Tail, RepeatN(transform(), (usize::ex_from(num_transforms)) as usize)))),
+        mapper: ProposalBodySpi4Mapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_proposal_body_spi4(num_transforms@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_proposal_body_spi4<'a>(input: &'a [u8], num_transforms: u8) -> (res: PResult<<ProposalBodySpi4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_proposal_body_spi4(num_transforms@).spec_parse(input@) == Some((n as int, v@)),
+        spec_proposal_body_spi4(num_transforms@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_proposal_body_spi4(num_transforms@).spec_parse(input@) is None,
+        spec_proposal_body_spi4(num_transforms@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = proposal_body_spi4( num_transforms );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_proposal_body_spi4<'a>(v: <ProposalBodySpi4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num_transforms: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_proposal_body_spi4(num_transforms@).wf(v@),
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_proposal_body_spi4(num_transforms@).spec_serialize(v@).len() <= usize::MAX,
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures
+        serialize_len == spec_proposal_body_spi4(num_transforms@).spec_serialize(v@).len(),
+{
+    let combinator = proposal_body_spi4( num_transforms );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecProposalBodySpi8 {
+    pub spi: Seq<u8>,
+    pub transforms: Seq<SpecTransform>,
+}
+
+pub type SpecProposalBodySpi8Inner = (Seq<u8>, Seq<SpecTransform>);
+
+
+impl SpecFrom<SpecProposalBodySpi8> for SpecProposalBodySpi8Inner {
+    open spec fn spec_from(m: SpecProposalBodySpi8) -> SpecProposalBodySpi8Inner {
+        (m.spi, m.transforms)
+    }
+}
+
+impl SpecFrom<SpecProposalBodySpi8Inner> for SpecProposalBodySpi8 {
+    open spec fn spec_from(m: SpecProposalBodySpi8Inner) -> SpecProposalBodySpi8 {
+        let (spi, transforms) = m;
+        SpecProposalBodySpi8 { spi, transforms }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct ProposalBodySpi8<'a> {
+    pub spi: &'a [u8],
+    pub transforms: RepeatResult<Transform<'a>>,
+}
+
+impl View for ProposalBodySpi8<'_> {
+    type V = SpecProposalBodySpi8;
+
+    open spec fn view(&self) -> Self::V {
+        SpecProposalBodySpi8 {
+            spi: self.spi@,
+            transforms: self.transforms@,
+        }
+    }
+}
+pub type ProposalBodySpi8Inner<'a> = (&'a [u8], RepeatResult<Transform<'a>>);
+
+pub type ProposalBodySpi8InnerRef<'a> = (&'a &'a [u8], &'a RepeatResult<Transform<'a>>);
+impl<'a> From<&'a ProposalBodySpi8<'a>> for ProposalBodySpi8InnerRef<'a> {
+    fn ex_from(m: &'a ProposalBodySpi8) -> ProposalBodySpi8InnerRef<'a> {
+        (&m.spi, &m.transforms)
+    }
+}
+
+impl<'a> From<ProposalBodySpi8Inner<'a>> for ProposalBodySpi8<'a> {
+    fn ex_from(m: ProposalBodySpi8Inner) -> ProposalBodySpi8 {
+        let (spi, transforms) = m;
+        ProposalBodySpi8 { spi, transforms }
+    }
+}
+
+pub struct ProposalBodySpi8Mapper;
+impl View for ProposalBodySpi8Mapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ProposalBodySpi8Mapper {
+    type Src = SpecProposalBodySpi8Inner;
+    type Dst = SpecProposalBodySpi8;
+}
+impl SpecIsoProof for ProposalBodySpi8Mapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ProposalBodySpi8Mapper {
+    type Src = ProposalBodySpi8Inner<'a>;
+    type Dst = ProposalBodySpi8<'a>;
+    type RefSrc = ProposalBodySpi8InnerRef<'a>;
+}
+type SpecProposalBodySpi8CombinatorAlias1 = (bytes::Fixed<8>, AndThen<bytes::Tail, RepeatN<SpecTransformCombinator>>);
+pub struct SpecProposalBodySpi8Combinator(pub SpecProposalBodySpi8CombinatorAlias);
+
+impl SpecCombinator for SpecProposalBodySpi8Combinator {
+    type Type = SpecProposalBodySpi8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecProposalBodySpi8Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecProposalBodySpi8CombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecProposalBodySpi8CombinatorAlias = Mapped<SpecProposalBodySpi8CombinatorAlias1, ProposalBodySpi8Mapper>;
+type ProposalBodySpi8CombinatorAlias1 = (bytes::Fixed<8>, AndThen<bytes::Tail, RepeatN<TransformCombinator>>);
+pub struct ProposalBodySpi8Combinator1(pub ProposalBodySpi8CombinatorAlias1);
+impl View for ProposalBodySpi8Combinator1 {
+    type V = SpecProposalBodySpi8CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ProposalBodySpi8Combinator1, ProposalBodySpi8CombinatorAlias1);
+
+pub struct ProposalBodySpi8Combinator(pub ProposalBodySpi8CombinatorAlias);
+
+impl View for ProposalBodySpi8Combinator {
+    type V = SpecProposalBodySpi8Combinator;
+    open spec fn view(&self) -> Self::V { SpecProposalBodySpi8Combinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodySpi8Combinator {
+    type Type = ProposalBodySpi8<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ProposalBodySpi8CombinatorAlias = Mapped<ProposalBodySpi8Combinator1, ProposalBodySpi8Mapper>;
+
+
+pub open spec fn spec_proposal_body_spi8(num_transforms: u8) -> SpecProposalBodySpi8Combinator {
+    SpecProposalBodySpi8Combinator(
+    Mapped {
+        inner: (bytes::Fixed::<8>, AndThen(bytes::Tail, RepeatN(spec_transform(), (usize::spec_from(num_transforms)) as usize))),
+        mapper: ProposalBodySpi8Mapper,
+    })
+}
+
+pub fn proposal_body_spi8<'a>(num_transforms: u8) -> (o: ProposalBodySpi8Combinator)
+    requires
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures o@ == spec_proposal_body_spi8(num_transforms@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ProposalBodySpi8Combinator(
+    Mapped {
+        inner: ProposalBodySpi8Combinator1((bytes::Fixed::<8>, AndThen(bytes::Tail, RepeatN(transform(), (usize::ex_from(num_transforms)) as usize)))),
+        mapper: ProposalBodySpi8Mapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_proposal_body_spi8(num_transforms@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_proposal_body_spi8<'a>(input: &'a [u8], num_transforms: u8) -> (res: PResult<<ProposalBodySpi8Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_proposal_body_spi8(num_transforms@).spec_parse(input@) == Some((n as int, v@)),
+        spec_proposal_body_spi8(num_transforms@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_proposal_body_spi8(num_transforms@).spec_parse(input@) is None,
+        spec_proposal_body_spi8(num_transforms@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = proposal_body_spi8( num_transforms );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_proposal_body_spi8<'a>(v: <ProposalBodySpi8Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num_transforms: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_proposal_body_spi8(num_transforms@).wf(v@),
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_proposal_body_spi8(num_transforms@).spec_serialize(v@).len() <= usize::MAX,
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+
+    ensures
+        serialize_len == spec_proposal_body_spi8(num_transforms@).spec_serialize(v@).len(),
+{
+    let combinator = proposal_body_spi8( num_transforms );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub enum SpecProposalBody {
+    Variant0(SpecProposalBodySpi0),
+    Variant1(SpecProposalBodySpi4),
+    Variant2(SpecProposalBodySpi8),
+}
+
+pub type SpecProposalBodyInner = Either<SpecProposalBodySpi0, Either<SpecProposalBodySpi4, SpecProposalBodySpi8>>;
+
+impl SpecFrom<SpecProposalBody> for SpecProposalBodyInner {
+    open spec fn spec_from(m: SpecProposalBody) -> SpecProposalBodyInner {
+        match m {
+            SpecProposalBody::Variant0(m) => Either::Left(m),
+            SpecProposalBody::Variant1(m) => Either::Right(Either::Left(m)),
+            SpecProposalBody::Variant2(m) => Either::Right(Either::Right(m)),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecProposalBodyInner> for SpecProposalBody {
+    open spec fn spec_from(m: SpecProposalBodyInner) -> SpecProposalBody {
+        match m {
+            Either::Left(m) => SpecProposalBody::Variant0(m),
+            Either::Right(Either::Left(m)) => SpecProposalBody::Variant1(m),
+            Either::Right(Either::Right(m)) => SpecProposalBody::Variant2(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ProposalBody<'a> {
+    Variant0(ProposalBodySpi0<'a>),
+    Variant1(ProposalBodySpi4<'a>),
+    Variant2(ProposalBodySpi8<'a>),
+}
+
+pub type ProposalBodyInner<'a> = Either<ProposalBodySpi0<'a>, Either<ProposalBodySpi4<'a>, ProposalBodySpi8<'a>>>;
+
+pub type ProposalBodyInnerRef<'a> = Either<&'a ProposalBodySpi0<'a>, Either<&'a ProposalBodySpi4<'a>, &'a ProposalBodySpi8<'a>>>;
+
+
+impl<'a> View for ProposalBody<'a> {
+    type V = SpecProposalBody;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            ProposalBody::Variant0(m) => SpecProposalBody::Variant0(m@),
+            ProposalBody::Variant1(m) => SpecProposalBody::Variant1(m@),
+            ProposalBody::Variant2(m) => SpecProposalBody::Variant2(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a ProposalBody<'a>> for ProposalBodyInnerRef<'a> {
+    fn ex_from(m: &'a ProposalBody<'a>) -> ProposalBodyInnerRef<'a> {
+        match m {
+            ProposalBody::Variant0(m) => Either::Left(m),
+            ProposalBody::Variant1(m) => Either::Right(Either::Left(m)),
+            ProposalBody::Variant2(m) => Either::Right(Either::Right(m)),
+        }
+    }
+
+}
+
+impl<'a> From<ProposalBodyInner<'a>> for ProposalBody<'a> {
+    fn ex_from(m: ProposalBodyInner<'a>) -> ProposalBody<'a> {
+        match m {
+            Either::Left(m) => ProposalBody::Variant0(m),
+            Either::Right(Either::Left(m)) => ProposalBody::Variant1(m),
+            Either::Right(Either::Right(m)) => ProposalBody::Variant2(m),
+        }
+    }
+    
+}
+
+
+pub struct ProposalBodyMapper;
+impl View for ProposalBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ProposalBodyMapper {
+    type Src = SpecProposalBodyInner;
+    type Dst = SpecProposalBody;
+}
+impl SpecIsoProof for ProposalBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ProposalBodyMapper {
+    type Src = ProposalBodyInner<'a>;
+    type Dst = ProposalBody<'a>;
+    type RefSrc = ProposalBodyInnerRef<'a>;
+}
+
+type SpecProposalBodyCombinatorAlias1 = Choice<Cond<SpecProposalBodySpi4Combinator>, Cond<SpecProposalBodySpi8Combinator>>;
+type SpecProposalBodyCombinatorAlias2 = Choice<Cond<SpecProposalBodySpi0Combinator>, SpecProposalBodyCombinatorAlias1>;
+pub struct SpecProposalBodyCombinator(pub SpecProposalBodyCombinatorAlias);
+
+impl SpecCombinator for SpecProposalBodyCombinator {
+    type Type = SpecProposalBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecProposalBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecProposalBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecProposalBodyCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecProposalBodyCombinatorAlias2, ProposalBodyMapper>>;
+type ProposalBodyCombinatorAlias1 = Choice<Cond<ProposalBodySpi4Combinator>, Cond<ProposalBodySpi8Combinator>>;
+type ProposalBodyCombinatorAlias2 = Choice<Cond<ProposalBodySpi0Combinator>, ProposalBodyCombinator1>;
+pub struct ProposalBodyCombinator1(pub ProposalBodyCombinatorAlias1);
+impl View for ProposalBodyCombinator1 {
+    type V = SpecProposalBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ProposalBodyCombinator1, ProposalBodyCombinatorAlias1);
+
+pub struct ProposalBodyCombinator2(pub ProposalBodyCombinatorAlias2);
+impl View for ProposalBodyCombinator2 {
+    type V = SpecProposalBodyCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ProposalBodyCombinator2, ProposalBodyCombinatorAlias2);
+
+pub struct ProposalBodyCombinator(pub ProposalBodyCombinatorAlias);
+
+impl View for ProposalBodyCombinator {
+    type V = SpecProposalBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecProposalBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalBodyCombinator {
+    type Type = ProposalBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ProposalBodyCombinatorAlias = AndThen<bytes::Variable, Mapped<ProposalBodyCombinator2, ProposalBodyMapper>>;
+
+
+pub open spec fn spec_proposal_body(num_transforms: u8, proposal_length: u16, spi_size: SpecProposalSpiSizeByte) -> SpecProposalBodyCombinator {
+    SpecProposalBodyCombinator(AndThen(bytes::Variable(((usize::spec_from(proposal_length) - 8)) as usize), Mapped { inner: Choice(Cond { cond: spi_size == 0, inner: spec_proposal_body_spi0(num_transforms) }, Choice(Cond { cond: spi_size == 4, inner: spec_proposal_body_spi4(num_transforms) }, Cond { cond: spi_size == 8, inner: spec_proposal_body_spi8(num_transforms) })), mapper: ProposalBodyMapper }))
+}
+
+pub fn proposal_body<'a>(num_transforms: u8, proposal_length: u16, spi_size: ProposalSpiSizeByte) -> (o: ProposalBodyCombinator)
+    requires
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+        ((proposal_length) >= 8 && (proposal_length) <= 65535),
+        spec_proposal_spi_size_byte().wf(spi_size@),
+
+    ensures o@ == spec_proposal_body(num_transforms@, proposal_length@, spi_size@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ProposalBodyCombinator(AndThen(bytes::Variable(((usize::ex_from(proposal_length) - 8)) as usize), Mapped { inner: ProposalBodyCombinator2(Choice::new(Cond { cond: spi_size == 0, inner: proposal_body_spi0(num_transforms) }, ProposalBodyCombinator1(Choice::new(Cond { cond: spi_size == 4, inner: proposal_body_spi4(num_transforms) }, Cond { cond: spi_size == 8, inner: proposal_body_spi8(num_transforms) })))), mapper: ProposalBodyMapper }));
+    // assert({
+    //     &&& combinator@ == spec_proposal_body(num_transforms@, proposal_length@, spi_size@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_proposal_body<'a>(input: &'a [u8], num_transforms: u8, proposal_length: u16, spi_size: ProposalSpiSizeByte) -> (res: PResult<<ProposalBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+        ((proposal_length) >= 8 && (proposal_length) <= 65535),
+        spec_proposal_spi_size_byte().wf(spi_size@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_proposal_body(num_transforms@, proposal_length@, spi_size@).spec_parse(input@) == Some((n as int, v@)),
+        spec_proposal_body(num_transforms@, proposal_length@, spi_size@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_proposal_body(num_transforms@, proposal_length@, spi_size@).spec_parse(input@) is None,
+        spec_proposal_body(num_transforms@, proposal_length@, spi_size@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = proposal_body( num_transforms, proposal_length, spi_size );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_proposal_body<'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) -> (o: SResult<usize, SerializeError>)
+    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@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_proposal_body(num_transforms@, proposal_length@, spi_size@).spec_serialize(v@).len() <= usize::MAX,
+        ((num_transforms) >= 1 && (num_transforms) <= 255),
+        ((proposal_length) >= 8 && (proposal_length) <= 65535),
+        spec_proposal_spi_size_byte().wf(spi_size@),
+
+    ensures
+        serialize_len == spec_proposal_body(num_transforms@, proposal_length@, spi_size@).spec_serialize(v@).len(),
+{
+    let combinator = proposal_body( num_transforms, proposal_length, spi_size );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecProposal {
+    pub last_or_more: u8,
+    pub reserved: u8,
+    pub proposal_length: u16,
+    pub proposal_num: u8,
+    pub protocol_id: u8,
+    pub spi_size: SpecProposalSpiSizeByte,
+    pub num_transforms: u8,
+    pub body: SpecProposalBody,
+}
+
+pub type SpecProposalInner = (((((u8, (u8, u16)), (u8, u8)), SpecProposalSpiSizeByte), u8), SpecProposalBody);
+
+
+impl SpecFrom<SpecProposal> for SpecProposalInner {
+    open spec fn spec_from(m: SpecProposal) -> SpecProposalInner {
+        (((((m.last_or_more, (m.reserved, m.proposal_length)), (m.proposal_num, m.protocol_id)), m.spi_size), m.num_transforms), m.body)
+    }
+}
+
+impl SpecFrom<SpecProposalInner> for SpecProposal {
+    open spec fn spec_from(m: SpecProposalInner) -> SpecProposal {
+        let (((((last_or_more, (reserved, proposal_length)), (proposal_num, protocol_id)), spi_size), num_transforms), body) = m;
+        SpecProposal { last_or_more, reserved, proposal_length, proposal_num, protocol_id, spi_size, num_transforms, body }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Proposal<'a> {
+    pub last_or_more: u8,
+    pub reserved: u8,
+    pub proposal_length: u16,
+    pub proposal_num: u8,
+    pub protocol_id: u8,
+    pub spi_size: ProposalSpiSizeByte,
+    pub num_transforms: u8,
+    pub body: ProposalBody<'a>,
+}
+
+impl View for Proposal<'_> {
+    type V = SpecProposal;
+
+    open spec fn view(&self) -> Self::V {
+        SpecProposal {
+            last_or_more: self.last_or_more@,
+            reserved: self.reserved@,
+            proposal_length: self.proposal_length@,
+            proposal_num: self.proposal_num@,
+            protocol_id: self.protocol_id@,
+            spi_size: self.spi_size@,
+            num_transforms: self.num_transforms@,
+            body: self.body@,
+        }
+    }
+}
+pub type ProposalInner<'a> = (((((u8, (u8, u16)), (u8, u8)), ProposalSpiSizeByte), u8), ProposalBody<'a>);
+
+pub type ProposalInnerRef<'a> = (((((&'a u8, (&'a u8, &'a u16)), (&'a u8, &'a u8)), &'a ProposalSpiSizeByte), &'a u8), &'a ProposalBody<'a>);
+impl<'a> From<&'a Proposal<'a>> for ProposalInnerRef<'a> {
+    fn ex_from(m: &'a Proposal) -> ProposalInnerRef<'a> {
+        (((((&m.last_or_more, (&m.reserved, &m.proposal_length)), (&m.proposal_num, &m.protocol_id)), &m.spi_size), &m.num_transforms), &m.body)
+    }
+}
+
+impl<'a> From<ProposalInner<'a>> for Proposal<'a> {
+    fn ex_from(m: ProposalInner) -> Proposal {
+        let (((((last_or_more, (reserved, proposal_length)), (proposal_num, protocol_id)), spi_size), num_transforms), body) = m;
+        Proposal { last_or_more, reserved, proposal_length, proposal_num, protocol_id, spi_size, num_transforms, body }
+    }
+}
+
+pub struct ProposalMapper;
+impl View for ProposalMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ProposalMapper {
+    type Src = SpecProposalInner;
+    type Dst = SpecProposal;
+}
+impl SpecIsoProof for ProposalMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ProposalMapper {
+    type Src = ProposalInner<'a>;
+    type Dst = Proposal<'a>;
+    type RefSrc = ProposalInnerRef<'a>;
+}
+pub const PROPOSALRESERVED_CONST: u8 = 0;
+
+pub struct SpecProposalCombinator(pub SpecProposalCombinatorAlias);
+
+impl SpecCombinator for SpecProposalCombinator {
+    type Type = SpecProposal;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecProposalCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecProposalCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecProposalCombinatorAlias = Mapped<SpecPair<SpecPair<SpecPair<SpecPair<(Refined<U8, Predicate7277979220772363767>, (Refined<U8, TagPred<u8>>, Refined<U16Be, Predicate18193225726552524852>)), (Refined<U8, Predicate2172399096230090262>, SpecIkeProtocolIdCombinator)>, SpecProposalSpiSizeByteCombinator>, Refined<U8, Predicate3651688686135228051>>, SpecProposalBodyCombinator>, ProposalMapper>;
+pub struct Predicate7277979220772363767;
+impl View for Predicate7277979220772363767 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate7277979220772363767 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 0) || (i == 2)
+    }
+}
+impl SpecPred<u8> for Predicate7277979220772363767 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 0) || (i == 2)
+    }
+}
+pub struct Predicate2172399096230090262;
+impl View for Predicate2172399096230090262 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate2172399096230090262 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 1)
+    }
+}
+impl SpecPred<u8> for Predicate2172399096230090262 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 1)
+    }
+}
+pub struct Predicate3651688686135228051;
+impl View for Predicate3651688686135228051 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate3651688686135228051 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 1 && i <= 255)
+    }
+}
+impl SpecPred<u8> for Predicate3651688686135228051 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 1 && i <= 255)
+    }
+}
+
+pub struct ProposalCombinator(pub ProposalCombinatorAlias);
+
+impl View for ProposalCombinator {
+    type V = SpecProposalCombinator;
+    open spec fn view(&self) -> Self::V { SpecProposalCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProposalCombinator {
+    type Type = Proposal<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::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>;
+
+
+pub open spec fn spec_proposal() -> SpecProposalCombinator {
+    SpecProposalCombinator(
+    Mapped {
+        inner: Pair::spec_new(Pair::spec_new(Pair::spec_new(Pair::spec_new((Refined { inner: U8, predicate: Predicate7277979220772363767 }, (Refined { inner: U8, predicate: TagPred(PROPOSALRESERVED_CONST) }, Refined { inner: U16Be, predicate: Predicate18193225726552524852 })), |deps| spec_proposal_cont3(deps)), |deps| spec_proposal_cont2(deps)), |deps| spec_proposal_cont1(deps)), |deps| spec_proposal_cont0(deps)),
+        mapper: ProposalMapper,
+    })
+}
+
+pub open spec fn spec_proposal_cont3(deps: (u8, (u8, u16))) -> (Refined<U8, Predicate2172399096230090262>, SpecIkeProtocolIdCombinator) {
+    let (_, (_, proposal_length)) = deps;
+    (Refined { inner: U8, predicate: Predicate2172399096230090262 }, spec_ike_protocol_id())
+}
+
+impl View for ProposalCont3 {
+    type V = spec_fn((u8, (u8, u16))) -> (Refined<U8, Predicate2172399096230090262>, SpecIkeProtocolIdCombinator);
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u8, (u8, u16))| {
+            spec_proposal_cont3(deps)
+        }
+    }
+}
+
+pub open spec fn spec_proposal_cont2(deps: ((u8, (u8, u16)), (u8, u8))) -> SpecProposalSpiSizeByteCombinator {
+    let ((_, (_, proposal_length)), (_, protocol_id)) = deps;
+    spec_proposal_spi_size_byte()
+}
+
+impl View for ProposalCont2 {
+    type V = spec_fn(((u8, (u8, u16)), (u8, u8))) -> SpecProposalSpiSizeByteCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: ((u8, (u8, u16)), (u8, u8))| {
+            spec_proposal_cont2(deps)
+        }
+    }
+}
+
+pub open spec fn spec_proposal_cont1(deps: (((u8, (u8, u16)), (u8, u8)), SpecProposalSpiSizeByte)) -> Refined<U8, Predicate3651688686135228051> {
+    let (((_, (_, proposal_length)), (_, protocol_id)), spi_size) = deps;
+    Refined { inner: U8, predicate: Predicate3651688686135228051 }
+}
+
+impl View for ProposalCont1 {
+    type V = spec_fn((((u8, (u8, u16)), (u8, u8)), SpecProposalSpiSizeByte)) -> Refined<U8, Predicate3651688686135228051>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (((u8, (u8, u16)), (u8, u8)), SpecProposalSpiSizeByte)| {
+            spec_proposal_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_proposal_cont0(deps: ((((u8, (u8, u16)), (u8, u8)), SpecProposalSpiSizeByte), u8)) -> SpecProposalBodyCombinator {
+    let ((((_, (_, proposal_length)), (_, protocol_id)), spi_size), num_transforms) = deps;
+    spec_proposal_body(num_transforms, proposal_length, spi_size)
+}
+
+impl View for ProposalCont0 {
+    type V = spec_fn(((((u8, (u8, u16)), (u8, u8)), SpecProposalSpiSizeByte), u8)) -> SpecProposalBodyCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: ((((u8, (u8, u16)), (u8, u8)), SpecProposalSpiSizeByte), u8)| {
+            spec_proposal_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn proposal<'a>() -> (o: ProposalCombinator)
+    ensures o@ == spec_proposal(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ProposalCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(Pair::new(Pair::new((Refined { inner: U8, predicate: Predicate7277979220772363767 }, (Refined { inner: U8, predicate: TagPred(PROPOSALRESERVED_CONST) }, Refined { inner: U16Be, predicate: Predicate18193225726552524852 })), ProposalCont3), ProposalCont2), ProposalCont1), ProposalCont0),
+        mapper: ProposalMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_proposal()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_proposal<'a>(input: &'a [u8]) -> (res: PResult<<ProposalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_proposal().spec_parse(input@) == Some((n as int, v@)),
+        spec_proposal().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_proposal().spec_parse(input@) is None,
+        spec_proposal().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = proposal();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_proposal<'a>(v: <ProposalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_proposal().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_proposal().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_proposal().spec_serialize(v@).len(),
+{
+    let combinator = proposal();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct ProposalCont3;
+type ProposalCont3Type<'a, 'b> = &'b (u8, (u8, u16));
+type ProposalCont3SType<'a, 'x> = (&'x u8, (&'x u8, &'x u16));
+type ProposalCont3Input<'a, 'b, 'x> = POrSType<ProposalCont3Type<'a, 'b>, ProposalCont3SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ProposalCont3Input<'a, 'b, 'x>> for ProposalCont3 {
+    type Output = (Refined<U8, Predicate2172399096230090262>, IkeProtocolIdCombinator);
+
+    open spec fn requires(&self, deps: ProposalCont3Input<'a, 'b, 'x>) -> bool {
+        &&& ((Refined { inner: U8, predicate: Predicate7277979220772363767 }, (Refined { inner: U8, predicate: TagPred(PROPOSALRESERVED_CONST) }, Refined { inner: U16Be, predicate: Predicate18193225726552524852 }))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: ProposalCont3Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_proposal_cont3(deps@)
+    }
+
+    fn apply(&self, deps: ProposalCont3Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (_, (_, proposal_length)) = deps;
+                let proposal_length = *proposal_length;
+                (Refined { inner: U8, predicate: Predicate2172399096230090262 }, ike_protocol_id())
+            }
+            POrSType::S(deps) => {
+                let (_, (_, proposal_length)) = deps;
+                let proposal_length = *proposal_length;
+                (Refined { inner: U8, predicate: Predicate2172399096230090262 }, ike_protocol_id())
+            }
+        }
+    }
+}
+pub struct ProposalCont2;
+type ProposalCont2Type<'a, 'b> = &'b ((u8, (u8, u16)), (u8, u8));
+type ProposalCont2SType<'a, 'x> = ((&'x u8, (&'x u8, &'x u16)), (&'x u8, &'x u8));
+type ProposalCont2Input<'a, 'b, 'x> = POrSType<ProposalCont2Type<'a, 'b>, ProposalCont2SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ProposalCont2Input<'a, 'b, 'x>> for ProposalCont2 {
+    type Output = ProposalSpiSizeByteCombinator;
+
+    open spec fn requires(&self, deps: ProposalCont2Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new((Refined { inner: U8, predicate: Predicate7277979220772363767 }, (Refined { inner: U8, predicate: TagPred(PROPOSALRESERVED_CONST) }, Refined { inner: U16Be, predicate: Predicate18193225726552524852 })), |deps| spec_proposal_cont3(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: ProposalCont2Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_proposal_cont2(deps@)
+    }
+
+    fn apply(&self, deps: ProposalCont2Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let ((_, (_, proposal_length)), (_, protocol_id)) = deps;
+                let proposal_length = *proposal_length;
+                let protocol_id = *protocol_id;
+                proposal_spi_size_byte()
+            }
+            POrSType::S(deps) => {
+                let ((_, (_, proposal_length)), (_, protocol_id)) = deps;
+                let proposal_length = *proposal_length;
+                let protocol_id = *protocol_id;
+                proposal_spi_size_byte()
+            }
+        }
+    }
+}
+pub struct ProposalCont1;
+type ProposalCont1Type<'a, 'b> = &'b (((u8, (u8, u16)), (u8, u8)), ProposalSpiSizeByte);
+type ProposalCont1SType<'a, 'x> = (((&'x u8, (&'x u8, &'x u16)), (&'x u8, &'x u8)), &'x ProposalSpiSizeByte);
+type ProposalCont1Input<'a, 'b, 'x> = POrSType<ProposalCont1Type<'a, 'b>, ProposalCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ProposalCont1Input<'a, 'b, 'x>> for ProposalCont1 {
+    type Output = Refined<U8, Predicate3651688686135228051>;
+
+    open spec fn requires(&self, deps: ProposalCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(Pair::spec_new((Refined { inner: U8, predicate: Predicate7277979220772363767 }, (Refined { inner: U8, predicate: TagPred(PROPOSALRESERVED_CONST) }, Refined { inner: U16Be, predicate: Predicate18193225726552524852 })), |deps| spec_proposal_cont3(deps)), |deps| spec_proposal_cont2(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: ProposalCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_proposal_cont1(deps@)
+    }
+
+    fn apply(&self, deps: ProposalCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (((_, (_, proposal_length)), (_, protocol_id)), spi_size) = deps;
+                let proposal_length = *proposal_length;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                Refined { inner: U8, predicate: Predicate3651688686135228051 }
+            }
+            POrSType::S(deps) => {
+                let (((_, (_, proposal_length)), (_, protocol_id)), spi_size) = deps;
+                let proposal_length = *proposal_length;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                Refined { inner: U8, predicate: Predicate3651688686135228051 }
+            }
+        }
+    }
+}
+pub struct ProposalCont0;
+type ProposalCont0Type<'a, 'b> = &'b ((((u8, (u8, u16)), (u8, u8)), ProposalSpiSizeByte), u8);
+type ProposalCont0SType<'a, 'x> = ((((&'x u8, (&'x u8, &'x u16)), (&'x u8, &'x u8)), &'x ProposalSpiSizeByte), &'x u8);
+type ProposalCont0Input<'a, 'b, 'x> = POrSType<ProposalCont0Type<'a, 'b>, ProposalCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ProposalCont0Input<'a, 'b, 'x>> for ProposalCont0 {
+    type Output = ProposalBodyCombinator;
+
+    open spec fn requires(&self, deps: ProposalCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(Pair::spec_new(Pair::spec_new((Refined { inner: U8, predicate: Predicate7277979220772363767 }, (Refined { inner: U8, predicate: TagPred(PROPOSALRESERVED_CONST) }, Refined { inner: U16Be, predicate: Predicate18193225726552524852 })), |deps| spec_proposal_cont3(deps)), |deps| spec_proposal_cont2(deps)), |deps| spec_proposal_cont1(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: ProposalCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_proposal_cont0(deps@)
+    }
+
+    fn apply(&self, deps: ProposalCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let ((((_, (_, proposal_length)), (_, protocol_id)), spi_size), num_transforms) = deps;
+                let proposal_length = *proposal_length;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                let num_transforms = *num_transforms;
+                proposal_body(num_transforms, proposal_length, spi_size)
+            }
+            POrSType::S(deps) => {
+                let ((((_, (_, proposal_length)), (_, protocol_id)), spi_size), num_transforms) = deps;
+                let proposal_length = *proposal_length;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                let num_transforms = *num_transforms;
+                proposal_body(num_transforms, proposal_length, spi_size)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecSaPayloadBody {
+    pub proposals: Seq<SpecProposal>,
+}
+
+pub type SpecSaPayloadBodyInner = Seq<SpecProposal>;
+
+
+impl SpecFrom<SpecSaPayloadBody> for SpecSaPayloadBodyInner {
+    open spec fn spec_from(m: SpecSaPayloadBody) -> SpecSaPayloadBodyInner {
+        m.proposals
+    }
+}
+
+impl SpecFrom<SpecSaPayloadBodyInner> for SpecSaPayloadBody {
+    open spec fn spec_from(m: SpecSaPayloadBodyInner) -> SpecSaPayloadBody {
+        let proposals = m;
+        SpecSaPayloadBody { proposals }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct SaPayloadBody<'a> {
+    pub proposals: RepeatResult<Proposal<'a>>,
+}
+
+impl View for SaPayloadBody<'_> {
+    type V = SpecSaPayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecSaPayloadBody {
+            proposals: self.proposals@,
+        }
+    }
+}
+pub type SaPayloadBodyInner<'a> = RepeatResult<Proposal<'a>>;
+
+pub type SaPayloadBodyInnerRef<'a> = &'a RepeatResult<Proposal<'a>>;
+impl<'a> From<&'a SaPayloadBody<'a>> for SaPayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a SaPayloadBody) -> SaPayloadBodyInnerRef<'a> {
+        &m.proposals
+    }
+}
+
+impl<'a> From<SaPayloadBodyInner<'a>> for SaPayloadBody<'a> {
+    fn ex_from(m: SaPayloadBodyInner) -> SaPayloadBody {
+        let proposals = m;
+        SaPayloadBody { proposals }
+    }
+}
+
+pub struct SaPayloadBodyMapper;
+impl View for SaPayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for SaPayloadBodyMapper {
+    type Src = SpecSaPayloadBodyInner;
+    type Dst = SpecSaPayloadBody;
+}
+impl SpecIsoProof for SaPayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for SaPayloadBodyMapper {
+    type Src = SaPayloadBodyInner<'a>;
+    type Dst = SaPayloadBody<'a>;
+    type RefSrc = SaPayloadBodyInnerRef<'a>;
+}
+
+pub struct SpecSaPayloadBodyCombinator(pub SpecSaPayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecSaPayloadBodyCombinator {
+    type Type = SpecSaPayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecSaPayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSaPayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecSaPayloadBodyCombinatorAlias = Mapped<AndThen<bytes::Variable, Repeat<SpecProposalCombinator>>, SaPayloadBodyMapper>;
+
+pub struct SaPayloadBodyCombinator(pub SaPayloadBodyCombinatorAlias);
+
+impl View for SaPayloadBodyCombinator {
+    type V = SpecSaPayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecSaPayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SaPayloadBodyCombinator {
+    type Type = SaPayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type SaPayloadBodyCombinatorAlias = Mapped<AndThen<bytes::Variable, Repeat<ProposalCombinator>>, SaPayloadBodyMapper>;
+
+
+pub open spec fn spec_sa_payload_body(payload_length: u16) -> SpecSaPayloadBodyCombinator {
+    SpecSaPayloadBodyCombinator(
+    Mapped {
+        inner: AndThen(bytes::Variable(((usize::spec_from(payload_length) - 4)) as usize), Repeat(spec_proposal())),
+        mapper: SaPayloadBodyMapper,
+    })
+}
+
+pub fn sa_payload_body<'a>(payload_length: u16) -> (o: SaPayloadBodyCombinator)
+    requires
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures o@ == spec_sa_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = SaPayloadBodyCombinator(
+    Mapped {
+        inner: AndThen(bytes::Variable(((usize::ex_from(payload_length) - 4)) as usize), Repeat::new(proposal())),
+        mapper: SaPayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_sa_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_sa_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<SaPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_sa_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_sa_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_sa_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_sa_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = sa_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_sa_payload_body<'a>(v: <SaPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_sa_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_sa_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_sa_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = sa_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecTsIpv6 {
+    pub ts_type: u8,
+    pub ip_protocol_id: u8,
+    pub selector_length: u16,
+    pub start_port: u16,
+    pub end_port: u16,
+    pub start_address: Seq<u8>,
+    pub end_address: Seq<u8>,
+}
+
+pub type SpecTsIpv6Inner = (u8, (u8, (u16, (u16, (u16, (Seq<u8>, Seq<u8>))))));
+
+
+impl SpecFrom<SpecTsIpv6> for SpecTsIpv6Inner {
+    open spec fn spec_from(m: SpecTsIpv6) -> SpecTsIpv6Inner {
+        (m.ts_type, (m.ip_protocol_id, (m.selector_length, (m.start_port, (m.end_port, (m.start_address, m.end_address))))))
+    }
+}
+
+impl SpecFrom<SpecTsIpv6Inner> for SpecTsIpv6 {
+    open spec fn spec_from(m: SpecTsIpv6Inner) -> SpecTsIpv6 {
+        let (ts_type, (ip_protocol_id, (selector_length, (start_port, (end_port, (start_address, end_address)))))) = m;
+        SpecTsIpv6 { ts_type, ip_protocol_id, selector_length, start_port, end_port, start_address, end_address }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct TsIpv6<'a> {
+    pub ts_type: u8,
+    pub ip_protocol_id: u8,
+    pub selector_length: u16,
+    pub start_port: u16,
+    pub end_port: u16,
+    pub start_address: &'a [u8],
+    pub end_address: &'a [u8],
+}
+
+impl View for TsIpv6<'_> {
+    type V = SpecTsIpv6;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTsIpv6 {
+            ts_type: self.ts_type@,
+            ip_protocol_id: self.ip_protocol_id@,
+            selector_length: self.selector_length@,
+            start_port: self.start_port@,
+            end_port: self.end_port@,
+            start_address: self.start_address@,
+            end_address: self.end_address@,
+        }
+    }
+}
+pub type TsIpv6Inner<'a> = (u8, (u8, (u16, (u16, (u16, (&'a [u8], &'a [u8]))))));
+
+pub type TsIpv6InnerRef<'a> = (&'a u8, (&'a u8, (&'a u16, (&'a u16, (&'a u16, (&'a &'a [u8], &'a &'a [u8]))))));
+impl<'a> From<&'a TsIpv6<'a>> for TsIpv6InnerRef<'a> {
+    fn ex_from(m: &'a TsIpv6) -> TsIpv6InnerRef<'a> {
+        (&m.ts_type, (&m.ip_protocol_id, (&m.selector_length, (&m.start_port, (&m.end_port, (&m.start_address, &m.end_address))))))
+    }
+}
+
+impl<'a> From<TsIpv6Inner<'a>> for TsIpv6<'a> {
+    fn ex_from(m: TsIpv6Inner) -> TsIpv6 {
+        let (ts_type, (ip_protocol_id, (selector_length, (start_port, (end_port, (start_address, end_address)))))) = m;
+        TsIpv6 { ts_type, ip_protocol_id, selector_length, start_port, end_port, start_address, end_address }
+    }
+}
+
+pub struct TsIpv6Mapper;
+impl View for TsIpv6Mapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TsIpv6Mapper {
+    type Src = SpecTsIpv6Inner;
+    type Dst = SpecTsIpv6;
+}
+impl SpecIsoProof for TsIpv6Mapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TsIpv6Mapper {
+    type Src = TsIpv6Inner<'a>;
+    type Dst = TsIpv6<'a>;
+    type RefSrc = TsIpv6InnerRef<'a>;
+}
+pub const TSIPV6TS_TYPE_CONST: u8 = 8;
+pub const TSIPV6SELECTOR_LENGTH_CONST: u16 = 40;
+type SpecTsIpv6CombinatorAlias1 = (bytes::Fixed<16>, bytes::Fixed<16>);
+type SpecTsIpv6CombinatorAlias2 = (U16Be, SpecTsIpv6CombinatorAlias1);
+type SpecTsIpv6CombinatorAlias3 = (U16Be, SpecTsIpv6CombinatorAlias2);
+type SpecTsIpv6CombinatorAlias4 = (Refined<U16Be, TagPred<u16>>, SpecTsIpv6CombinatorAlias3);
+type SpecTsIpv6CombinatorAlias5 = (U8, SpecTsIpv6CombinatorAlias4);
+type SpecTsIpv6CombinatorAlias6 = (Refined<U8, TagPred<u8>>, SpecTsIpv6CombinatorAlias5);
+pub struct SpecTsIpv6Combinator(pub SpecTsIpv6CombinatorAlias);
+
+impl SpecCombinator for SpecTsIpv6Combinator {
+    type Type = SpecTsIpv6;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTsIpv6Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTsIpv6CombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTsIpv6CombinatorAlias = Mapped<SpecTsIpv6CombinatorAlias6, TsIpv6Mapper>;
+type TsIpv6CombinatorAlias1 = (bytes::Fixed<16>, bytes::Fixed<16>);
+type TsIpv6CombinatorAlias2 = (U16Be, TsIpv6Combinator1);
+type TsIpv6CombinatorAlias3 = (U16Be, TsIpv6Combinator2);
+type TsIpv6CombinatorAlias4 = (Refined<U16Be, TagPred<u16>>, TsIpv6Combinator3);
+type TsIpv6CombinatorAlias5 = (U8, TsIpv6Combinator4);
+type TsIpv6CombinatorAlias6 = (Refined<U8, TagPred<u8>>, TsIpv6Combinator5);
+pub struct TsIpv6Combinator1(pub TsIpv6CombinatorAlias1);
+impl View for TsIpv6Combinator1 {
+    type V = SpecTsIpv6CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv6Combinator1, TsIpv6CombinatorAlias1);
+
+pub struct TsIpv6Combinator2(pub TsIpv6CombinatorAlias2);
+impl View for TsIpv6Combinator2 {
+    type V = SpecTsIpv6CombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv6Combinator2, TsIpv6CombinatorAlias2);
+
+pub struct TsIpv6Combinator3(pub TsIpv6CombinatorAlias3);
+impl View for TsIpv6Combinator3 {
+    type V = SpecTsIpv6CombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv6Combinator3, TsIpv6CombinatorAlias3);
+
+pub struct TsIpv6Combinator4(pub TsIpv6CombinatorAlias4);
+impl View for TsIpv6Combinator4 {
+    type V = SpecTsIpv6CombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv6Combinator4, TsIpv6CombinatorAlias4);
+
+pub struct TsIpv6Combinator5(pub TsIpv6CombinatorAlias5);
+impl View for TsIpv6Combinator5 {
+    type V = SpecTsIpv6CombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv6Combinator5, TsIpv6CombinatorAlias5);
+
+pub struct TsIpv6Combinator6(pub TsIpv6CombinatorAlias6);
+impl View for TsIpv6Combinator6 {
+    type V = SpecTsIpv6CombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv6Combinator6, TsIpv6CombinatorAlias6);
+
+pub struct TsIpv6Combinator(pub TsIpv6CombinatorAlias);
+
+impl View for TsIpv6Combinator {
+    type V = SpecTsIpv6Combinator;
+    open spec fn view(&self) -> Self::V { SpecTsIpv6Combinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv6Combinator {
+    type Type = TsIpv6<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TsIpv6CombinatorAlias = Mapped<TsIpv6Combinator6, TsIpv6Mapper>;
+
+
+pub open spec fn spec_ts_ipv6() -> SpecTsIpv6Combinator {
+    SpecTsIpv6Combinator(
+    Mapped {
+        inner: (Refined { inner: U8, predicate: TagPred(TSIPV6TS_TYPE_CONST) }, (U8, (Refined { inner: U16Be, predicate: TagPred(TSIPV6SELECTOR_LENGTH_CONST) }, (U16Be, (U16Be, (bytes::Fixed::<16>, bytes::Fixed::<16>)))))),
+        mapper: TsIpv6Mapper,
+    })
+}
+
+                
+pub fn ts_ipv6<'a>() -> (o: TsIpv6Combinator)
+    ensures o@ == spec_ts_ipv6(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TsIpv6Combinator(
+    Mapped {
+        inner: TsIpv6Combinator6((Refined { inner: U8, predicate: TagPred(TSIPV6TS_TYPE_CONST) }, TsIpv6Combinator5((U8, TsIpv6Combinator4((Refined { inner: U16Be, predicate: TagPred(TSIPV6SELECTOR_LENGTH_CONST) }, TsIpv6Combinator3((U16Be, TsIpv6Combinator2((U16Be, TsIpv6Combinator1((bytes::Fixed::<16>, bytes::Fixed::<16>)))))))))))),
+        mapper: TsIpv6Mapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ts_ipv6()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ts_ipv6<'a>(input: &'a [u8]) -> (res: PResult<<TsIpv6Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ts_ipv6().spec_parse(input@) == Some((n as int, v@)),
+        spec_ts_ipv6().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ts_ipv6().spec_parse(input@) is None,
+        spec_ts_ipv6().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ts_ipv6();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ts_ipv6<'a>(v: <TsIpv6Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_ipv6().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ts_ipv6().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ts_ipv6().spec_serialize(v@).len(),
+{
+    let combinator = ts_ipv6();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecIkev2SaPayloadInner {
+    pub proposals: Seq<SpecProposal>,
+}
+
+pub type SpecIkev2SaPayloadInnerInner = Seq<SpecProposal>;
+
+
+impl SpecFrom<SpecIkev2SaPayloadInner> for SpecIkev2SaPayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2SaPayloadInner) -> SpecIkev2SaPayloadInnerInner {
+        m.proposals
+    }
+}
+
+impl SpecFrom<SpecIkev2SaPayloadInnerInner> for SpecIkev2SaPayloadInner {
+    open spec fn spec_from(m: SpecIkev2SaPayloadInnerInner) -> SpecIkev2SaPayloadInner {
+        let proposals = m;
+        SpecIkev2SaPayloadInner { proposals }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2SaPayloadInner<'a> {
+    pub proposals: RepeatResult<Proposal<'a>>,
+}
+
+impl View for Ikev2SaPayloadInner<'_> {
+    type V = SpecIkev2SaPayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2SaPayloadInner {
+            proposals: self.proposals@,
+        }
+    }
+}
+pub type Ikev2SaPayloadInnerInner<'a> = RepeatResult<Proposal<'a>>;
+
+pub type Ikev2SaPayloadInnerInnerRef<'a> = &'a RepeatResult<Proposal<'a>>;
+impl<'a> From<&'a Ikev2SaPayloadInner<'a>> for Ikev2SaPayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2SaPayloadInner) -> Ikev2SaPayloadInnerInnerRef<'a> {
+        &m.proposals
+    }
+}
+
+impl<'a> From<Ikev2SaPayloadInnerInner<'a>> for Ikev2SaPayloadInner<'a> {
+    fn ex_from(m: Ikev2SaPayloadInnerInner) -> Ikev2SaPayloadInner {
+        let proposals = m;
+        Ikev2SaPayloadInner { proposals }
+    }
+}
+
+pub struct Ikev2SaPayloadInnerMapper;
+impl View for Ikev2SaPayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2SaPayloadInnerMapper {
+    type Src = SpecIkev2SaPayloadInnerInner;
+    type Dst = SpecIkev2SaPayloadInner;
+}
+impl SpecIsoProof for Ikev2SaPayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2SaPayloadInnerMapper {
+    type Src = Ikev2SaPayloadInnerInner<'a>;
+    type Dst = Ikev2SaPayloadInner<'a>;
+    type RefSrc = Ikev2SaPayloadInnerInnerRef<'a>;
+}
+
+pub struct SpecIkev2SaPayloadInnerCombinator(pub SpecIkev2SaPayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2SaPayloadInnerCombinator {
+    type Type = SpecIkev2SaPayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2SaPayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2SaPayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2SaPayloadInnerCombinatorAlias = Mapped<AndThen<bytes::Tail, Repeat<SpecProposalCombinator>>, Ikev2SaPayloadInnerMapper>;
+
+pub struct Ikev2SaPayloadInnerCombinator(pub Ikev2SaPayloadInnerCombinatorAlias);
+
+impl View for Ikev2SaPayloadInnerCombinator {
+    type V = SpecIkev2SaPayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2SaPayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2SaPayloadInnerCombinator {
+    type Type = Ikev2SaPayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2SaPayloadInnerCombinatorAlias = Mapped<AndThen<bytes::Tail, Repeat<ProposalCombinator>>, Ikev2SaPayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_sa_payload_inner() -> SpecIkev2SaPayloadInnerCombinator {
+    SpecIkev2SaPayloadInnerCombinator(
+    Mapped {
+        inner: AndThen(bytes::Tail, Repeat(spec_proposal())),
+        mapper: Ikev2SaPayloadInnerMapper,
+    })
+}
+
+                
+pub fn ikev2_sa_payload_inner<'a>() -> (o: Ikev2SaPayloadInnerCombinator)
+    ensures o@ == spec_ikev2_sa_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2SaPayloadInnerCombinator(
+    Mapped {
+        inner: AndThen(bytes::Tail, Repeat::new(proposal())),
+        mapper: Ikev2SaPayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_sa_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_sa_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2SaPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_sa_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_sa_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_sa_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_sa_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_sa_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_sa_payload_inner<'a>(v: <Ikev2SaPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_sa_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_sa_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_sa_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_sa_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecNoncePayloadBody {
+    pub nonce_data: Seq<u8>,
+}
+
+pub type SpecNoncePayloadBodyInner = Seq<u8>;
+
+
+impl SpecFrom<SpecNoncePayloadBody> for SpecNoncePayloadBodyInner {
+    open spec fn spec_from(m: SpecNoncePayloadBody) -> SpecNoncePayloadBodyInner {
+        m.nonce_data
+    }
+}
+
+impl SpecFrom<SpecNoncePayloadBodyInner> for SpecNoncePayloadBody {
+    open spec fn spec_from(m: SpecNoncePayloadBodyInner) -> SpecNoncePayloadBody {
+        let nonce_data = m;
+        SpecNoncePayloadBody { nonce_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct NoncePayloadBody<'a> {
+    pub nonce_data: &'a [u8],
+}
+
+impl View for NoncePayloadBody<'_> {
+    type V = SpecNoncePayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecNoncePayloadBody {
+            nonce_data: self.nonce_data@,
+        }
+    }
+}
+pub type NoncePayloadBodyInner<'a> = &'a [u8];
+
+pub type NoncePayloadBodyInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a NoncePayloadBody<'a>> for NoncePayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a NoncePayloadBody) -> NoncePayloadBodyInnerRef<'a> {
+        &m.nonce_data
+    }
+}
+
+impl<'a> From<NoncePayloadBodyInner<'a>> for NoncePayloadBody<'a> {
+    fn ex_from(m: NoncePayloadBodyInner) -> NoncePayloadBody {
+        let nonce_data = m;
+        NoncePayloadBody { nonce_data }
+    }
+}
+
+pub struct NoncePayloadBodyMapper;
+impl View for NoncePayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for NoncePayloadBodyMapper {
+    type Src = SpecNoncePayloadBodyInner;
+    type Dst = SpecNoncePayloadBody;
+}
+impl SpecIsoProof for NoncePayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for NoncePayloadBodyMapper {
+    type Src = NoncePayloadBodyInner<'a>;
+    type Dst = NoncePayloadBody<'a>;
+    type RefSrc = NoncePayloadBodyInnerRef<'a>;
+}
+
+pub struct SpecNoncePayloadBodyCombinator(pub SpecNoncePayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecNoncePayloadBodyCombinator {
+    type Type = SpecNoncePayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNoncePayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNoncePayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNoncePayloadBodyCombinatorAlias = Mapped<bytes::Variable, NoncePayloadBodyMapper>;
+
+pub struct NoncePayloadBodyCombinator(pub NoncePayloadBodyCombinatorAlias);
+
+impl View for NoncePayloadBodyCombinator {
+    type V = SpecNoncePayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecNoncePayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NoncePayloadBodyCombinator {
+    type Type = NoncePayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NoncePayloadBodyCombinatorAlias = Mapped<bytes::Variable, NoncePayloadBodyMapper>;
+
+
+pub open spec fn spec_nonce_payload_body(payload_length: u16) -> SpecNoncePayloadBodyCombinator {
+    SpecNoncePayloadBodyCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::spec_from(payload_length) - 4)) as usize),
+        mapper: NoncePayloadBodyMapper,
+    })
+}
+
+pub fn nonce_payload_body<'a>(payload_length: u16) -> (o: NoncePayloadBodyCombinator)
+    requires
+        ((payload_length) >= 20 && (payload_length) <= 260),
+
+    ensures o@ == spec_nonce_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NoncePayloadBodyCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::ex_from(payload_length) - 4)) as usize),
+        mapper: NoncePayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_nonce_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_nonce_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<NoncePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 20 && (payload_length) <= 260),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_nonce_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_nonce_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_nonce_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_nonce_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = nonce_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_nonce_payload_body<'a>(v: <NoncePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_nonce_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 20 && (payload_length) <= 260),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_nonce_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 20 && (payload_length) <= 260),
+
+    ensures
+        serialize_len == spec_nonce_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = nonce_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub mod IdType {
+    use super::*;
+    pub spec const SPEC_ID_IPV4_ADDR: u8 = 1;
+    pub spec const SPEC_ID_FQDN: u8 = 2;
+    pub spec const SPEC_ID_RFC822_ADDR: u8 = 3;
+    pub spec const SPEC_ID_IPV6_ADDR: u8 = 5;
+    pub spec const SPEC_ID_DER_ASN1_DN: u8 = 9;
+    pub spec const SPEC_ID_DER_ASN1_GN: u8 = 10;
+    pub spec const SPEC_ID_KEY_ID: u8 = 11;
+    pub exec const ID_IPV4_ADDR: u8 ensures ID_IPV4_ADDR == SPEC_ID_IPV4_ADDR { 1 }
+    pub exec const ID_FQDN: u8 ensures ID_FQDN == SPEC_ID_FQDN { 2 }
+    pub exec const ID_RFC822_ADDR: u8 ensures ID_RFC822_ADDR == SPEC_ID_RFC822_ADDR { 3 }
+    pub exec const ID_IPV6_ADDR: u8 ensures ID_IPV6_ADDR == SPEC_ID_IPV6_ADDR { 5 }
+    pub exec const ID_DER_ASN1_DN: u8 ensures ID_DER_ASN1_DN == SPEC_ID_DER_ASN1_DN { 9 }
+    pub exec const ID_DER_ASN1_GN: u8 ensures ID_DER_ASN1_GN == SPEC_ID_DER_ASN1_GN { 10 }
+    pub exec const ID_KEY_ID: u8 ensures ID_KEY_ID == SPEC_ID_KEY_ID { 11 }
+}
+
+
+pub struct SpecIdTypeCombinator(pub SpecIdTypeCombinatorAlias);
+
+impl SpecCombinator for SpecIdTypeCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIdTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIdTypeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIdTypeCombinatorAlias = U8;
+
+pub struct IdTypeCombinator(pub IdTypeCombinatorAlias);
+
+impl View for IdTypeCombinator {
+    type V = SpecIdTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecIdTypeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IdTypeCombinator {
+    type Type = u8;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type IdTypeCombinatorAlias = U8;
+
+
+pub open spec fn spec_id_type() -> SpecIdTypeCombinator {
+    SpecIdTypeCombinator(U8)
+}
+
+                
+pub fn id_type<'a>() -> (o: IdTypeCombinator)
+    ensures o@ == spec_id_type(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = IdTypeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_id_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_id_type<'a>(input: &'a [u8]) -> (res: PResult<<IdTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_id_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_id_type().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_id_type().spec_parse(input@) is None,
+        spec_id_type().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = id_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_id_type<'a>(v: <IdTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_id_type().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_id_type().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_id_type().spec_serialize(v@).len(),
+{
+    let combinator = id_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecIkev2IdPayloadInner {
+    pub id_type: u8,
+    pub reserved: Seq<u8>,
+    pub id_data: Seq<u8>,
+}
+
+pub type SpecIkev2IdPayloadInnerInner = (u8, (Seq<u8>, Seq<u8>));
+
+
+impl SpecFrom<SpecIkev2IdPayloadInner> for SpecIkev2IdPayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2IdPayloadInner) -> SpecIkev2IdPayloadInnerInner {
+        (m.id_type, (m.reserved, m.id_data))
+    }
+}
+
+impl SpecFrom<SpecIkev2IdPayloadInnerInner> for SpecIkev2IdPayloadInner {
+    open spec fn spec_from(m: SpecIkev2IdPayloadInnerInner) -> SpecIkev2IdPayloadInner {
+        let (id_type, (reserved, id_data)) = m;
+        SpecIkev2IdPayloadInner { id_type, reserved, id_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2IdPayloadInner<'a> {
+    pub id_type: u8,
+    pub reserved: &'a [u8],
+    pub id_data: &'a [u8],
+}
+
+impl View for Ikev2IdPayloadInner<'_> {
+    type V = SpecIkev2IdPayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2IdPayloadInner {
+            id_type: self.id_type@,
+            reserved: self.reserved@,
+            id_data: self.id_data@,
+        }
+    }
+}
+pub type Ikev2IdPayloadInnerInner<'a> = (u8, (&'a [u8], &'a [u8]));
+
+pub type Ikev2IdPayloadInnerInnerRef<'a> = (&'a u8, (&'a &'a [u8], &'a &'a [u8]));
+impl<'a> From<&'a Ikev2IdPayloadInner<'a>> for Ikev2IdPayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2IdPayloadInner) -> Ikev2IdPayloadInnerInnerRef<'a> {
+        (&m.id_type, (&m.reserved, &m.id_data))
+    }
+}
+
+impl<'a> From<Ikev2IdPayloadInnerInner<'a>> for Ikev2IdPayloadInner<'a> {
+    fn ex_from(m: Ikev2IdPayloadInnerInner) -> Ikev2IdPayloadInner {
+        let (id_type, (reserved, id_data)) = m;
+        Ikev2IdPayloadInner { id_type, reserved, id_data }
+    }
+}
+
+pub struct Ikev2IdPayloadInnerMapper;
+impl View for Ikev2IdPayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2IdPayloadInnerMapper {
+    type Src = SpecIkev2IdPayloadInnerInner;
+    type Dst = SpecIkev2IdPayloadInner;
+}
+impl SpecIsoProof for Ikev2IdPayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2IdPayloadInnerMapper {
+    type Src = Ikev2IdPayloadInnerInner<'a>;
+    type Dst = Ikev2IdPayloadInner<'a>;
+    type RefSrc = Ikev2IdPayloadInnerInnerRef<'a>;
+}
+pub spec const SPEC_IKEV2IDPAYLOADINNERRESERVED_CONST: Seq<u8> = seq![0; 3];type SpecIkev2IdPayloadInnerCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, bytes::Tail);
+type SpecIkev2IdPayloadInnerCombinatorAlias2 = (SpecIdTypeCombinator, SpecIkev2IdPayloadInnerCombinatorAlias1);
+pub struct SpecIkev2IdPayloadInnerCombinator(pub SpecIkev2IdPayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2IdPayloadInnerCombinator {
+    type Type = SpecIkev2IdPayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2IdPayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2IdPayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2IdPayloadInnerCombinatorAlias = Mapped<SpecIkev2IdPayloadInnerCombinatorAlias2, Ikev2IdPayloadInnerMapper>;
+pub exec static IKEV2IDPAYLOADINNERRESERVED_CONST: [u8; 3]
+    ensures IKEV2IDPAYLOADINNERRESERVED_CONST@ == SPEC_IKEV2IDPAYLOADINNERRESERVED_CONST,
+{
+    let arr: [u8; 3] = [0; 3];
+    assert(arr@ == SPEC_IKEV2IDPAYLOADINNERRESERVED_CONST);
+    arr
+}
+type Ikev2IdPayloadInnerCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, bytes::Tail);
+type Ikev2IdPayloadInnerCombinatorAlias2 = (IdTypeCombinator, Ikev2IdPayloadInnerCombinator1);
+pub struct Ikev2IdPayloadInnerCombinator1(pub Ikev2IdPayloadInnerCombinatorAlias1);
+impl View for Ikev2IdPayloadInnerCombinator1 {
+    type V = SpecIkev2IdPayloadInnerCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2IdPayloadInnerCombinator1, Ikev2IdPayloadInnerCombinatorAlias1);
+
+pub struct Ikev2IdPayloadInnerCombinator2(pub Ikev2IdPayloadInnerCombinatorAlias2);
+impl View for Ikev2IdPayloadInnerCombinator2 {
+    type V = SpecIkev2IdPayloadInnerCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2IdPayloadInnerCombinator2, Ikev2IdPayloadInnerCombinatorAlias2);
+
+pub struct Ikev2IdPayloadInnerCombinator(pub Ikev2IdPayloadInnerCombinatorAlias);
+
+impl View for Ikev2IdPayloadInnerCombinator {
+    type V = SpecIkev2IdPayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2IdPayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2IdPayloadInnerCombinator {
+    type Type = Ikev2IdPayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2IdPayloadInnerCombinatorAlias = Mapped<Ikev2IdPayloadInnerCombinator2, Ikev2IdPayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_id_payload_inner() -> SpecIkev2IdPayloadInnerCombinator {
+    SpecIkev2IdPayloadInnerCombinator(
+    Mapped {
+        inner: (spec_id_type(), (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(SPEC_IKEV2IDPAYLOADINNERRESERVED_CONST) }, bytes::Tail)),
+        mapper: Ikev2IdPayloadInnerMapper,
+    })
+}
+
+                
+pub fn ikev2_id_payload_inner<'a>() -> (o: Ikev2IdPayloadInnerCombinator)
+    ensures o@ == spec_ikev2_id_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2IdPayloadInnerCombinator(
+    Mapped {
+        inner: Ikev2IdPayloadInnerCombinator2((id_type(), Ikev2IdPayloadInnerCombinator1((Refined { inner: bytes::Fixed::<3>, predicate: TagPred(IKEV2IDPAYLOADINNERRESERVED_CONST) }, bytes::Tail)))),
+        mapper: Ikev2IdPayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_id_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_id_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2IdPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_id_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_id_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_id_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_id_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_id_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_id_payload_inner<'a>(v: <Ikev2IdPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_id_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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>>>::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)
+    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)
+}
+
+                
+
+pub struct SpecNotifyPayloadBodySpi0 {
+    pub spi: Seq<u8>,
+    pub notification_data: Seq<u8>,
+}
+
+pub type SpecNotifyPayloadBodySpi0Inner = (Seq<u8>, Seq<u8>);
+
+
+impl SpecFrom<SpecNotifyPayloadBodySpi0> for SpecNotifyPayloadBodySpi0Inner {
+    open spec fn spec_from(m: SpecNotifyPayloadBodySpi0) -> SpecNotifyPayloadBodySpi0Inner {
+        (m.spi, m.notification_data)
+    }
+}
+
+impl SpecFrom<SpecNotifyPayloadBodySpi0Inner> for SpecNotifyPayloadBodySpi0 {
+    open spec fn spec_from(m: SpecNotifyPayloadBodySpi0Inner) -> SpecNotifyPayloadBodySpi0 {
+        let (spi, notification_data) = m;
+        SpecNotifyPayloadBodySpi0 { spi, notification_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct NotifyPayloadBodySpi0<'a> {
+    pub spi: &'a [u8],
+    pub notification_data: &'a [u8],
+}
+
+impl View for NotifyPayloadBodySpi0<'_> {
+    type V = SpecNotifyPayloadBodySpi0;
+
+    open spec fn view(&self) -> Self::V {
+        SpecNotifyPayloadBodySpi0 {
+            spi: self.spi@,
+            notification_data: self.notification_data@,
+        }
+    }
+}
+pub type NotifyPayloadBodySpi0Inner<'a> = (&'a [u8], &'a [u8]);
+
+pub type NotifyPayloadBodySpi0InnerRef<'a> = (&'a &'a [u8], &'a &'a [u8]);
+impl<'a> From<&'a NotifyPayloadBodySpi0<'a>> for NotifyPayloadBodySpi0InnerRef<'a> {
+    fn ex_from(m: &'a NotifyPayloadBodySpi0) -> NotifyPayloadBodySpi0InnerRef<'a> {
+        (&m.spi, &m.notification_data)
+    }
+}
+
+impl<'a> From<NotifyPayloadBodySpi0Inner<'a>> for NotifyPayloadBodySpi0<'a> {
+    fn ex_from(m: NotifyPayloadBodySpi0Inner) -> NotifyPayloadBodySpi0 {
+        let (spi, notification_data) = m;
+        NotifyPayloadBodySpi0 { spi, notification_data }
+    }
+}
+
+pub struct NotifyPayloadBodySpi0Mapper;
+impl View for NotifyPayloadBodySpi0Mapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for NotifyPayloadBodySpi0Mapper {
+    type Src = SpecNotifyPayloadBodySpi0Inner;
+    type Dst = SpecNotifyPayloadBodySpi0;
+}
+impl SpecIsoProof for NotifyPayloadBodySpi0Mapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for NotifyPayloadBodySpi0Mapper {
+    type Src = NotifyPayloadBodySpi0Inner<'a>;
+    type Dst = NotifyPayloadBodySpi0<'a>;
+    type RefSrc = NotifyPayloadBodySpi0InnerRef<'a>;
+}
+type SpecNotifyPayloadBodySpi0CombinatorAlias1 = (bytes::Fixed<0>, bytes::Tail);
+pub struct SpecNotifyPayloadBodySpi0Combinator(pub SpecNotifyPayloadBodySpi0CombinatorAlias);
+
+impl SpecCombinator for SpecNotifyPayloadBodySpi0Combinator {
+    type Type = SpecNotifyPayloadBodySpi0;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNotifyPayloadBodySpi0Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNotifyPayloadBodySpi0CombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNotifyPayloadBodySpi0CombinatorAlias = Mapped<SpecNotifyPayloadBodySpi0CombinatorAlias1, NotifyPayloadBodySpi0Mapper>;
+type NotifyPayloadBodySpi0CombinatorAlias1 = (bytes::Fixed<0>, bytes::Tail);
+pub struct NotifyPayloadBodySpi0Combinator1(pub NotifyPayloadBodySpi0CombinatorAlias1);
+impl View for NotifyPayloadBodySpi0Combinator1 {
+    type V = SpecNotifyPayloadBodySpi0CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(NotifyPayloadBodySpi0Combinator1, NotifyPayloadBodySpi0CombinatorAlias1);
+
+pub struct NotifyPayloadBodySpi0Combinator(pub NotifyPayloadBodySpi0CombinatorAlias);
+
+impl View for NotifyPayloadBodySpi0Combinator {
+    type V = SpecNotifyPayloadBodySpi0Combinator;
+    open spec fn view(&self) -> Self::V { SpecNotifyPayloadBodySpi0Combinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodySpi0Combinator {
+    type Type = NotifyPayloadBodySpi0<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NotifyPayloadBodySpi0CombinatorAlias = Mapped<NotifyPayloadBodySpi0Combinator1, NotifyPayloadBodySpi0Mapper>;
+
+
+pub open spec fn spec_notify_payload_body_spi0() -> SpecNotifyPayloadBodySpi0Combinator {
+    SpecNotifyPayloadBodySpi0Combinator(
+    Mapped {
+        inner: (bytes::Fixed::<0>, bytes::Tail),
+        mapper: NotifyPayloadBodySpi0Mapper,
+    })
+}
+
+                
+pub fn notify_payload_body_spi0<'a>() -> (o: NotifyPayloadBodySpi0Combinator)
+    ensures o@ == spec_notify_payload_body_spi0(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NotifyPayloadBodySpi0Combinator(
+    Mapped {
+        inner: NotifyPayloadBodySpi0Combinator1((bytes::Fixed::<0>, bytes::Tail)),
+        mapper: NotifyPayloadBodySpi0Mapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_notify_payload_body_spi0()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_notify_payload_body_spi0<'a>(input: &'a [u8]) -> (res: PResult<<NotifyPayloadBodySpi0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_notify_payload_body_spi0().spec_parse(input@) == Some((n as int, v@)),
+        spec_notify_payload_body_spi0().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_notify_payload_body_spi0().spec_parse(input@) is None,
+        spec_notify_payload_body_spi0().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = notify_payload_body_spi0();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_notify_payload_body_spi0<'a>(v: <NotifyPayloadBodySpi0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_notify_payload_body_spi0().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_notify_payload_body_spi0().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_notify_payload_body_spi0().spec_serialize(v@).len(),
+{
+    let combinator = notify_payload_body_spi0();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub type SpecCfgAttrTypeWord = u16;
+pub type CfgAttrTypeWord = u16;
+pub type CfgAttrTypeWordRef<'a> = &'a u16;
+
+
+pub struct SpecCfgAttrTypeWordCombinator(pub SpecCfgAttrTypeWordCombinatorAlias);
+
+impl SpecCombinator for SpecCfgAttrTypeWordCombinator {
+    type Type = SpecCfgAttrTypeWord;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCfgAttrTypeWordCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCfgAttrTypeWordCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCfgAttrTypeWordCombinatorAlias = Refined<U16Be, Predicate5630542192344936318>;
+
+pub struct CfgAttrTypeWordCombinator(pub CfgAttrTypeWordCombinatorAlias);
+
+impl View for CfgAttrTypeWordCombinator {
+    type V = SpecCfgAttrTypeWordCombinator;
+    open spec fn view(&self) -> Self::V { SpecCfgAttrTypeWordCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CfgAttrTypeWordCombinator {
+    type Type = CfgAttrTypeWord;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CfgAttrTypeWordCombinatorAlias = Refined<U16Be, Predicate5630542192344936318>;
+
+
+pub open spec fn spec_cfg_attr_type_word() -> SpecCfgAttrTypeWordCombinator {
+    SpecCfgAttrTypeWordCombinator(Refined { inner: U16Be, predicate: Predicate5630542192344936318 })
+}
+
+                
+pub fn cfg_attr_type_word<'a>() -> (o: CfgAttrTypeWordCombinator)
+    ensures o@ == spec_cfg_attr_type_word(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CfgAttrTypeWordCombinator(Refined { inner: U16Be, predicate: Predicate5630542192344936318 });
+    // assert({
+    //     &&& combinator@ == spec_cfg_attr_type_word()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_cfg_attr_type_word<'a>(input: &'a [u8]) -> (res: PResult<<CfgAttrTypeWordCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_cfg_attr_type_word().spec_parse(input@) == Some((n as int, v@)),
+        spec_cfg_attr_type_word().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_cfg_attr_type_word().spec_parse(input@) is None,
+        spec_cfg_attr_type_word().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = cfg_attr_type_word();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_cfg_attr_type_word<'a>(v: <CfgAttrTypeWordCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cfg_attr_type_word().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_cfg_attr_type_word().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_cfg_attr_type_word().spec_serialize(v@).len(),
+{
+    let combinator = cfg_attr_type_word();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecCfgAttribute {
+    pub r_and_attr_type: SpecCfgAttrTypeWord,
+    pub length: u16,
+    pub value: Seq<u8>,
+}
+
+pub type SpecCfgAttributeInner = ((SpecCfgAttrTypeWord, u16), Seq<u8>);
+
+
+impl SpecFrom<SpecCfgAttribute> for SpecCfgAttributeInner {
+    open spec fn spec_from(m: SpecCfgAttribute) -> SpecCfgAttributeInner {
+        ((m.r_and_attr_type, m.length), m.value)
+    }
+}
+
+impl SpecFrom<SpecCfgAttributeInner> for SpecCfgAttribute {
+    open spec fn spec_from(m: SpecCfgAttributeInner) -> SpecCfgAttribute {
+        let ((r_and_attr_type, length), value) = m;
+        SpecCfgAttribute { r_and_attr_type, length, value }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CfgAttribute<'a> {
+    pub r_and_attr_type: CfgAttrTypeWord,
+    pub length: u16,
+    pub value: &'a [u8],
+}
+
+impl View for CfgAttribute<'_> {
+    type V = SpecCfgAttribute;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCfgAttribute {
+            r_and_attr_type: self.r_and_attr_type@,
+            length: self.length@,
+            value: self.value@,
+        }
+    }
+}
+pub type CfgAttributeInner<'a> = ((CfgAttrTypeWord, u16), &'a [u8]);
+
+pub type CfgAttributeInnerRef<'a> = ((&'a CfgAttrTypeWord, &'a u16), &'a &'a [u8]);
+impl<'a> From<&'a CfgAttribute<'a>> for CfgAttributeInnerRef<'a> {
+    fn ex_from(m: &'a CfgAttribute) -> CfgAttributeInnerRef<'a> {
+        ((&m.r_and_attr_type, &m.length), &m.value)
+    }
+}
+
+impl<'a> From<CfgAttributeInner<'a>> for CfgAttribute<'a> {
+    fn ex_from(m: CfgAttributeInner) -> CfgAttribute {
+        let ((r_and_attr_type, length), value) = m;
+        CfgAttribute { r_and_attr_type, length, value }
+    }
+}
+
+pub struct CfgAttributeMapper;
+impl View for CfgAttributeMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CfgAttributeMapper {
+    type Src = SpecCfgAttributeInner;
+    type Dst = SpecCfgAttribute;
+}
+impl SpecIsoProof for CfgAttributeMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CfgAttributeMapper {
+    type Src = CfgAttributeInner<'a>;
+    type Dst = CfgAttribute<'a>;
+    type RefSrc = CfgAttributeInnerRef<'a>;
+}
+
+pub struct SpecCfgAttributeCombinator(pub SpecCfgAttributeCombinatorAlias);
+
+impl SpecCombinator for SpecCfgAttributeCombinator {
+    type Type = SpecCfgAttribute;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCfgAttributeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCfgAttributeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCfgAttributeCombinatorAlias = Mapped<SpecPair<SpecPair<SpecCfgAttrTypeWordCombinator, U16Be>, bytes::Variable>, CfgAttributeMapper>;
+
+pub struct CfgAttributeCombinator(pub CfgAttributeCombinatorAlias);
+
+impl View for CfgAttributeCombinator {
+    type V = SpecCfgAttributeCombinator;
+    open spec fn view(&self) -> Self::V { SpecCfgAttributeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CfgAttributeCombinator {
+    type Type = CfgAttribute<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CfgAttributeCombinatorAlias = Mapped<Pair<Pair<CfgAttrTypeWordCombinator, U16Be, CfgAttributeCont1>, bytes::Variable, CfgAttributeCont0>, CfgAttributeMapper>;
+
+
+pub open spec fn spec_cfg_attribute() -> SpecCfgAttributeCombinator {
+    SpecCfgAttributeCombinator(
+    Mapped {
+        inner: Pair::spec_new(Pair::spec_new(spec_cfg_attr_type_word(), |deps| spec_cfg_attribute_cont1(deps)), |deps| spec_cfg_attribute_cont0(deps)),
+        mapper: CfgAttributeMapper,
+    })
+}
+
+pub open spec fn spec_cfg_attribute_cont1(deps: SpecCfgAttrTypeWord) -> U16Be {
+    let r_and_attr_type = deps;
+    U16Be
+}
+
+impl View for CfgAttributeCont1 {
+    type V = spec_fn(SpecCfgAttrTypeWord) -> U16Be;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: SpecCfgAttrTypeWord| {
+            spec_cfg_attribute_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_cfg_attribute_cont0(deps: (SpecCfgAttrTypeWord, u16)) -> bytes::Variable {
+    let (r_and_attr_type, length) = deps;
+    bytes::Variable((usize::spec_from(length)) as usize)
+}
+
+impl View for CfgAttributeCont0 {
+    type V = spec_fn((SpecCfgAttrTypeWord, u16)) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (SpecCfgAttrTypeWord, u16)| {
+            spec_cfg_attribute_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn cfg_attribute<'a>() -> (o: CfgAttributeCombinator)
+    ensures o@ == spec_cfg_attribute(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CfgAttributeCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(cfg_attr_type_word(), CfgAttributeCont1), CfgAttributeCont0),
+        mapper: CfgAttributeMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_cfg_attribute()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_cfg_attribute<'a>(input: &'a [u8]) -> (res: PResult<<CfgAttributeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_cfg_attribute().spec_parse(input@) == Some((n as int, v@)),
+        spec_cfg_attribute().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_cfg_attribute().spec_parse(input@) is None,
+        spec_cfg_attribute().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = cfg_attribute();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_cfg_attribute<'a>(v: <CfgAttributeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cfg_attribute().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_cfg_attribute().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_cfg_attribute().spec_serialize(v@).len(),
+{
+    let combinator = cfg_attribute();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct CfgAttributeCont1;
+type CfgAttributeCont1Type<'a, 'b> = &'b CfgAttrTypeWord;
+type CfgAttributeCont1SType<'a, 'x> = &'x CfgAttrTypeWord;
+type CfgAttributeCont1Input<'a, 'b, 'x> = POrSType<CfgAttributeCont1Type<'a, 'b>, CfgAttributeCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CfgAttributeCont1Input<'a, 'b, 'x>> for CfgAttributeCont1 {
+    type Output = U16Be;
+
+    open spec fn requires(&self, deps: CfgAttributeCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_cfg_attr_type_word()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CfgAttributeCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_cfg_attribute_cont1(deps@)
+    }
+
+    fn apply(&self, deps: CfgAttributeCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let r_and_attr_type = deps;
+                let r_and_attr_type = *r_and_attr_type;
+                U16Be
+            }
+            POrSType::S(deps) => {
+                let r_and_attr_type = deps;
+                let r_and_attr_type = *r_and_attr_type;
+                U16Be
+            }
+        }
+    }
+}
+pub struct CfgAttributeCont0;
+type CfgAttributeCont0Type<'a, 'b> = &'b (CfgAttrTypeWord, u16);
+type CfgAttributeCont0SType<'a, 'x> = (&'x CfgAttrTypeWord, &'x u16);
+type CfgAttributeCont0Input<'a, 'b, 'x> = POrSType<CfgAttributeCont0Type<'a, 'b>, CfgAttributeCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CfgAttributeCont0Input<'a, 'b, 'x>> for CfgAttributeCont0 {
+    type Output = bytes::Variable;
+
+    open spec fn requires(&self, deps: CfgAttributeCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_cfg_attr_type_word(), |deps| spec_cfg_attribute_cont1(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CfgAttributeCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_cfg_attribute_cont0(deps@)
+    }
+
+    fn apply(&self, deps: CfgAttributeCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (r_and_attr_type, length) = deps;
+                let r_and_attr_type = *r_and_attr_type;
+                let length = *length;
+                bytes::Variable((usize::ex_from(length)) as usize)
+            }
+            POrSType::S(deps) => {
+                let (r_and_attr_type, length) = deps;
+                let r_and_attr_type = *r_and_attr_type;
+                let length = *length;
+                bytes::Variable((usize::ex_from(length)) as usize)
+            }
+        }
+    }
+}
+                
+pub mod TsType {
+    use super::*;
+    pub spec const SPEC_TS_IPV4_ADDR_RANGE: u8 = 7;
+    pub spec const SPEC_TS_IPV6_ADDR_RANGE: u8 = 8;
+    pub exec const TS_IPV4_ADDR_RANGE: u8 ensures TS_IPV4_ADDR_RANGE == SPEC_TS_IPV4_ADDR_RANGE { 7 }
+    pub exec const TS_IPV6_ADDR_RANGE: u8 ensures TS_IPV6_ADDR_RANGE == SPEC_TS_IPV6_ADDR_RANGE { 8 }
+}
+
+
+pub struct SpecTsTypeCombinator(pub SpecTsTypeCombinatorAlias);
+
+impl SpecCombinator for SpecTsTypeCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTsTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTsTypeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTsTypeCombinatorAlias = U8;
+
+pub struct TsTypeCombinator(pub TsTypeCombinatorAlias);
+
+impl View for TsTypeCombinator {
+    type V = SpecTsTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecTsTypeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsTypeCombinator {
+    type Type = u8;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TsTypeCombinatorAlias = U8;
+
+
+pub open spec fn spec_ts_type() -> SpecTsTypeCombinator {
+    SpecTsTypeCombinator(U8)
+}
+
+                
+pub fn ts_type<'a>() -> (o: TsTypeCombinator)
+    ensures o@ == spec_ts_type(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TsTypeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_ts_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ts_type<'a>(input: &'a [u8]) -> (res: PResult<<TsTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ts_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_ts_type().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ts_type().spec_parse(input@) is None,
+        spec_ts_type().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ts_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ts_type<'a>(v: <TsTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_type().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ts_type().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ts_type().spec_serialize(v@).len(),
+{
+    let combinator = ts_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecTsIpv4SelectorBody {
+    pub ip_protocol_id: u8,
+    pub selector_length: u16,
+    pub start_port: u16,
+    pub end_port: u16,
+    pub start_address: Seq<u8>,
+    pub end_address: Seq<u8>,
+}
+
+pub type SpecTsIpv4SelectorBodyInner = (u8, (u16, (u16, (u16, (Seq<u8>, Seq<u8>)))));
+
+
+impl SpecFrom<SpecTsIpv4SelectorBody> for SpecTsIpv4SelectorBodyInner {
+    open spec fn spec_from(m: SpecTsIpv4SelectorBody) -> SpecTsIpv4SelectorBodyInner {
+        (m.ip_protocol_id, (m.selector_length, (m.start_port, (m.end_port, (m.start_address, m.end_address)))))
+    }
+}
+
+impl SpecFrom<SpecTsIpv4SelectorBodyInner> for SpecTsIpv4SelectorBody {
+    open spec fn spec_from(m: SpecTsIpv4SelectorBodyInner) -> SpecTsIpv4SelectorBody {
+        let (ip_protocol_id, (selector_length, (start_port, (end_port, (start_address, end_address))))) = m;
+        SpecTsIpv4SelectorBody { ip_protocol_id, selector_length, start_port, end_port, start_address, end_address }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct TsIpv4SelectorBody<'a> {
+    pub ip_protocol_id: u8,
+    pub selector_length: u16,
+    pub start_port: u16,
+    pub end_port: u16,
+    pub start_address: &'a [u8],
+    pub end_address: &'a [u8],
+}
+
+impl View for TsIpv4SelectorBody<'_> {
+    type V = SpecTsIpv4SelectorBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTsIpv4SelectorBody {
+            ip_protocol_id: self.ip_protocol_id@,
+            selector_length: self.selector_length@,
+            start_port: self.start_port@,
+            end_port: self.end_port@,
+            start_address: self.start_address@,
+            end_address: self.end_address@,
+        }
+    }
+}
+pub type TsIpv4SelectorBodyInner<'a> = (u8, (u16, (u16, (u16, (&'a [u8], &'a [u8])))));
+
+pub type TsIpv4SelectorBodyInnerRef<'a> = (&'a u8, (&'a u16, (&'a u16, (&'a u16, (&'a &'a [u8], &'a &'a [u8])))));
+impl<'a> From<&'a TsIpv4SelectorBody<'a>> for TsIpv4SelectorBodyInnerRef<'a> {
+    fn ex_from(m: &'a TsIpv4SelectorBody) -> TsIpv4SelectorBodyInnerRef<'a> {
+        (&m.ip_protocol_id, (&m.selector_length, (&m.start_port, (&m.end_port, (&m.start_address, &m.end_address)))))
+    }
+}
+
+impl<'a> From<TsIpv4SelectorBodyInner<'a>> for TsIpv4SelectorBody<'a> {
+    fn ex_from(m: TsIpv4SelectorBodyInner) -> TsIpv4SelectorBody {
+        let (ip_protocol_id, (selector_length, (start_port, (end_port, (start_address, end_address))))) = m;
+        TsIpv4SelectorBody { ip_protocol_id, selector_length, start_port, end_port, start_address, end_address }
+    }
+}
+
+pub struct TsIpv4SelectorBodyMapper;
+impl View for TsIpv4SelectorBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TsIpv4SelectorBodyMapper {
+    type Src = SpecTsIpv4SelectorBodyInner;
+    type Dst = SpecTsIpv4SelectorBody;
+}
+impl SpecIsoProof for TsIpv4SelectorBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TsIpv4SelectorBodyMapper {
+    type Src = TsIpv4SelectorBodyInner<'a>;
+    type Dst = TsIpv4SelectorBody<'a>;
+    type RefSrc = TsIpv4SelectorBodyInnerRef<'a>;
+}
+pub const TSIPV4SELECTORBODYSELECTOR_LENGTH_CONST: u16 = 16;
+type SpecTsIpv4SelectorBodyCombinatorAlias1 = (bytes::Fixed<4>, bytes::Fixed<4>);
+type SpecTsIpv4SelectorBodyCombinatorAlias2 = (U16Be, SpecTsIpv4SelectorBodyCombinatorAlias1);
+type SpecTsIpv4SelectorBodyCombinatorAlias3 = (U16Be, SpecTsIpv4SelectorBodyCombinatorAlias2);
+type SpecTsIpv4SelectorBodyCombinatorAlias4 = (Refined<U16Be, TagPred<u16>>, SpecTsIpv4SelectorBodyCombinatorAlias3);
+type SpecTsIpv4SelectorBodyCombinatorAlias5 = (U8, SpecTsIpv4SelectorBodyCombinatorAlias4);
+pub struct SpecTsIpv4SelectorBodyCombinator(pub SpecTsIpv4SelectorBodyCombinatorAlias);
+
+impl SpecCombinator for SpecTsIpv4SelectorBodyCombinator {
+    type Type = SpecTsIpv4SelectorBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTsIpv4SelectorBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTsIpv4SelectorBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTsIpv4SelectorBodyCombinatorAlias = Mapped<SpecTsIpv4SelectorBodyCombinatorAlias5, TsIpv4SelectorBodyMapper>;
+type TsIpv4SelectorBodyCombinatorAlias1 = (bytes::Fixed<4>, bytes::Fixed<4>);
+type TsIpv4SelectorBodyCombinatorAlias2 = (U16Be, TsIpv4SelectorBodyCombinator1);
+type TsIpv4SelectorBodyCombinatorAlias3 = (U16Be, TsIpv4SelectorBodyCombinator2);
+type TsIpv4SelectorBodyCombinatorAlias4 = (Refined<U16Be, TagPred<u16>>, TsIpv4SelectorBodyCombinator3);
+type TsIpv4SelectorBodyCombinatorAlias5 = (U8, TsIpv4SelectorBodyCombinator4);
+pub struct TsIpv4SelectorBodyCombinator1(pub TsIpv4SelectorBodyCombinatorAlias1);
+impl View for TsIpv4SelectorBodyCombinator1 {
+    type V = SpecTsIpv4SelectorBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv4SelectorBodyCombinator1, TsIpv4SelectorBodyCombinatorAlias1);
+
+pub struct TsIpv4SelectorBodyCombinator2(pub TsIpv4SelectorBodyCombinatorAlias2);
+impl View for TsIpv4SelectorBodyCombinator2 {
+    type V = SpecTsIpv4SelectorBodyCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv4SelectorBodyCombinator2, TsIpv4SelectorBodyCombinatorAlias2);
+
+pub struct TsIpv4SelectorBodyCombinator3(pub TsIpv4SelectorBodyCombinatorAlias3);
+impl View for TsIpv4SelectorBodyCombinator3 {
+    type V = SpecTsIpv4SelectorBodyCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv4SelectorBodyCombinator3, TsIpv4SelectorBodyCombinatorAlias3);
+
+pub struct TsIpv4SelectorBodyCombinator4(pub TsIpv4SelectorBodyCombinatorAlias4);
+impl View for TsIpv4SelectorBodyCombinator4 {
+    type V = SpecTsIpv4SelectorBodyCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv4SelectorBodyCombinator4, TsIpv4SelectorBodyCombinatorAlias4);
+
+pub struct TsIpv4SelectorBodyCombinator5(pub TsIpv4SelectorBodyCombinatorAlias5);
+impl View for TsIpv4SelectorBodyCombinator5 {
+    type V = SpecTsIpv4SelectorBodyCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv4SelectorBodyCombinator5, TsIpv4SelectorBodyCombinatorAlias5);
+
+pub struct TsIpv4SelectorBodyCombinator(pub TsIpv4SelectorBodyCombinatorAlias);
+
+impl View for TsIpv4SelectorBodyCombinator {
+    type V = SpecTsIpv4SelectorBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecTsIpv4SelectorBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv4SelectorBodyCombinator {
+    type Type = TsIpv4SelectorBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TsIpv4SelectorBodyCombinatorAlias = Mapped<TsIpv4SelectorBodyCombinator5, TsIpv4SelectorBodyMapper>;
+
+
+pub open spec fn spec_ts_ipv4_selector_body() -> SpecTsIpv4SelectorBodyCombinator {
+    SpecTsIpv4SelectorBodyCombinator(
+    Mapped {
+        inner: (U8, (Refined { inner: U16Be, predicate: TagPred(TSIPV4SELECTORBODYSELECTOR_LENGTH_CONST) }, (U16Be, (U16Be, (bytes::Fixed::<4>, bytes::Fixed::<4>))))),
+        mapper: TsIpv4SelectorBodyMapper,
+    })
+}
+
+                
+pub fn ts_ipv4_selector_body<'a>() -> (o: TsIpv4SelectorBodyCombinator)
+    ensures o@ == spec_ts_ipv4_selector_body(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TsIpv4SelectorBodyCombinator(
+    Mapped {
+        inner: TsIpv4SelectorBodyCombinator5((U8, TsIpv4SelectorBodyCombinator4((Refined { inner: U16Be, predicate: TagPred(TSIPV4SELECTORBODYSELECTOR_LENGTH_CONST) }, TsIpv4SelectorBodyCombinator3((U16Be, TsIpv4SelectorBodyCombinator2((U16Be, TsIpv4SelectorBodyCombinator1((bytes::Fixed::<4>, bytes::Fixed::<4>)))))))))),
+        mapper: TsIpv4SelectorBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ts_ipv4_selector_body()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ts_ipv4_selector_body<'a>(input: &'a [u8]) -> (res: PResult<<TsIpv4SelectorBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ts_ipv4_selector_body().spec_parse(input@) == Some((n as int, v@)),
+        spec_ts_ipv4_selector_body().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ts_ipv4_selector_body().spec_parse(input@) is None,
+        spec_ts_ipv4_selector_body().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ts_ipv4_selector_body();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ts_ipv4_selector_body<'a>(v: <TsIpv4SelectorBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_ipv4_selector_body().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ts_ipv4_selector_body().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ts_ipv4_selector_body().spec_serialize(v@).len(),
+{
+    let combinator = ts_ipv4_selector_body();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecTsIpv6SelectorBody {
+    pub ip_protocol_id: u8,
+    pub selector_length: u16,
+    pub start_port: u16,
+    pub end_port: u16,
+    pub start_address: Seq<u8>,
+    pub end_address: Seq<u8>,
+}
+
+pub type SpecTsIpv6SelectorBodyInner = (u8, (u16, (u16, (u16, (Seq<u8>, Seq<u8>)))));
+
+
+impl SpecFrom<SpecTsIpv6SelectorBody> for SpecTsIpv6SelectorBodyInner {
+    open spec fn spec_from(m: SpecTsIpv6SelectorBody) -> SpecTsIpv6SelectorBodyInner {
+        (m.ip_protocol_id, (m.selector_length, (m.start_port, (m.end_port, (m.start_address, m.end_address)))))
+    }
+}
+
+impl SpecFrom<SpecTsIpv6SelectorBodyInner> for SpecTsIpv6SelectorBody {
+    open spec fn spec_from(m: SpecTsIpv6SelectorBodyInner) -> SpecTsIpv6SelectorBody {
+        let (ip_protocol_id, (selector_length, (start_port, (end_port, (start_address, end_address))))) = m;
+        SpecTsIpv6SelectorBody { ip_protocol_id, selector_length, start_port, end_port, start_address, end_address }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct TsIpv6SelectorBody<'a> {
+    pub ip_protocol_id: u8,
+    pub selector_length: u16,
+    pub start_port: u16,
+    pub end_port: u16,
+    pub start_address: &'a [u8],
+    pub end_address: &'a [u8],
+}
+
+impl View for TsIpv6SelectorBody<'_> {
+    type V = SpecTsIpv6SelectorBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTsIpv6SelectorBody {
+            ip_protocol_id: self.ip_protocol_id@,
+            selector_length: self.selector_length@,
+            start_port: self.start_port@,
+            end_port: self.end_port@,
+            start_address: self.start_address@,
+            end_address: self.end_address@,
+        }
+    }
+}
+pub type TsIpv6SelectorBodyInner<'a> = (u8, (u16, (u16, (u16, (&'a [u8], &'a [u8])))));
+
+pub type TsIpv6SelectorBodyInnerRef<'a> = (&'a u8, (&'a u16, (&'a u16, (&'a u16, (&'a &'a [u8], &'a &'a [u8])))));
+impl<'a> From<&'a TsIpv6SelectorBody<'a>> for TsIpv6SelectorBodyInnerRef<'a> {
+    fn ex_from(m: &'a TsIpv6SelectorBody) -> TsIpv6SelectorBodyInnerRef<'a> {
+        (&m.ip_protocol_id, (&m.selector_length, (&m.start_port, (&m.end_port, (&m.start_address, &m.end_address)))))
+    }
+}
+
+impl<'a> From<TsIpv6SelectorBodyInner<'a>> for TsIpv6SelectorBody<'a> {
+    fn ex_from(m: TsIpv6SelectorBodyInner) -> TsIpv6SelectorBody {
+        let (ip_protocol_id, (selector_length, (start_port, (end_port, (start_address, end_address))))) = m;
+        TsIpv6SelectorBody { ip_protocol_id, selector_length, start_port, end_port, start_address, end_address }
+    }
+}
+
+pub struct TsIpv6SelectorBodyMapper;
+impl View for TsIpv6SelectorBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TsIpv6SelectorBodyMapper {
+    type Src = SpecTsIpv6SelectorBodyInner;
+    type Dst = SpecTsIpv6SelectorBody;
+}
+impl SpecIsoProof for TsIpv6SelectorBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TsIpv6SelectorBodyMapper {
+    type Src = TsIpv6SelectorBodyInner<'a>;
+    type Dst = TsIpv6SelectorBody<'a>;
+    type RefSrc = TsIpv6SelectorBodyInnerRef<'a>;
+}
+pub const TSIPV6SELECTORBODYSELECTOR_LENGTH_CONST: u16 = 40;
+type SpecTsIpv6SelectorBodyCombinatorAlias1 = (bytes::Fixed<16>, bytes::Fixed<16>);
+type SpecTsIpv6SelectorBodyCombinatorAlias2 = (U16Be, SpecTsIpv6SelectorBodyCombinatorAlias1);
+type SpecTsIpv6SelectorBodyCombinatorAlias3 = (U16Be, SpecTsIpv6SelectorBodyCombinatorAlias2);
+type SpecTsIpv6SelectorBodyCombinatorAlias4 = (Refined<U16Be, TagPred<u16>>, SpecTsIpv6SelectorBodyCombinatorAlias3);
+type SpecTsIpv6SelectorBodyCombinatorAlias5 = (U8, SpecTsIpv6SelectorBodyCombinatorAlias4);
+pub struct SpecTsIpv6SelectorBodyCombinator(pub SpecTsIpv6SelectorBodyCombinatorAlias);
+
+impl SpecCombinator for SpecTsIpv6SelectorBodyCombinator {
+    type Type = SpecTsIpv6SelectorBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTsIpv6SelectorBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTsIpv6SelectorBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTsIpv6SelectorBodyCombinatorAlias = Mapped<SpecTsIpv6SelectorBodyCombinatorAlias5, TsIpv6SelectorBodyMapper>;
+type TsIpv6SelectorBodyCombinatorAlias1 = (bytes::Fixed<16>, bytes::Fixed<16>);
+type TsIpv6SelectorBodyCombinatorAlias2 = (U16Be, TsIpv6SelectorBodyCombinator1);
+type TsIpv6SelectorBodyCombinatorAlias3 = (U16Be, TsIpv6SelectorBodyCombinator2);
+type TsIpv6SelectorBodyCombinatorAlias4 = (Refined<U16Be, TagPred<u16>>, TsIpv6SelectorBodyCombinator3);
+type TsIpv6SelectorBodyCombinatorAlias5 = (U8, TsIpv6SelectorBodyCombinator4);
+pub struct TsIpv6SelectorBodyCombinator1(pub TsIpv6SelectorBodyCombinatorAlias1);
+impl View for TsIpv6SelectorBodyCombinator1 {
+    type V = SpecTsIpv6SelectorBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv6SelectorBodyCombinator1, TsIpv6SelectorBodyCombinatorAlias1);
+
+pub struct TsIpv6SelectorBodyCombinator2(pub TsIpv6SelectorBodyCombinatorAlias2);
+impl View for TsIpv6SelectorBodyCombinator2 {
+    type V = SpecTsIpv6SelectorBodyCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv6SelectorBodyCombinator2, TsIpv6SelectorBodyCombinatorAlias2);
+
+pub struct TsIpv6SelectorBodyCombinator3(pub TsIpv6SelectorBodyCombinatorAlias3);
+impl View for TsIpv6SelectorBodyCombinator3 {
+    type V = SpecTsIpv6SelectorBodyCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv6SelectorBodyCombinator3, TsIpv6SelectorBodyCombinatorAlias3);
+
+pub struct TsIpv6SelectorBodyCombinator4(pub TsIpv6SelectorBodyCombinatorAlias4);
+impl View for TsIpv6SelectorBodyCombinator4 {
+    type V = SpecTsIpv6SelectorBodyCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv6SelectorBodyCombinator4, TsIpv6SelectorBodyCombinatorAlias4);
+
+pub struct TsIpv6SelectorBodyCombinator5(pub TsIpv6SelectorBodyCombinatorAlias5);
+impl View for TsIpv6SelectorBodyCombinator5 {
+    type V = SpecTsIpv6SelectorBodyCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv6SelectorBodyCombinator5, TsIpv6SelectorBodyCombinatorAlias5);
+
+pub struct TsIpv6SelectorBodyCombinator(pub TsIpv6SelectorBodyCombinatorAlias);
+
+impl View for TsIpv6SelectorBodyCombinator {
+    type V = SpecTsIpv6SelectorBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecTsIpv6SelectorBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv6SelectorBodyCombinator {
+    type Type = TsIpv6SelectorBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TsIpv6SelectorBodyCombinatorAlias = Mapped<TsIpv6SelectorBodyCombinator5, TsIpv6SelectorBodyMapper>;
+
+
+pub open spec fn spec_ts_ipv6_selector_body() -> SpecTsIpv6SelectorBodyCombinator {
+    SpecTsIpv6SelectorBodyCombinator(
+    Mapped {
+        inner: (U8, (Refined { inner: U16Be, predicate: TagPred(TSIPV6SELECTORBODYSELECTOR_LENGTH_CONST) }, (U16Be, (U16Be, (bytes::Fixed::<16>, bytes::Fixed::<16>))))),
+        mapper: TsIpv6SelectorBodyMapper,
+    })
+}
+
+                
+pub fn ts_ipv6_selector_body<'a>() -> (o: TsIpv6SelectorBodyCombinator)
+    ensures o@ == spec_ts_ipv6_selector_body(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TsIpv6SelectorBodyCombinator(
+    Mapped {
+        inner: TsIpv6SelectorBodyCombinator5((U8, TsIpv6SelectorBodyCombinator4((Refined { inner: U16Be, predicate: TagPred(TSIPV6SELECTORBODYSELECTOR_LENGTH_CONST) }, TsIpv6SelectorBodyCombinator3((U16Be, TsIpv6SelectorBodyCombinator2((U16Be, TsIpv6SelectorBodyCombinator1((bytes::Fixed::<16>, bytes::Fixed::<16>)))))))))),
+        mapper: TsIpv6SelectorBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ts_ipv6_selector_body()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ts_ipv6_selector_body<'a>(input: &'a [u8]) -> (res: PResult<<TsIpv6SelectorBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ts_ipv6_selector_body().spec_parse(input@) == Some((n as int, v@)),
+        spec_ts_ipv6_selector_body().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ts_ipv6_selector_body().spec_parse(input@) is None,
+        spec_ts_ipv6_selector_body().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ts_ipv6_selector_body();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ts_ipv6_selector_body<'a>(v: <TsIpv6SelectorBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_ipv6_selector_body().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ts_ipv6_selector_body().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ts_ipv6_selector_body().spec_serialize(v@).len(),
+{
+    let combinator = ts_ipv6_selector_body();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecTsUnknownInner {
+    pub ip_protocol_id: u8,
+    pub selector_length: u16,
+    pub selector_data: Seq<u8>,
+}
+
+pub type SpecTsUnknownInnerInner = ((u8, u16), Seq<u8>);
+
+
+impl SpecFrom<SpecTsUnknownInner> for SpecTsUnknownInnerInner {
+    open spec fn spec_from(m: SpecTsUnknownInner) -> SpecTsUnknownInnerInner {
+        ((m.ip_protocol_id, m.selector_length), m.selector_data)
+    }
+}
+
+impl SpecFrom<SpecTsUnknownInnerInner> for SpecTsUnknownInner {
+    open spec fn spec_from(m: SpecTsUnknownInnerInner) -> SpecTsUnknownInner {
+        let ((ip_protocol_id, selector_length), selector_data) = m;
+        SpecTsUnknownInner { ip_protocol_id, selector_length, selector_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct TsUnknownInner<'a> {
+    pub ip_protocol_id: u8,
+    pub selector_length: u16,
+    pub selector_data: &'a [u8],
+}
+
+impl View for TsUnknownInner<'_> {
+    type V = SpecTsUnknownInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTsUnknownInner {
+            ip_protocol_id: self.ip_protocol_id@,
+            selector_length: self.selector_length@,
+            selector_data: self.selector_data@,
+        }
+    }
+}
+pub type TsUnknownInnerInner<'a> = ((u8, u16), &'a [u8]);
+
+pub type TsUnknownInnerInnerRef<'a> = ((&'a u8, &'a u16), &'a &'a [u8]);
+impl<'a> From<&'a TsUnknownInner<'a>> for TsUnknownInnerInnerRef<'a> {
+    fn ex_from(m: &'a TsUnknownInner) -> TsUnknownInnerInnerRef<'a> {
+        ((&m.ip_protocol_id, &m.selector_length), &m.selector_data)
+    }
+}
+
+impl<'a> From<TsUnknownInnerInner<'a>> for TsUnknownInner<'a> {
+    fn ex_from(m: TsUnknownInnerInner) -> TsUnknownInner {
+        let ((ip_protocol_id, selector_length), selector_data) = m;
+        TsUnknownInner { ip_protocol_id, selector_length, selector_data }
+    }
+}
+
+pub struct TsUnknownInnerMapper;
+impl View for TsUnknownInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TsUnknownInnerMapper {
+    type Src = SpecTsUnknownInnerInner;
+    type Dst = SpecTsUnknownInner;
+}
+impl SpecIsoProof for TsUnknownInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TsUnknownInnerMapper {
+    type Src = TsUnknownInnerInner<'a>;
+    type Dst = TsUnknownInner<'a>;
+    type RefSrc = TsUnknownInnerInnerRef<'a>;
+}
+
+pub struct SpecTsUnknownInnerCombinator(pub SpecTsUnknownInnerCombinatorAlias);
+
+impl SpecCombinator for SpecTsUnknownInnerCombinator {
+    type Type = SpecTsUnknownInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTsUnknownInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTsUnknownInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTsUnknownInnerCombinatorAlias = Mapped<SpecPair<(U8, Refined<U16Be, Predicate17149271707383182075>), bytes::Variable>, TsUnknownInnerMapper>;
+pub struct Predicate17149271707383182075;
+impl View for Predicate17149271707383182075 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate17149271707383182075 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 4 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate17149271707383182075 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 4 && i <= 65535)
+    }
+}
+
+pub struct TsUnknownInnerCombinator(pub TsUnknownInnerCombinatorAlias);
+
+impl View for TsUnknownInnerCombinator {
+    type V = SpecTsUnknownInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecTsUnknownInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsUnknownInnerCombinator {
+    type Type = TsUnknownInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TsUnknownInnerCombinatorAlias = Mapped<Pair<(U8, Refined<U16Be, Predicate17149271707383182075>), bytes::Variable, TsUnknownInnerCont0>, TsUnknownInnerMapper>;
+
+
+pub open spec fn spec_ts_unknown_inner() -> SpecTsUnknownInnerCombinator {
+    SpecTsUnknownInnerCombinator(
+    Mapped {
+        inner: Pair::spec_new((U8, Refined { inner: U16Be, predicate: Predicate17149271707383182075 }), |deps| spec_ts_unknown_inner_cont0(deps)),
+        mapper: TsUnknownInnerMapper,
+    })
+}
+
+pub open spec fn spec_ts_unknown_inner_cont0(deps: (u8, u16)) -> bytes::Variable {
+    let (_, selector_length) = deps;
+    bytes::Variable(((usize::spec_from(selector_length) - 4)) as usize)
+}
+
+impl View for TsUnknownInnerCont0 {
+    type V = spec_fn((u8, u16)) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u8, u16)| {
+            spec_ts_unknown_inner_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn ts_unknown_inner<'a>() -> (o: TsUnknownInnerCombinator)
+    ensures o@ == spec_ts_unknown_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TsUnknownInnerCombinator(
+    Mapped {
+        inner: Pair::new((U8, Refined { inner: U16Be, predicate: Predicate17149271707383182075 }), TsUnknownInnerCont0),
+        mapper: TsUnknownInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ts_unknown_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ts_unknown_inner<'a>(input: &'a [u8]) -> (res: PResult<<TsUnknownInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ts_unknown_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ts_unknown_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ts_unknown_inner().spec_parse(input@) is None,
+        spec_ts_unknown_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ts_unknown_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ts_unknown_inner<'a>(v: <TsUnknownInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_unknown_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ts_unknown_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ts_unknown_inner().spec_serialize(v@).len(),
+{
+    let combinator = ts_unknown_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct TsUnknownInnerCont0;
+type TsUnknownInnerCont0Type<'a, 'b> = &'b (u8, u16);
+type TsUnknownInnerCont0SType<'a, 'x> = (&'x u8, &'x u16);
+type TsUnknownInnerCont0Input<'a, 'b, 'x> = POrSType<TsUnknownInnerCont0Type<'a, 'b>, TsUnknownInnerCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TsUnknownInnerCont0Input<'a, 'b, 'x>> for TsUnknownInnerCont0 {
+    type Output = bytes::Variable;
+
+    open spec fn requires(&self, deps: TsUnknownInnerCont0Input<'a, 'b, 'x>) -> bool {
+        &&& ((U8, Refined { inner: U16Be, predicate: Predicate17149271707383182075 })).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: TsUnknownInnerCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_ts_unknown_inner_cont0(deps@)
+    }
+
+    fn apply(&self, deps: TsUnknownInnerCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (_, selector_length) = deps;
+                let selector_length = *selector_length;
+                bytes::Variable(((usize::ex_from(selector_length) - 4)) as usize)
+            }
+            POrSType::S(deps) => {
+                let (_, selector_length) = deps;
+                let selector_length = *selector_length;
+                bytes::Variable(((usize::ex_from(selector_length) - 4)) as usize)
+            }
+        }
+    }
+}
+                
+
+pub enum SpecTrafficSelectorTsBody {
+    TS_IPV4_ADDR_RANGE(SpecTsIpv4SelectorBody),
+    TS_IPV6_ADDR_RANGE(SpecTsIpv6SelectorBody),
+    Unrecognized(SpecTsUnknownInner),
+}
+
+pub type SpecTrafficSelectorTsBodyInner = Either<SpecTsIpv4SelectorBody, Either<SpecTsIpv6SelectorBody, SpecTsUnknownInner>>;
+
+impl SpecFrom<SpecTrafficSelectorTsBody> for SpecTrafficSelectorTsBodyInner {
+    open spec fn spec_from(m: SpecTrafficSelectorTsBody) -> SpecTrafficSelectorTsBodyInner {
+        match m {
+            SpecTrafficSelectorTsBody::TS_IPV4_ADDR_RANGE(m) => Either::Left(m),
+            SpecTrafficSelectorTsBody::TS_IPV6_ADDR_RANGE(m) => Either::Right(Either::Left(m)),
+            SpecTrafficSelectorTsBody::Unrecognized(m) => Either::Right(Either::Right(m)),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecTrafficSelectorTsBodyInner> for SpecTrafficSelectorTsBody {
+    open spec fn spec_from(m: SpecTrafficSelectorTsBodyInner) -> SpecTrafficSelectorTsBody {
+        match m {
+            Either::Left(m) => SpecTrafficSelectorTsBody::TS_IPV4_ADDR_RANGE(m),
+            Either::Right(Either::Left(m)) => SpecTrafficSelectorTsBody::TS_IPV6_ADDR_RANGE(m),
+            Either::Right(Either::Right(m)) => SpecTrafficSelectorTsBody::Unrecognized(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum TrafficSelectorTsBody<'a> {
+    TS_IPV4_ADDR_RANGE(TsIpv4SelectorBody<'a>),
+    TS_IPV6_ADDR_RANGE(TsIpv6SelectorBody<'a>),
+    Unrecognized(TsUnknownInner<'a>),
+}
+
+pub type TrafficSelectorTsBodyInner<'a> = Either<TsIpv4SelectorBody<'a>, Either<TsIpv6SelectorBody<'a>, TsUnknownInner<'a>>>;
+
+pub type TrafficSelectorTsBodyInnerRef<'a> = Either<&'a TsIpv4SelectorBody<'a>, Either<&'a TsIpv6SelectorBody<'a>, &'a TsUnknownInner<'a>>>;
+
+
+impl<'a> View for TrafficSelectorTsBody<'a> {
+    type V = SpecTrafficSelectorTsBody;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            TrafficSelectorTsBody::TS_IPV4_ADDR_RANGE(m) => SpecTrafficSelectorTsBody::TS_IPV4_ADDR_RANGE(m@),
+            TrafficSelectorTsBody::TS_IPV6_ADDR_RANGE(m) => SpecTrafficSelectorTsBody::TS_IPV6_ADDR_RANGE(m@),
+            TrafficSelectorTsBody::Unrecognized(m) => SpecTrafficSelectorTsBody::Unrecognized(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a TrafficSelectorTsBody<'a>> for TrafficSelectorTsBodyInnerRef<'a> {
+    fn ex_from(m: &'a TrafficSelectorTsBody<'a>) -> TrafficSelectorTsBodyInnerRef<'a> {
+        match m {
+            TrafficSelectorTsBody::TS_IPV4_ADDR_RANGE(m) => Either::Left(m),
+            TrafficSelectorTsBody::TS_IPV6_ADDR_RANGE(m) => Either::Right(Either::Left(m)),
+            TrafficSelectorTsBody::Unrecognized(m) => Either::Right(Either::Right(m)),
+        }
+    }
+
+}
+
+impl<'a> From<TrafficSelectorTsBodyInner<'a>> for TrafficSelectorTsBody<'a> {
+    fn ex_from(m: TrafficSelectorTsBodyInner<'a>) -> TrafficSelectorTsBody<'a> {
+        match m {
+            Either::Left(m) => TrafficSelectorTsBody::TS_IPV4_ADDR_RANGE(m),
+            Either::Right(Either::Left(m)) => TrafficSelectorTsBody::TS_IPV6_ADDR_RANGE(m),
+            Either::Right(Either::Right(m)) => TrafficSelectorTsBody::Unrecognized(m),
+        }
+    }
+    
+}
+
+
+pub struct TrafficSelectorTsBodyMapper;
+impl View for TrafficSelectorTsBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TrafficSelectorTsBodyMapper {
+    type Src = SpecTrafficSelectorTsBodyInner;
+    type Dst = SpecTrafficSelectorTsBody;
+}
+impl SpecIsoProof for TrafficSelectorTsBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TrafficSelectorTsBodyMapper {
+    type Src = TrafficSelectorTsBodyInner<'a>;
+    type Dst = TrafficSelectorTsBody<'a>;
+    type RefSrc = TrafficSelectorTsBodyInnerRef<'a>;
+}
+
+type SpecTrafficSelectorTsBodyCombinatorAlias1 = Choice<Cond<SpecTsIpv6SelectorBodyCombinator>, Cond<SpecTsUnknownInnerCombinator>>;
+type SpecTrafficSelectorTsBodyCombinatorAlias2 = Choice<Cond<SpecTsIpv4SelectorBodyCombinator>, SpecTrafficSelectorTsBodyCombinatorAlias1>;
+pub struct SpecTrafficSelectorTsBodyCombinator(pub SpecTrafficSelectorTsBodyCombinatorAlias);
+
+impl SpecCombinator for SpecTrafficSelectorTsBodyCombinator {
+    type Type = SpecTrafficSelectorTsBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTrafficSelectorTsBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTrafficSelectorTsBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTrafficSelectorTsBodyCombinatorAlias = Mapped<SpecTrafficSelectorTsBodyCombinatorAlias2, TrafficSelectorTsBodyMapper>;
+type TrafficSelectorTsBodyCombinatorAlias1 = Choice<Cond<TsIpv6SelectorBodyCombinator>, Cond<TsUnknownInnerCombinator>>;
+type TrafficSelectorTsBodyCombinatorAlias2 = Choice<Cond<TsIpv4SelectorBodyCombinator>, TrafficSelectorTsBodyCombinator1>;
+pub struct TrafficSelectorTsBodyCombinator1(pub TrafficSelectorTsBodyCombinatorAlias1);
+impl View for TrafficSelectorTsBodyCombinator1 {
+    type V = SpecTrafficSelectorTsBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TrafficSelectorTsBodyCombinator1, TrafficSelectorTsBodyCombinatorAlias1);
+
+pub struct TrafficSelectorTsBodyCombinator2(pub TrafficSelectorTsBodyCombinatorAlias2);
+impl View for TrafficSelectorTsBodyCombinator2 {
+    type V = SpecTrafficSelectorTsBodyCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TrafficSelectorTsBodyCombinator2, TrafficSelectorTsBodyCombinatorAlias2);
+
+pub struct TrafficSelectorTsBodyCombinator(pub TrafficSelectorTsBodyCombinatorAlias);
+
+impl View for TrafficSelectorTsBodyCombinator {
+    type V = SpecTrafficSelectorTsBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecTrafficSelectorTsBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TrafficSelectorTsBodyCombinator {
+    type Type = TrafficSelectorTsBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TrafficSelectorTsBodyCombinatorAlias = Mapped<TrafficSelectorTsBodyCombinator2, TrafficSelectorTsBodyMapper>;
+
+
+pub open spec fn spec_traffic_selector_ts_body(ts_type_byte: u8) -> SpecTrafficSelectorTsBodyCombinator {
+    SpecTrafficSelectorTsBodyCombinator(Mapped { inner: Choice(Cond { cond: ts_type_byte == TsType::SPEC_TS_IPV4_ADDR_RANGE, inner: spec_ts_ipv4_selector_body() }, Choice(Cond { cond: ts_type_byte == TsType::SPEC_TS_IPV6_ADDR_RANGE, inner: spec_ts_ipv6_selector_body() }, Cond { cond: !(ts_type_byte == TsType::SPEC_TS_IPV4_ADDR_RANGE || ts_type_byte == TsType::SPEC_TS_IPV6_ADDR_RANGE), inner: spec_ts_unknown_inner() })), mapper: TrafficSelectorTsBodyMapper })
+}
+
+pub fn traffic_selector_ts_body<'a>(ts_type_byte: u8) -> (o: TrafficSelectorTsBodyCombinator)
+    requires
+        spec_ts_type().wf(ts_type_byte@),
+
+    ensures o@ == spec_traffic_selector_ts_body(ts_type_byte@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TrafficSelectorTsBodyCombinator(Mapped { inner: TrafficSelectorTsBodyCombinator2(Choice::new(Cond { cond: ts_type_byte == TsType::TS_IPV4_ADDR_RANGE, inner: ts_ipv4_selector_body() }, TrafficSelectorTsBodyCombinator1(Choice::new(Cond { cond: ts_type_byte == TsType::TS_IPV6_ADDR_RANGE, inner: ts_ipv6_selector_body() }, Cond { cond: !(ts_type_byte == TsType::TS_IPV4_ADDR_RANGE || ts_type_byte == TsType::TS_IPV6_ADDR_RANGE), inner: ts_unknown_inner() })))), mapper: TrafficSelectorTsBodyMapper });
+    // assert({
+    //     &&& combinator@ == spec_traffic_selector_ts_body(ts_type_byte@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_traffic_selector_ts_body<'a>(input: &'a [u8], ts_type_byte: u8) -> (res: PResult<<TrafficSelectorTsBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_ts_type().wf(ts_type_byte@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_traffic_selector_ts_body(ts_type_byte@).spec_parse(input@) == Some((n as int, v@)),
+        spec_traffic_selector_ts_body(ts_type_byte@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_traffic_selector_ts_body(ts_type_byte@).spec_parse(input@) is None,
+        spec_traffic_selector_ts_body(ts_type_byte@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = traffic_selector_ts_body( ts_type_byte );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_traffic_selector_ts_body<'a>(v: <TrafficSelectorTsBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ts_type_byte: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_traffic_selector_ts_body(ts_type_byte@).wf(v@),
+        spec_ts_type().wf(ts_type_byte@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_traffic_selector_ts_body(ts_type_byte@).spec_serialize(v@).len() <= usize::MAX,
+        spec_ts_type().wf(ts_type_byte@),
+
+    ensures
+        serialize_len == spec_traffic_selector_ts_body(ts_type_byte@).spec_serialize(v@).len(),
+{
+    let combinator = traffic_selector_ts_body( ts_type_byte );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecTrafficSelector {
+    pub ts_type_byte: u8,
+    pub ts_body: SpecTrafficSelectorTsBody,
+}
+
+pub type SpecTrafficSelectorInner = (u8, SpecTrafficSelectorTsBody);
+
+
+impl SpecFrom<SpecTrafficSelector> for SpecTrafficSelectorInner {
+    open spec fn spec_from(m: SpecTrafficSelector) -> SpecTrafficSelectorInner {
+        (m.ts_type_byte, m.ts_body)
+    }
+}
+
+impl SpecFrom<SpecTrafficSelectorInner> for SpecTrafficSelector {
+    open spec fn spec_from(m: SpecTrafficSelectorInner) -> SpecTrafficSelector {
+        let (ts_type_byte, ts_body) = m;
+        SpecTrafficSelector { ts_type_byte, ts_body }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct TrafficSelector<'a> {
+    pub ts_type_byte: u8,
+    pub ts_body: TrafficSelectorTsBody<'a>,
+}
+
+impl View for TrafficSelector<'_> {
+    type V = SpecTrafficSelector;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTrafficSelector {
+            ts_type_byte: self.ts_type_byte@,
+            ts_body: self.ts_body@,
+        }
+    }
+}
+pub type TrafficSelectorInner<'a> = (u8, TrafficSelectorTsBody<'a>);
+
+pub type TrafficSelectorInnerRef<'a> = (&'a u8, &'a TrafficSelectorTsBody<'a>);
+impl<'a> From<&'a TrafficSelector<'a>> for TrafficSelectorInnerRef<'a> {
+    fn ex_from(m: &'a TrafficSelector) -> TrafficSelectorInnerRef<'a> {
+        (&m.ts_type_byte, &m.ts_body)
+    }
+}
+
+impl<'a> From<TrafficSelectorInner<'a>> for TrafficSelector<'a> {
+    fn ex_from(m: TrafficSelectorInner) -> TrafficSelector {
+        let (ts_type_byte, ts_body) = m;
+        TrafficSelector { ts_type_byte, ts_body }
+    }
+}
+
+pub struct TrafficSelectorMapper;
+impl View for TrafficSelectorMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TrafficSelectorMapper {
+    type Src = SpecTrafficSelectorInner;
+    type Dst = SpecTrafficSelector;
+}
+impl SpecIsoProof for TrafficSelectorMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TrafficSelectorMapper {
+    type Src = TrafficSelectorInner<'a>;
+    type Dst = TrafficSelector<'a>;
+    type RefSrc = TrafficSelectorInnerRef<'a>;
+}
+
+pub struct SpecTrafficSelectorCombinator(pub SpecTrafficSelectorCombinatorAlias);
+
+impl SpecCombinator for SpecTrafficSelectorCombinator {
+    type Type = SpecTrafficSelector;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTrafficSelectorCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTrafficSelectorCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTrafficSelectorCombinatorAlias = Mapped<SpecPair<SpecTsTypeCombinator, SpecTrafficSelectorTsBodyCombinator>, TrafficSelectorMapper>;
+
+pub struct TrafficSelectorCombinator(pub TrafficSelectorCombinatorAlias);
+
+impl View for TrafficSelectorCombinator {
+    type V = SpecTrafficSelectorCombinator;
+    open spec fn view(&self) -> Self::V { SpecTrafficSelectorCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TrafficSelectorCombinator {
+    type Type = TrafficSelector<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TrafficSelectorCombinatorAlias = Mapped<Pair<TsTypeCombinator, TrafficSelectorTsBodyCombinator, TrafficSelectorCont0>, TrafficSelectorMapper>;
+
+
+pub open spec fn spec_traffic_selector() -> SpecTrafficSelectorCombinator {
+    SpecTrafficSelectorCombinator(
+    Mapped {
+        inner: Pair::spec_new(spec_ts_type(), |deps| spec_traffic_selector_cont0(deps)),
+        mapper: TrafficSelectorMapper,
+    })
+}
+
+pub open spec fn spec_traffic_selector_cont0(deps: u8) -> SpecTrafficSelectorTsBodyCombinator {
+    let ts_type_byte = deps;
+    spec_traffic_selector_ts_body(ts_type_byte)
+}
+
+impl View for TrafficSelectorCont0 {
+    type V = spec_fn(u8) -> SpecTrafficSelectorTsBodyCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_traffic_selector_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn traffic_selector<'a>() -> (o: TrafficSelectorCombinator)
+    ensures o@ == spec_traffic_selector(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TrafficSelectorCombinator(
+    Mapped {
+        inner: Pair::new(ts_type(), TrafficSelectorCont0),
+        mapper: TrafficSelectorMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_traffic_selector()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_traffic_selector<'a>(input: &'a [u8]) -> (res: PResult<<TrafficSelectorCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_traffic_selector().spec_parse(input@) == Some((n as int, v@)),
+        spec_traffic_selector().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_traffic_selector().spec_parse(input@) is None,
+        spec_traffic_selector().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = traffic_selector();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_traffic_selector<'a>(v: <TrafficSelectorCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_traffic_selector().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_traffic_selector().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_traffic_selector().spec_serialize(v@).len(),
+{
+    let combinator = traffic_selector();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct TrafficSelectorCont0;
+type TrafficSelectorCont0Type<'a, 'b> = &'b u8;
+type TrafficSelectorCont0SType<'a, 'x> = &'x u8;
+type TrafficSelectorCont0Input<'a, 'b, 'x> = POrSType<TrafficSelectorCont0Type<'a, 'b>, TrafficSelectorCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TrafficSelectorCont0Input<'a, 'b, 'x>> for TrafficSelectorCont0 {
+    type Output = TrafficSelectorTsBodyCombinator;
+
+    open spec fn requires(&self, deps: TrafficSelectorCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_ts_type()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: TrafficSelectorCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_traffic_selector_cont0(deps@)
+    }
+
+    fn apply(&self, deps: TrafficSelectorCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let ts_type_byte = deps;
+                let ts_type_byte = *ts_type_byte;
+                traffic_selector_ts_body(ts_type_byte)
+            }
+            POrSType::S(deps) => {
+                let ts_type_byte = deps;
+                let ts_type_byte = *ts_type_byte;
+                traffic_selector_ts_body(ts_type_byte)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecIkev2TsPayloadInner {
+    pub num_ts: u8,
+    pub reserved: Seq<u8>,
+    pub selectors: Seq<SpecTrafficSelector>,
+}
+
+pub type SpecIkev2TsPayloadInnerInner = (u8, (Seq<u8>, Seq<SpecTrafficSelector>));
+
+
+impl SpecFrom<SpecIkev2TsPayloadInner> for SpecIkev2TsPayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2TsPayloadInner) -> SpecIkev2TsPayloadInnerInner {
+        (m.num_ts, (m.reserved, m.selectors))
+    }
+}
+
+impl SpecFrom<SpecIkev2TsPayloadInnerInner> for SpecIkev2TsPayloadInner {
+    open spec fn spec_from(m: SpecIkev2TsPayloadInnerInner) -> SpecIkev2TsPayloadInner {
+        let (num_ts, (reserved, selectors)) = m;
+        SpecIkev2TsPayloadInner { num_ts, reserved, selectors }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2TsPayloadInner<'a> {
+    pub num_ts: u8,
+    pub reserved: &'a [u8],
+    pub selectors: RepeatResult<TrafficSelector<'a>>,
+}
+
+impl View for Ikev2TsPayloadInner<'_> {
+    type V = SpecIkev2TsPayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2TsPayloadInner {
+            num_ts: self.num_ts@,
+            reserved: self.reserved@,
+            selectors: self.selectors@,
+        }
+    }
+}
+pub type Ikev2TsPayloadInnerInner<'a> = (u8, (&'a [u8], RepeatResult<TrafficSelector<'a>>));
+
+pub type Ikev2TsPayloadInnerInnerRef<'a> = (&'a u8, (&'a &'a [u8], &'a RepeatResult<TrafficSelector<'a>>));
+impl<'a> From<&'a Ikev2TsPayloadInner<'a>> for Ikev2TsPayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2TsPayloadInner) -> Ikev2TsPayloadInnerInnerRef<'a> {
+        (&m.num_ts, (&m.reserved, &m.selectors))
+    }
+}
+
+impl<'a> From<Ikev2TsPayloadInnerInner<'a>> for Ikev2TsPayloadInner<'a> {
+    fn ex_from(m: Ikev2TsPayloadInnerInner) -> Ikev2TsPayloadInner {
+        let (num_ts, (reserved, selectors)) = m;
+        Ikev2TsPayloadInner { num_ts, reserved, selectors }
+    }
+}
+
+pub struct Ikev2TsPayloadInnerMapper;
+impl View for Ikev2TsPayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2TsPayloadInnerMapper {
+    type Src = SpecIkev2TsPayloadInnerInner;
+    type Dst = SpecIkev2TsPayloadInner;
+}
+impl SpecIsoProof for Ikev2TsPayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2TsPayloadInnerMapper {
+    type Src = Ikev2TsPayloadInnerInner<'a>;
+    type Dst = Ikev2TsPayloadInner<'a>;
+    type RefSrc = Ikev2TsPayloadInnerInnerRef<'a>;
+}
+pub spec const SPEC_IKEV2TSPAYLOADINNERRESERVED_CONST: Seq<u8> = seq![0; 3];
+pub struct SpecIkev2TsPayloadInnerCombinator(pub SpecIkev2TsPayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2TsPayloadInnerCombinator {
+    type Type = SpecIkev2TsPayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2TsPayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2TsPayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2TsPayloadInnerCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate3651688686135228051>, (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, AndThen<bytes::Tail, RepeatN<SpecTrafficSelectorCombinator>>)>, Ikev2TsPayloadInnerMapper>;
+pub exec static IKEV2TSPAYLOADINNERRESERVED_CONST: [u8; 3]
+    ensures IKEV2TSPAYLOADINNERRESERVED_CONST@ == SPEC_IKEV2TSPAYLOADINNERRESERVED_CONST,
+{
+    let arr: [u8; 3] = [0; 3];
+    assert(arr@ == SPEC_IKEV2TSPAYLOADINNERRESERVED_CONST);
+    arr
+}
+
+pub struct Ikev2TsPayloadInnerCombinator(pub Ikev2TsPayloadInnerCombinatorAlias);
+
+impl View for Ikev2TsPayloadInnerCombinator {
+    type V = SpecIkev2TsPayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2TsPayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2TsPayloadInnerCombinator {
+    type Type = Ikev2TsPayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::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>;
+
+
+pub open spec fn spec_ikev2_ts_payload_inner() -> SpecIkev2TsPayloadInnerCombinator {
+    SpecIkev2TsPayloadInnerCombinator(
+    Mapped {
+        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate3651688686135228051 }, |deps| spec_ikev2_ts_payload_inner_cont0(deps)),
+        mapper: Ikev2TsPayloadInnerMapper,
+    })
+}
+
+pub open spec fn spec_ikev2_ts_payload_inner_cont0(deps: u8) -> (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, AndThen<bytes::Tail, RepeatN<SpecTrafficSelectorCombinator>>) {
+    let num_ts = deps;
+    (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(SPEC_IKEV2TSPAYLOADINNERRESERVED_CONST) }, AndThen(bytes::Tail, RepeatN(spec_traffic_selector(), (usize::spec_from(num_ts)) as usize)))
+}
+
+impl View for Ikev2TsPayloadInnerCont0 {
+    type V = spec_fn(u8) -> (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, AndThen<bytes::Tail, RepeatN<SpecTrafficSelectorCombinator>>);
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_ikev2_ts_payload_inner_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn ikev2_ts_payload_inner<'a>() -> (o: Ikev2TsPayloadInnerCombinator)
+    ensures o@ == spec_ikev2_ts_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2TsPayloadInnerCombinator(
+    Mapped {
+        inner: Pair::new(Refined { inner: U8, predicate: Predicate3651688686135228051 }, Ikev2TsPayloadInnerCont0),
+        mapper: Ikev2TsPayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_ts_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_ts_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2TsPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_ts_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_ts_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_ts_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_ts_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_ts_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_ts_payload_inner<'a>(v: <Ikev2TsPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_ts_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_ts_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_ts_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_ts_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct Ikev2TsPayloadInnerCont0;
+type Ikev2TsPayloadInnerCont0Type<'a, 'b> = &'b u8;
+type Ikev2TsPayloadInnerCont0SType<'a, 'x> = &'x u8;
+type Ikev2TsPayloadInnerCont0Input<'a, 'b, 'x> = POrSType<Ikev2TsPayloadInnerCont0Type<'a, 'b>, Ikev2TsPayloadInnerCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Ikev2TsPayloadInnerCont0Input<'a, 'b, 'x>> for Ikev2TsPayloadInnerCont0 {
+    type Output = (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, AndThen<bytes::Tail, RepeatN<TrafficSelectorCombinator>>);
+
+    open spec fn requires(&self, deps: Ikev2TsPayloadInnerCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U8, predicate: Predicate3651688686135228051 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: Ikev2TsPayloadInnerCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_ikev2_ts_payload_inner_cont0(deps@)
+    }
+
+    fn apply(&self, deps: Ikev2TsPayloadInnerCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let num_ts = deps;
+                let num_ts = *num_ts;
+                (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(IKEV2TSPAYLOADINNERRESERVED_CONST) }, AndThen(bytes::Tail, RepeatN(traffic_selector(), (usize::ex_from(num_ts)) as usize)))
+            }
+            POrSType::S(deps) => {
+                let num_ts = deps;
+                let num_ts = *num_ts;
+                (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(IKEV2TSPAYLOADINNERRESERVED_CONST) }, AndThen(bytes::Tail, RepeatN(traffic_selector(), (usize::ex_from(num_ts)) as usize)))
+            }
+        }
+    }
+}
+                
+
+pub struct SpecEapSuccessRest {
+    pub identifier: u8,
+    pub eap_length: u16,
+}
+
+pub type SpecEapSuccessRestInner = (u8, u16);
+
+
+impl SpecFrom<SpecEapSuccessRest> for SpecEapSuccessRestInner {
+    open spec fn spec_from(m: SpecEapSuccessRest) -> SpecEapSuccessRestInner {
+        (m.identifier, m.eap_length)
+    }
+}
+
+impl SpecFrom<SpecEapSuccessRestInner> for SpecEapSuccessRest {
+    open spec fn spec_from(m: SpecEapSuccessRestInner) -> SpecEapSuccessRest {
+        let (identifier, eap_length) = m;
+        SpecEapSuccessRest { identifier, eap_length }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct EapSuccessRest {
+    pub identifier: u8,
+    pub eap_length: u16,
+}
+
+impl View for EapSuccessRest {
+    type V = SpecEapSuccessRest;
+
+    open spec fn view(&self) -> Self::V {
+        SpecEapSuccessRest {
+            identifier: self.identifier@,
+            eap_length: self.eap_length@,
+        }
+    }
+}
+pub type EapSuccessRestInner = (u8, u16);
+
+pub type EapSuccessRestInnerRef<'a> = (&'a u8, &'a u16);
+impl<'a> From<&'a EapSuccessRest> for EapSuccessRestInnerRef<'a> {
+    fn ex_from(m: &'a EapSuccessRest) -> EapSuccessRestInnerRef<'a> {
+        (&m.identifier, &m.eap_length)
+    }
+}
+
+impl From<EapSuccessRestInner> for EapSuccessRest {
+    fn ex_from(m: EapSuccessRestInner) -> EapSuccessRest {
+        let (identifier, eap_length) = m;
+        EapSuccessRest { identifier, eap_length }
+    }
+}
+
+pub struct EapSuccessRestMapper;
+impl View for EapSuccessRestMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for EapSuccessRestMapper {
+    type Src = SpecEapSuccessRestInner;
+    type Dst = SpecEapSuccessRest;
+}
+impl SpecIsoProof for EapSuccessRestMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for EapSuccessRestMapper {
+    type Src = EapSuccessRestInner;
+    type Dst = EapSuccessRest;
+    type RefSrc = EapSuccessRestInnerRef<'a>;
+}
+pub const EAPSUCCESSRESTEAP_LENGTH_CONST: u16 = 4;
+type SpecEapSuccessRestCombinatorAlias1 = (U8, Refined<U16Be, TagPred<u16>>);
+pub struct SpecEapSuccessRestCombinator(pub SpecEapSuccessRestCombinatorAlias);
+
+impl SpecCombinator for SpecEapSuccessRestCombinator {
+    type Type = SpecEapSuccessRest;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecEapSuccessRestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEapSuccessRestCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecEapSuccessRestCombinatorAlias = Mapped<SpecEapSuccessRestCombinatorAlias1, EapSuccessRestMapper>;
+type EapSuccessRestCombinatorAlias1 = (U8, Refined<U16Be, TagPred<u16>>);
+pub struct EapSuccessRestCombinator1(pub EapSuccessRestCombinatorAlias1);
+impl View for EapSuccessRestCombinator1 {
+    type V = SpecEapSuccessRestCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(EapSuccessRestCombinator1, EapSuccessRestCombinatorAlias1);
+
+pub struct EapSuccessRestCombinator(pub EapSuccessRestCombinatorAlias);
+
+impl View for EapSuccessRestCombinator {
+    type V = SpecEapSuccessRestCombinator;
+    open spec fn view(&self) -> Self::V { SpecEapSuccessRestCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapSuccessRestCombinator {
+    type Type = EapSuccessRest;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type EapSuccessRestCombinatorAlias = Mapped<EapSuccessRestCombinator1, EapSuccessRestMapper>;
+
+
+pub open spec fn spec_eap_success_rest() -> SpecEapSuccessRestCombinator {
+    SpecEapSuccessRestCombinator(
+    Mapped {
+        inner: (U8, Refined { inner: U16Be, predicate: TagPred(EAPSUCCESSRESTEAP_LENGTH_CONST) }),
+        mapper: EapSuccessRestMapper,
+    })
+}
+
+                
+pub fn eap_success_rest<'a>() -> (o: EapSuccessRestCombinator)
+    ensures o@ == spec_eap_success_rest(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = EapSuccessRestCombinator(
+    Mapped {
+        inner: EapSuccessRestCombinator1((U8, Refined { inner: U16Be, predicate: TagPred(EAPSUCCESSRESTEAP_LENGTH_CONST) })),
+        mapper: EapSuccessRestMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_eap_success_rest()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_eap_success_rest<'a>(input: &'a [u8]) -> (res: PResult<<EapSuccessRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_eap_success_rest().spec_parse(input@) == Some((n as int, v@)),
+        spec_eap_success_rest().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_eap_success_rest().spec_parse(input@) is None,
+        spec_eap_success_rest().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = eap_success_rest();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_eap_success_rest<'a>(v: <EapSuccessRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_success_rest().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_eap_success_rest().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_eap_success_rest().spec_serialize(v@).len(),
+{
+    let combinator = eap_success_rest();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub type SpecIpsecSpiSizeOrNone = u8;
+pub type IpsecSpiSizeOrNone = u8;
+pub type IpsecSpiSizeOrNoneRef<'a> = &'a u8;
+
+
+pub struct SpecIpsecSpiSizeOrNoneCombinator(pub SpecIpsecSpiSizeOrNoneCombinatorAlias);
+
+impl SpecCombinator for SpecIpsecSpiSizeOrNoneCombinator {
+    type Type = SpecIpsecSpiSizeOrNone;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIpsecSpiSizeOrNoneCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIpsecSpiSizeOrNoneCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIpsecSpiSizeOrNoneCombinatorAlias = Refined<U8, Predicate15445621259281350129>;
+pub struct Predicate15445621259281350129;
+impl View for Predicate15445621259281350129 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate15445621259281350129 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 0) || (i == 4)
+    }
+}
+impl SpecPred<u8> for Predicate15445621259281350129 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 0) || (i == 4)
+    }
+}
+
+pub struct IpsecSpiSizeOrNoneCombinator(pub IpsecSpiSizeOrNoneCombinatorAlias);
+
+impl View for IpsecSpiSizeOrNoneCombinator {
+    type V = SpecIpsecSpiSizeOrNoneCombinator;
+    open spec fn view(&self) -> Self::V { SpecIpsecSpiSizeOrNoneCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IpsecSpiSizeOrNoneCombinator {
+    type Type = IpsecSpiSizeOrNone;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type IpsecSpiSizeOrNoneCombinatorAlias = Refined<U8, Predicate15445621259281350129>;
+
+
+pub open spec fn spec_ipsec_spi_size_or_none() -> SpecIpsecSpiSizeOrNoneCombinator {
+    SpecIpsecSpiSizeOrNoneCombinator(Refined { inner: U8, predicate: Predicate15445621259281350129 })
+}
+
+                
+pub fn ipsec_spi_size_or_none<'a>() -> (o: IpsecSpiSizeOrNoneCombinator)
+    ensures o@ == spec_ipsec_spi_size_or_none(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = IpsecSpiSizeOrNoneCombinator(Refined { inner: U8, predicate: Predicate15445621259281350129 });
+    // assert({
+    //     &&& combinator@ == spec_ipsec_spi_size_or_none()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ipsec_spi_size_or_none<'a>(input: &'a [u8]) -> (res: PResult<<IpsecSpiSizeOrNoneCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ipsec_spi_size_or_none().spec_parse(input@) == Some((n as int, v@)),
+        spec_ipsec_spi_size_or_none().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ipsec_spi_size_or_none().spec_parse(input@) is None,
+        spec_ipsec_spi_size_or_none().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ipsec_spi_size_or_none();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ipsec_spi_size_or_none<'a>(v: <IpsecSpiSizeOrNoneCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ipsec_spi_size_or_none().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ipsec_spi_size_or_none().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ipsec_spi_size_or_none().spec_serialize(v@).len(),
+{
+    let combinator = ipsec_spi_size_or_none();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub mod EapCode {
+    use super::*;
+    pub spec const SPEC_Request: u8 = 1;
+    pub spec const SPEC_Response: u8 = 2;
+    pub spec const SPEC_Success: u8 = 3;
+    pub spec const SPEC_Failure: u8 = 4;
+    pub exec const Request: u8 ensures Request == SPEC_Request { 1 }
+    pub exec const Response: u8 ensures Response == SPEC_Response { 2 }
+    pub exec const Success: u8 ensures Success == SPEC_Success { 3 }
+    pub exec const Failure: u8 ensures Failure == SPEC_Failure { 4 }
+}
+
+
+pub struct SpecEapCodeCombinator(pub SpecEapCodeCombinatorAlias);
+
+impl SpecCombinator for SpecEapCodeCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecEapCodeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEapCodeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecEapCodeCombinatorAlias = U8;
+
+pub struct EapCodeCombinator(pub EapCodeCombinatorAlias);
+
+impl View for EapCodeCombinator {
+    type V = SpecEapCodeCombinator;
+    open spec fn view(&self) -> Self::V { SpecEapCodeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapCodeCombinator {
+    type Type = u8;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type EapCodeCombinatorAlias = U8;
+
+
+pub open spec fn spec_eap_code() -> SpecEapCodeCombinator {
+    SpecEapCodeCombinator(U8)
+}
+
+                
+pub fn eap_code<'a>() -> (o: EapCodeCombinator)
+    ensures o@ == spec_eap_code(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = EapCodeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_eap_code()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_eap_code<'a>(input: &'a [u8]) -> (res: PResult<<EapCodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_eap_code().spec_parse(input@) == Some((n as int, v@)),
+        spec_eap_code().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_eap_code().spec_parse(input@) is None,
+        spec_eap_code().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = eap_code();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_eap_code<'a>(v: <EapCodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_code().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_eap_code().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_eap_code().spec_serialize(v@).len(),
+{
+    let combinator = eap_code();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecEapFailureRest {
+    pub identifier: u8,
+    pub eap_length: u16,
+}
+
+pub type SpecEapFailureRestInner = (u8, u16);
+
+
+impl SpecFrom<SpecEapFailureRest> for SpecEapFailureRestInner {
+    open spec fn spec_from(m: SpecEapFailureRest) -> SpecEapFailureRestInner {
+        (m.identifier, m.eap_length)
+    }
+}
+
+impl SpecFrom<SpecEapFailureRestInner> for SpecEapFailureRest {
+    open spec fn spec_from(m: SpecEapFailureRestInner) -> SpecEapFailureRest {
+        let (identifier, eap_length) = m;
+        SpecEapFailureRest { identifier, eap_length }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct EapFailureRest {
+    pub identifier: u8,
+    pub eap_length: u16,
+}
+
+impl View for EapFailureRest {
+    type V = SpecEapFailureRest;
+
+    open spec fn view(&self) -> Self::V {
+        SpecEapFailureRest {
+            identifier: self.identifier@,
+            eap_length: self.eap_length@,
+        }
+    }
+}
+pub type EapFailureRestInner = (u8, u16);
+
+pub type EapFailureRestInnerRef<'a> = (&'a u8, &'a u16);
+impl<'a> From<&'a EapFailureRest> for EapFailureRestInnerRef<'a> {
+    fn ex_from(m: &'a EapFailureRest) -> EapFailureRestInnerRef<'a> {
+        (&m.identifier, &m.eap_length)
+    }
+}
+
+impl From<EapFailureRestInner> for EapFailureRest {
+    fn ex_from(m: EapFailureRestInner) -> EapFailureRest {
+        let (identifier, eap_length) = m;
+        EapFailureRest { identifier, eap_length }
+    }
+}
+
+pub struct EapFailureRestMapper;
+impl View for EapFailureRestMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for EapFailureRestMapper {
+    type Src = SpecEapFailureRestInner;
+    type Dst = SpecEapFailureRest;
+}
+impl SpecIsoProof for EapFailureRestMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for EapFailureRestMapper {
+    type Src = EapFailureRestInner;
+    type Dst = EapFailureRest;
+    type RefSrc = EapFailureRestInnerRef<'a>;
+}
+pub const EAPFAILURERESTEAP_LENGTH_CONST: u16 = 4;
+type SpecEapFailureRestCombinatorAlias1 = (U8, Refined<U16Be, TagPred<u16>>);
+pub struct SpecEapFailureRestCombinator(pub SpecEapFailureRestCombinatorAlias);
+
+impl SpecCombinator for SpecEapFailureRestCombinator {
+    type Type = SpecEapFailureRest;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecEapFailureRestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEapFailureRestCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecEapFailureRestCombinatorAlias = Mapped<SpecEapFailureRestCombinatorAlias1, EapFailureRestMapper>;
+type EapFailureRestCombinatorAlias1 = (U8, Refined<U16Be, TagPred<u16>>);
+pub struct EapFailureRestCombinator1(pub EapFailureRestCombinatorAlias1);
+impl View for EapFailureRestCombinator1 {
+    type V = SpecEapFailureRestCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(EapFailureRestCombinator1, EapFailureRestCombinatorAlias1);
+
+pub struct EapFailureRestCombinator(pub EapFailureRestCombinatorAlias);
+
+impl View for EapFailureRestCombinator {
+    type V = SpecEapFailureRestCombinator;
+    open spec fn view(&self) -> Self::V { SpecEapFailureRestCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapFailureRestCombinator {
+    type Type = EapFailureRest;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type EapFailureRestCombinatorAlias = Mapped<EapFailureRestCombinator1, EapFailureRestMapper>;
+
+
+pub open spec fn spec_eap_failure_rest() -> SpecEapFailureRestCombinator {
+    SpecEapFailureRestCombinator(
+    Mapped {
+        inner: (U8, Refined { inner: U16Be, predicate: TagPred(EAPFAILURERESTEAP_LENGTH_CONST) }),
+        mapper: EapFailureRestMapper,
+    })
+}
+
+                
+pub fn eap_failure_rest<'a>() -> (o: EapFailureRestCombinator)
+    ensures o@ == spec_eap_failure_rest(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = EapFailureRestCombinator(
+    Mapped {
+        inner: EapFailureRestCombinator1((U8, Refined { inner: U16Be, predicate: TagPred(EAPFAILURERESTEAP_LENGTH_CONST) })),
+        mapper: EapFailureRestMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_eap_failure_rest()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_eap_failure_rest<'a>(input: &'a [u8]) -> (res: PResult<<EapFailureRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_eap_failure_rest().spec_parse(input@) == Some((n as int, v@)),
+        spec_eap_failure_rest().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_eap_failure_rest().spec_parse(input@) is None,
+        spec_eap_failure_rest().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = eap_failure_rest();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_eap_failure_rest<'a>(v: <EapFailureRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_failure_rest().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_eap_failure_rest().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_eap_failure_rest().spec_serialize(v@).len(),
+{
+    let combinator = eap_failure_rest();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecEapReqRespRest {
+    pub identifier: u8,
+    pub eap_length: u16,
+    pub eap_type: u8,
+    pub type_data: Seq<u8>,
+}
+
+pub type SpecEapReqRespRestInner = ((u8, u16), (u8, Seq<u8>));
+
+
+impl SpecFrom<SpecEapReqRespRest> for SpecEapReqRespRestInner {
+    open spec fn spec_from(m: SpecEapReqRespRest) -> SpecEapReqRespRestInner {
+        ((m.identifier, m.eap_length), (m.eap_type, m.type_data))
+    }
+}
+
+impl SpecFrom<SpecEapReqRespRestInner> for SpecEapReqRespRest {
+    open spec fn spec_from(m: SpecEapReqRespRestInner) -> SpecEapReqRespRest {
+        let ((identifier, eap_length), (eap_type, type_data)) = m;
+        SpecEapReqRespRest { identifier, eap_length, eap_type, type_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct EapReqRespRest<'a> {
+    pub identifier: u8,
+    pub eap_length: u16,
+    pub eap_type: u8,
+    pub type_data: &'a [u8],
+}
+
+impl View for EapReqRespRest<'_> {
+    type V = SpecEapReqRespRest;
+
+    open spec fn view(&self) -> Self::V {
+        SpecEapReqRespRest {
+            identifier: self.identifier@,
+            eap_length: self.eap_length@,
+            eap_type: self.eap_type@,
+            type_data: self.type_data@,
+        }
+    }
+}
+pub type EapReqRespRestInner<'a> = ((u8, u16), (u8, &'a [u8]));
+
+pub type EapReqRespRestInnerRef<'a> = ((&'a u8, &'a u16), (&'a u8, &'a &'a [u8]));
+impl<'a> From<&'a EapReqRespRest<'a>> for EapReqRespRestInnerRef<'a> {
+    fn ex_from(m: &'a EapReqRespRest) -> EapReqRespRestInnerRef<'a> {
+        ((&m.identifier, &m.eap_length), (&m.eap_type, &m.type_data))
+    }
+}
+
+impl<'a> From<EapReqRespRestInner<'a>> for EapReqRespRest<'a> {
+    fn ex_from(m: EapReqRespRestInner) -> EapReqRespRest {
+        let ((identifier, eap_length), (eap_type, type_data)) = m;
+        EapReqRespRest { identifier, eap_length, eap_type, type_data }
+    }
+}
+
+pub struct EapReqRespRestMapper;
+impl View for EapReqRespRestMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for EapReqRespRestMapper {
+    type Src = SpecEapReqRespRestInner;
+    type Dst = SpecEapReqRespRest;
+}
+impl SpecIsoProof for EapReqRespRestMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for EapReqRespRestMapper {
+    type Src = EapReqRespRestInner<'a>;
+    type Dst = EapReqRespRest<'a>;
+    type RefSrc = EapReqRespRestInnerRef<'a>;
+}
+
+pub struct SpecEapReqRespRestCombinator(pub SpecEapReqRespRestCombinatorAlias);
+
+impl SpecCombinator for SpecEapReqRespRestCombinator {
+    type Type = SpecEapReqRespRest;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecEapReqRespRestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEapReqRespRestCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecEapReqRespRestCombinatorAlias = Mapped<SpecPair<(U8, Refined<U16Be, Predicate7010197279221949030>), (U8, bytes::Variable)>, EapReqRespRestMapper>;
+pub struct Predicate7010197279221949030;
+impl View for Predicate7010197279221949030 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate7010197279221949030 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 5 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate7010197279221949030 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 5 && i <= 65535)
+    }
+}
+
+pub struct EapReqRespRestCombinator(pub EapReqRespRestCombinatorAlias);
+
+impl View for EapReqRespRestCombinator {
+    type V = SpecEapReqRespRestCombinator;
+    open spec fn view(&self) -> Self::V { SpecEapReqRespRestCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapReqRespRestCombinator {
+    type Type = EapReqRespRest<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type EapReqRespRestCombinatorAlias = Mapped<Pair<(U8, Refined<U16Be, Predicate7010197279221949030>), (U8, bytes::Variable), EapReqRespRestCont0>, EapReqRespRestMapper>;
+
+
+pub open spec fn spec_eap_req_resp_rest() -> SpecEapReqRespRestCombinator {
+    SpecEapReqRespRestCombinator(
+    Mapped {
+        inner: Pair::spec_new((U8, Refined { inner: U16Be, predicate: Predicate7010197279221949030 }), |deps| spec_eap_req_resp_rest_cont0(deps)),
+        mapper: EapReqRespRestMapper,
+    })
+}
+
+pub open spec fn spec_eap_req_resp_rest_cont0(deps: (u8, u16)) -> (U8, bytes::Variable) {
+    let (_, eap_length) = deps;
+    (U8, bytes::Variable(((usize::spec_from(eap_length) - 5)) as usize))
+}
+
+impl View for EapReqRespRestCont0 {
+    type V = spec_fn((u8, u16)) -> (U8, bytes::Variable);
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u8, u16)| {
+            spec_eap_req_resp_rest_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn eap_req_resp_rest<'a>() -> (o: EapReqRespRestCombinator)
+    ensures o@ == spec_eap_req_resp_rest(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = EapReqRespRestCombinator(
+    Mapped {
+        inner: Pair::new((U8, Refined { inner: U16Be, predicate: Predicate7010197279221949030 }), EapReqRespRestCont0),
+        mapper: EapReqRespRestMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_eap_req_resp_rest()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_eap_req_resp_rest<'a>(input: &'a [u8]) -> (res: PResult<<EapReqRespRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_eap_req_resp_rest().spec_parse(input@) == Some((n as int, v@)),
+        spec_eap_req_resp_rest().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_eap_req_resp_rest().spec_parse(input@) is None,
+        spec_eap_req_resp_rest().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = eap_req_resp_rest();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_eap_req_resp_rest<'a>(v: <EapReqRespRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_req_resp_rest().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_eap_req_resp_rest().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_eap_req_resp_rest().spec_serialize(v@).len(),
+{
+    let combinator = eap_req_resp_rest();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct EapReqRespRestCont0;
+type EapReqRespRestCont0Type<'a, 'b> = &'b (u8, u16);
+type EapReqRespRestCont0SType<'a, 'x> = (&'x u8, &'x u16);
+type EapReqRespRestCont0Input<'a, 'b, 'x> = POrSType<EapReqRespRestCont0Type<'a, 'b>, EapReqRespRestCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<EapReqRespRestCont0Input<'a, 'b, 'x>> for EapReqRespRestCont0 {
+    type Output = (U8, bytes::Variable);
+
+    open spec fn requires(&self, deps: EapReqRespRestCont0Input<'a, 'b, 'x>) -> bool {
+        &&& ((U8, Refined { inner: U16Be, predicate: Predicate7010197279221949030 })).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: EapReqRespRestCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_eap_req_resp_rest_cont0(deps@)
+    }
+
+    fn apply(&self, deps: EapReqRespRestCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (_, eap_length) = deps;
+                let eap_length = *eap_length;
+                (U8, bytes::Variable(((usize::ex_from(eap_length) - 5)) as usize))
+            }
+            POrSType::S(deps) => {
+                let (_, eap_length) = deps;
+                let eap_length = *eap_length;
+                (U8, bytes::Variable(((usize::ex_from(eap_length) - 5)) as usize))
+            }
+        }
+    }
+}
+                
+
+pub enum SpecIkev2EapPayloadInnerEapRest {
+    Success(SpecEapSuccessRest),
+    Failure(SpecEapFailureRest),
+    Request(SpecEapReqRespRest),
+    Response(SpecEapReqRespRest),
+}
+
+pub type SpecIkev2EapPayloadInnerEapRestInner = Either<SpecEapSuccessRest, Either<SpecEapFailureRest, Either<SpecEapReqRespRest, SpecEapReqRespRest>>>;
+
+impl SpecFrom<SpecIkev2EapPayloadInnerEapRest> for SpecIkev2EapPayloadInnerEapRestInner {
+    open spec fn spec_from(m: SpecIkev2EapPayloadInnerEapRest) -> SpecIkev2EapPayloadInnerEapRestInner {
+        match m {
+            SpecIkev2EapPayloadInnerEapRest::Success(m) => Either::Left(m),
+            SpecIkev2EapPayloadInnerEapRest::Failure(m) => Either::Right(Either::Left(m)),
+            SpecIkev2EapPayloadInnerEapRest::Request(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecIkev2EapPayloadInnerEapRest::Response(m) => Either::Right(Either::Right(Either::Right(m))),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecIkev2EapPayloadInnerEapRestInner> for SpecIkev2EapPayloadInnerEapRest {
+    open spec fn spec_from(m: SpecIkev2EapPayloadInnerEapRestInner) -> SpecIkev2EapPayloadInnerEapRest {
+        match m {
+            Either::Left(m) => SpecIkev2EapPayloadInnerEapRest::Success(m),
+            Either::Right(Either::Left(m)) => SpecIkev2EapPayloadInnerEapRest::Failure(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecIkev2EapPayloadInnerEapRest::Request(m),
+            Either::Right(Either::Right(Either::Right(m))) => SpecIkev2EapPayloadInnerEapRest::Response(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Ikev2EapPayloadInnerEapRest<'a> {
+    Success(EapSuccessRest),
+    Failure(EapFailureRest),
+    Request(EapReqRespRest<'a>),
+    Response(EapReqRespRest<'a>),
+}
+
+pub type Ikev2EapPayloadInnerEapRestInner<'a> = Either<EapSuccessRest, Either<EapFailureRest, Either<EapReqRespRest<'a>, EapReqRespRest<'a>>>>;
+
+pub type Ikev2EapPayloadInnerEapRestInnerRef<'a> = Either<&'a EapSuccessRest, Either<&'a EapFailureRest, Either<&'a EapReqRespRest<'a>, &'a EapReqRespRest<'a>>>>;
+
+
+impl<'a> View for Ikev2EapPayloadInnerEapRest<'a> {
+    type V = SpecIkev2EapPayloadInnerEapRest;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            Ikev2EapPayloadInnerEapRest::Success(m) => SpecIkev2EapPayloadInnerEapRest::Success(m@),
+            Ikev2EapPayloadInnerEapRest::Failure(m) => SpecIkev2EapPayloadInnerEapRest::Failure(m@),
+            Ikev2EapPayloadInnerEapRest::Request(m) => SpecIkev2EapPayloadInnerEapRest::Request(m@),
+            Ikev2EapPayloadInnerEapRest::Response(m) => SpecIkev2EapPayloadInnerEapRest::Response(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a Ikev2EapPayloadInnerEapRest<'a>> for Ikev2EapPayloadInnerEapRestInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2EapPayloadInnerEapRest<'a>) -> Ikev2EapPayloadInnerEapRestInnerRef<'a> {
+        match m {
+            Ikev2EapPayloadInnerEapRest::Success(m) => Either::Left(m),
+            Ikev2EapPayloadInnerEapRest::Failure(m) => Either::Right(Either::Left(m)),
+            Ikev2EapPayloadInnerEapRest::Request(m) => Either::Right(Either::Right(Either::Left(m))),
+            Ikev2EapPayloadInnerEapRest::Response(m) => Either::Right(Either::Right(Either::Right(m))),
+        }
+    }
+
+}
+
+impl<'a> From<Ikev2EapPayloadInnerEapRestInner<'a>> for Ikev2EapPayloadInnerEapRest<'a> {
+    fn ex_from(m: Ikev2EapPayloadInnerEapRestInner<'a>) -> Ikev2EapPayloadInnerEapRest<'a> {
+        match m {
+            Either::Left(m) => Ikev2EapPayloadInnerEapRest::Success(m),
+            Either::Right(Either::Left(m)) => Ikev2EapPayloadInnerEapRest::Failure(m),
+            Either::Right(Either::Right(Either::Left(m))) => Ikev2EapPayloadInnerEapRest::Request(m),
+            Either::Right(Either::Right(Either::Right(m))) => Ikev2EapPayloadInnerEapRest::Response(m),
+        }
+    }
+    
+}
+
+
+pub struct Ikev2EapPayloadInnerEapRestMapper;
+impl View for Ikev2EapPayloadInnerEapRestMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2EapPayloadInnerEapRestMapper {
+    type Src = SpecIkev2EapPayloadInnerEapRestInner;
+    type Dst = SpecIkev2EapPayloadInnerEapRest;
+}
+impl SpecIsoProof for Ikev2EapPayloadInnerEapRestMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2EapPayloadInnerEapRestMapper {
+    type Src = Ikev2EapPayloadInnerEapRestInner<'a>;
+    type Dst = Ikev2EapPayloadInnerEapRest<'a>;
+    type RefSrc = Ikev2EapPayloadInnerEapRestInnerRef<'a>;
+}
+
+type SpecIkev2EapPayloadInnerEapRestCombinatorAlias1 = Choice<Cond<SpecEapReqRespRestCombinator>, Cond<SpecEapReqRespRestCombinator>>;
+type SpecIkev2EapPayloadInnerEapRestCombinatorAlias2 = Choice<Cond<SpecEapFailureRestCombinator>, SpecIkev2EapPayloadInnerEapRestCombinatorAlias1>;
+type SpecIkev2EapPayloadInnerEapRestCombinatorAlias3 = Choice<Cond<SpecEapSuccessRestCombinator>, SpecIkev2EapPayloadInnerEapRestCombinatorAlias2>;
+pub struct SpecIkev2EapPayloadInnerEapRestCombinator(pub SpecIkev2EapPayloadInnerEapRestCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2EapPayloadInnerEapRestCombinator {
+    type Type = SpecIkev2EapPayloadInnerEapRest;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2EapPayloadInnerEapRestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2EapPayloadInnerEapRestCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2EapPayloadInnerEapRestCombinatorAlias = Mapped<SpecIkev2EapPayloadInnerEapRestCombinatorAlias3, Ikev2EapPayloadInnerEapRestMapper>;
+type Ikev2EapPayloadInnerEapRestCombinatorAlias1 = Choice<Cond<EapReqRespRestCombinator>, Cond<EapReqRespRestCombinator>>;
+type Ikev2EapPayloadInnerEapRestCombinatorAlias2 = Choice<Cond<EapFailureRestCombinator>, Ikev2EapPayloadInnerEapRestCombinator1>;
+type Ikev2EapPayloadInnerEapRestCombinatorAlias3 = Choice<Cond<EapSuccessRestCombinator>, Ikev2EapPayloadInnerEapRestCombinator2>;
+pub struct Ikev2EapPayloadInnerEapRestCombinator1(pub Ikev2EapPayloadInnerEapRestCombinatorAlias1);
+impl View for Ikev2EapPayloadInnerEapRestCombinator1 {
+    type V = SpecIkev2EapPayloadInnerEapRestCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2EapPayloadInnerEapRestCombinator1, Ikev2EapPayloadInnerEapRestCombinatorAlias1);
+
+pub struct Ikev2EapPayloadInnerEapRestCombinator2(pub Ikev2EapPayloadInnerEapRestCombinatorAlias2);
+impl View for Ikev2EapPayloadInnerEapRestCombinator2 {
+    type V = SpecIkev2EapPayloadInnerEapRestCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2EapPayloadInnerEapRestCombinator2, Ikev2EapPayloadInnerEapRestCombinatorAlias2);
+
+pub struct Ikev2EapPayloadInnerEapRestCombinator3(pub Ikev2EapPayloadInnerEapRestCombinatorAlias3);
+impl View for Ikev2EapPayloadInnerEapRestCombinator3 {
+    type V = SpecIkev2EapPayloadInnerEapRestCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2EapPayloadInnerEapRestCombinator3, Ikev2EapPayloadInnerEapRestCombinatorAlias3);
+
+pub struct Ikev2EapPayloadInnerEapRestCombinator(pub Ikev2EapPayloadInnerEapRestCombinatorAlias);
+
+impl View for Ikev2EapPayloadInnerEapRestCombinator {
+    type V = SpecIkev2EapPayloadInnerEapRestCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2EapPayloadInnerEapRestCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2EapPayloadInnerEapRestCombinator {
+    type Type = Ikev2EapPayloadInnerEapRest<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2EapPayloadInnerEapRestCombinatorAlias = Mapped<Ikev2EapPayloadInnerEapRestCombinator3, Ikev2EapPayloadInnerEapRestMapper>;
+
+
+pub open spec fn spec_ikev2_eap_payload_inner_eap_rest(code: u8) -> SpecIkev2EapPayloadInnerEapRestCombinator {
+    SpecIkev2EapPayloadInnerEapRestCombinator(Mapped { inner: Choice(Cond { cond: code == EapCode::SPEC_Success, inner: spec_eap_success_rest() }, Choice(Cond { cond: code == EapCode::SPEC_Failure, inner: spec_eap_failure_rest() }, Choice(Cond { cond: code == EapCode::SPEC_Request, inner: spec_eap_req_resp_rest() }, Cond { cond: code == EapCode::SPEC_Response, inner: spec_eap_req_resp_rest() }))), mapper: Ikev2EapPayloadInnerEapRestMapper })
+}
+
+pub fn ikev2_eap_payload_inner_eap_rest<'a>(code: u8) -> (o: Ikev2EapPayloadInnerEapRestCombinator)
+    requires
+        spec_eap_code().wf(code@),
+
+    ensures o@ == spec_ikev2_eap_payload_inner_eap_rest(code@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2EapPayloadInnerEapRestCombinator(Mapped { inner: Ikev2EapPayloadInnerEapRestCombinator3(Choice::new(Cond { cond: code == EapCode::Success, inner: eap_success_rest() }, Ikev2EapPayloadInnerEapRestCombinator2(Choice::new(Cond { cond: code == EapCode::Failure, inner: eap_failure_rest() }, Ikev2EapPayloadInnerEapRestCombinator1(Choice::new(Cond { cond: code == EapCode::Request, inner: eap_req_resp_rest() }, Cond { cond: code == EapCode::Response, inner: eap_req_resp_rest() })))))), mapper: Ikev2EapPayloadInnerEapRestMapper });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_eap_payload_inner_eap_rest(code@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_eap_payload_inner_eap_rest<'a>(input: &'a [u8], code: u8) -> (res: PResult<<Ikev2EapPayloadInnerEapRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_eap_code().wf(code@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_eap_payload_inner_eap_rest(code@).spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_eap_payload_inner_eap_rest(code@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_eap_payload_inner_eap_rest(code@).spec_parse(input@) is None,
+        spec_ikev2_eap_payload_inner_eap_rest(code@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_eap_payload_inner_eap_rest( code );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_eap_payload_inner_eap_rest<'a>(v: <Ikev2EapPayloadInnerEapRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, code: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_eap_payload_inner_eap_rest(code@).wf(v@),
+        spec_eap_code().wf(code@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_ikev2_eap_payload_inner_eap_rest(code@).spec_serialize(v@).len() <= usize::MAX,
+        spec_eap_code().wf(code@),
+
+    ensures
+        serialize_len == spec_ikev2_eap_payload_inner_eap_rest(code@).spec_serialize(v@).len(),
+{
+    let combinator = ikev2_eap_payload_inner_eap_rest( code );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecIkev2EapPayloadInner {
+    pub code: u8,
+    pub eap_rest: SpecIkev2EapPayloadInnerEapRest,
+}
+
+pub type SpecIkev2EapPayloadInnerInner = (u8, SpecIkev2EapPayloadInnerEapRest);
+
+
+impl SpecFrom<SpecIkev2EapPayloadInner> for SpecIkev2EapPayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2EapPayloadInner) -> SpecIkev2EapPayloadInnerInner {
+        (m.code, m.eap_rest)
+    }
+}
+
+impl SpecFrom<SpecIkev2EapPayloadInnerInner> for SpecIkev2EapPayloadInner {
+    open spec fn spec_from(m: SpecIkev2EapPayloadInnerInner) -> SpecIkev2EapPayloadInner {
+        let (code, eap_rest) = m;
+        SpecIkev2EapPayloadInner { code, eap_rest }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2EapPayloadInner<'a> {
+    pub code: u8,
+    pub eap_rest: Ikev2EapPayloadInnerEapRest<'a>,
+}
+
+impl View for Ikev2EapPayloadInner<'_> {
+    type V = SpecIkev2EapPayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2EapPayloadInner {
+            code: self.code@,
+            eap_rest: self.eap_rest@,
+        }
+    }
+}
+pub type Ikev2EapPayloadInnerInner<'a> = (u8, Ikev2EapPayloadInnerEapRest<'a>);
+
+pub type Ikev2EapPayloadInnerInnerRef<'a> = (&'a u8, &'a Ikev2EapPayloadInnerEapRest<'a>);
+impl<'a> From<&'a Ikev2EapPayloadInner<'a>> for Ikev2EapPayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2EapPayloadInner) -> Ikev2EapPayloadInnerInnerRef<'a> {
+        (&m.code, &m.eap_rest)
+    }
+}
+
+impl<'a> From<Ikev2EapPayloadInnerInner<'a>> for Ikev2EapPayloadInner<'a> {
+    fn ex_from(m: Ikev2EapPayloadInnerInner) -> Ikev2EapPayloadInner {
+        let (code, eap_rest) = m;
+        Ikev2EapPayloadInner { code, eap_rest }
+    }
+}
+
+pub struct Ikev2EapPayloadInnerMapper;
+impl View for Ikev2EapPayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2EapPayloadInnerMapper {
+    type Src = SpecIkev2EapPayloadInnerInner;
+    type Dst = SpecIkev2EapPayloadInner;
+}
+impl SpecIsoProof for Ikev2EapPayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2EapPayloadInnerMapper {
+    type Src = Ikev2EapPayloadInnerInner<'a>;
+    type Dst = Ikev2EapPayloadInner<'a>;
+    type RefSrc = Ikev2EapPayloadInnerInnerRef<'a>;
+}
+
+pub struct SpecIkev2EapPayloadInnerCombinator(pub SpecIkev2EapPayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2EapPayloadInnerCombinator {
+    type Type = SpecIkev2EapPayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2EapPayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2EapPayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2EapPayloadInnerCombinatorAlias = Mapped<SpecPair<SpecEapCodeCombinator, SpecIkev2EapPayloadInnerEapRestCombinator>, Ikev2EapPayloadInnerMapper>;
+
+pub struct Ikev2EapPayloadInnerCombinator(pub Ikev2EapPayloadInnerCombinatorAlias);
+
+impl View for Ikev2EapPayloadInnerCombinator {
+    type V = SpecIkev2EapPayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2EapPayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2EapPayloadInnerCombinator {
+    type Type = Ikev2EapPayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2EapPayloadInnerCombinatorAlias = Mapped<Pair<EapCodeCombinator, Ikev2EapPayloadInnerEapRestCombinator, Ikev2EapPayloadInnerCont0>, Ikev2EapPayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_eap_payload_inner() -> SpecIkev2EapPayloadInnerCombinator {
+    SpecIkev2EapPayloadInnerCombinator(
+    Mapped {
+        inner: Pair::spec_new(spec_eap_code(), |deps| spec_ikev2_eap_payload_inner_cont0(deps)),
+        mapper: Ikev2EapPayloadInnerMapper,
+    })
+}
+
+pub open spec fn spec_ikev2_eap_payload_inner_cont0(deps: u8) -> SpecIkev2EapPayloadInnerEapRestCombinator {
+    let code = deps;
+    spec_ikev2_eap_payload_inner_eap_rest(code)
+}
+
+impl View for Ikev2EapPayloadInnerCont0 {
+    type V = spec_fn(u8) -> SpecIkev2EapPayloadInnerEapRestCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_ikev2_eap_payload_inner_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn ikev2_eap_payload_inner<'a>() -> (o: Ikev2EapPayloadInnerCombinator)
+    ensures o@ == spec_ikev2_eap_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2EapPayloadInnerCombinator(
+    Mapped {
+        inner: Pair::new(eap_code(), Ikev2EapPayloadInnerCont0),
+        mapper: Ikev2EapPayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_eap_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_eap_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2EapPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_eap_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_eap_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_eap_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_eap_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_eap_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_eap_payload_inner<'a>(v: <Ikev2EapPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_eap_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_eap_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_eap_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_eap_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct Ikev2EapPayloadInnerCont0;
+type Ikev2EapPayloadInnerCont0Type<'a, 'b> = &'b u8;
+type Ikev2EapPayloadInnerCont0SType<'a, 'x> = &'x u8;
+type Ikev2EapPayloadInnerCont0Input<'a, 'b, 'x> = POrSType<Ikev2EapPayloadInnerCont0Type<'a, 'b>, Ikev2EapPayloadInnerCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Ikev2EapPayloadInnerCont0Input<'a, 'b, 'x>> for Ikev2EapPayloadInnerCont0 {
+    type Output = Ikev2EapPayloadInnerEapRestCombinator;
+
+    open spec fn requires(&self, deps: Ikev2EapPayloadInnerCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_eap_code()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: Ikev2EapPayloadInnerCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_ikev2_eap_payload_inner_cont0(deps@)
+    }
+
+    fn apply(&self, deps: Ikev2EapPayloadInnerCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let code = deps;
+                let code = *code;
+                ikev2_eap_payload_inner_eap_rest(code)
+            }
+            POrSType::S(deps) => {
+                let code = deps;
+                let code = *code;
+                ikev2_eap_payload_inner_eap_rest(code)
+            }
+        }
+    }
+}
+                
+pub mod CertEncoding {
+    use super::*;
+    pub spec const SPEC_PKCS7WrappedX509: u8 = 1;
+    pub spec const SPEC_PGPCert: u8 = 2;
+    pub spec const SPEC_DNSSignedKey: u8 = 3;
+    pub spec const SPEC_X509CertSig: u8 = 4;
+    pub spec const SPEC_KerberosToken: u8 = 6;
+    pub spec const SPEC_CRL: u8 = 7;
+    pub spec const SPEC_ARL: u8 = 8;
+    pub spec const SPEC_SPKICert: u8 = 9;
+    pub spec const SPEC_X509CertAttr: u8 = 10;
+    pub spec const SPEC_RawRSAKey: u8 = 11;
+    pub spec const SPEC_HashAndURLX509: u8 = 12;
+    pub spec const SPEC_HashAndURLBundle: u8 = 13;
+    pub exec const PKCS7WrappedX509: u8 ensures PKCS7WrappedX509 == SPEC_PKCS7WrappedX509 { 1 }
+    pub exec const PGPCert: u8 ensures PGPCert == SPEC_PGPCert { 2 }
+    pub exec const DNSSignedKey: u8 ensures DNSSignedKey == SPEC_DNSSignedKey { 3 }
+    pub exec const X509CertSig: u8 ensures X509CertSig == SPEC_X509CertSig { 4 }
+    pub exec const KerberosToken: u8 ensures KerberosToken == SPEC_KerberosToken { 6 }
+    pub exec const CRL: u8 ensures CRL == SPEC_CRL { 7 }
+    pub exec const ARL: u8 ensures ARL == SPEC_ARL { 8 }
+    pub exec const SPKICert: u8 ensures SPKICert == SPEC_SPKICert { 9 }
+    pub exec const X509CertAttr: u8 ensures X509CertAttr == SPEC_X509CertAttr { 10 }
+    pub exec const RawRSAKey: u8 ensures RawRSAKey == SPEC_RawRSAKey { 11 }
+    pub exec const HashAndURLX509: u8 ensures HashAndURLX509 == SPEC_HashAndURLX509 { 12 }
+    pub exec const HashAndURLBundle: u8 ensures HashAndURLBundle == SPEC_HashAndURLBundle { 13 }
+}
+
+
+pub struct SpecCertEncodingCombinator(pub SpecCertEncodingCombinatorAlias);
+
+impl SpecCombinator for SpecCertEncodingCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCertEncodingCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertEncodingCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCertEncodingCombinatorAlias = U8;
+
+pub struct CertEncodingCombinator(pub CertEncodingCombinatorAlias);
+
+impl View for CertEncodingCombinator {
+    type V = SpecCertEncodingCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertEncodingCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertEncodingCombinator {
+    type Type = u8;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CertEncodingCombinatorAlias = U8;
+
+
+pub open spec fn spec_cert_encoding() -> SpecCertEncodingCombinator {
+    SpecCertEncodingCombinator(U8)
+}
+
+                
+pub fn cert_encoding<'a>() -> (o: CertEncodingCombinator)
+    ensures o@ == spec_cert_encoding(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CertEncodingCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_cert_encoding()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_cert_encoding<'a>(input: &'a [u8]) -> (res: PResult<<CertEncodingCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_cert_encoding().spec_parse(input@) == Some((n as int, v@)),
+        spec_cert_encoding().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_cert_encoding().spec_parse(input@) is None,
+        spec_cert_encoding().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = cert_encoding();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_cert_encoding<'a>(v: <CertEncodingCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cert_encoding().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_cert_encoding().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_cert_encoding().spec_serialize(v@).len(),
+{
+    let combinator = cert_encoding();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecCertreqPayloadBody {
+    pub cert_encoding: u8,
+    pub ca_data: Seq<u8>,
+}
+
+pub type SpecCertreqPayloadBodyInner = (u8, Seq<u8>);
+
+
+impl SpecFrom<SpecCertreqPayloadBody> for SpecCertreqPayloadBodyInner {
+    open spec fn spec_from(m: SpecCertreqPayloadBody) -> SpecCertreqPayloadBodyInner {
+        (m.cert_encoding, m.ca_data)
+    }
+}
+
+impl SpecFrom<SpecCertreqPayloadBodyInner> for SpecCertreqPayloadBody {
+    open spec fn spec_from(m: SpecCertreqPayloadBodyInner) -> SpecCertreqPayloadBody {
+        let (cert_encoding, ca_data) = m;
+        SpecCertreqPayloadBody { cert_encoding, ca_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CertreqPayloadBody<'a> {
+    pub cert_encoding: u8,
+    pub ca_data: &'a [u8],
+}
+
+impl View for CertreqPayloadBody<'_> {
+    type V = SpecCertreqPayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCertreqPayloadBody {
+            cert_encoding: self.cert_encoding@,
+            ca_data: self.ca_data@,
+        }
+    }
+}
+pub type CertreqPayloadBodyInner<'a> = (u8, &'a [u8]);
+
+pub type CertreqPayloadBodyInnerRef<'a> = (&'a u8, &'a &'a [u8]);
+impl<'a> From<&'a CertreqPayloadBody<'a>> for CertreqPayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a CertreqPayloadBody) -> CertreqPayloadBodyInnerRef<'a> {
+        (&m.cert_encoding, &m.ca_data)
+    }
+}
+
+impl<'a> From<CertreqPayloadBodyInner<'a>> for CertreqPayloadBody<'a> {
+    fn ex_from(m: CertreqPayloadBodyInner) -> CertreqPayloadBody {
+        let (cert_encoding, ca_data) = m;
+        CertreqPayloadBody { cert_encoding, ca_data }
+    }
+}
+
+pub struct CertreqPayloadBodyMapper;
+impl View for CertreqPayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CertreqPayloadBodyMapper {
+    type Src = SpecCertreqPayloadBodyInner;
+    type Dst = SpecCertreqPayloadBody;
+}
+impl SpecIsoProof for CertreqPayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CertreqPayloadBodyMapper {
+    type Src = CertreqPayloadBodyInner<'a>;
+    type Dst = CertreqPayloadBody<'a>;
+    type RefSrc = CertreqPayloadBodyInnerRef<'a>;
+}
+type SpecCertreqPayloadBodyCombinatorAlias1 = (SpecCertEncodingCombinator, bytes::Variable);
+pub struct SpecCertreqPayloadBodyCombinator(pub SpecCertreqPayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecCertreqPayloadBodyCombinator {
+    type Type = SpecCertreqPayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCertreqPayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertreqPayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCertreqPayloadBodyCombinatorAlias = Mapped<SpecCertreqPayloadBodyCombinatorAlias1, CertreqPayloadBodyMapper>;
+type CertreqPayloadBodyCombinatorAlias1 = (CertEncodingCombinator, bytes::Variable);
+pub struct CertreqPayloadBodyCombinator1(pub CertreqPayloadBodyCombinatorAlias1);
+impl View for CertreqPayloadBodyCombinator1 {
+    type V = SpecCertreqPayloadBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertreqPayloadBodyCombinator1, CertreqPayloadBodyCombinatorAlias1);
+
+pub struct CertreqPayloadBodyCombinator(pub CertreqPayloadBodyCombinatorAlias);
+
+impl View for CertreqPayloadBodyCombinator {
+    type V = SpecCertreqPayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertreqPayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertreqPayloadBodyCombinator {
+    type Type = CertreqPayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CertreqPayloadBodyCombinatorAlias = Mapped<CertreqPayloadBodyCombinator1, CertreqPayloadBodyMapper>;
+
+
+pub open spec fn spec_certreq_payload_body(payload_length: u16) -> SpecCertreqPayloadBodyCombinator {
+    SpecCertreqPayloadBodyCombinator(
+    Mapped {
+        inner: (spec_cert_encoding(), bytes::Variable(((usize::spec_from(payload_length) - 5)) as usize)),
+        mapper: CertreqPayloadBodyMapper,
+    })
+}
+
+pub fn certreq_payload_body<'a>(payload_length: u16) -> (o: CertreqPayloadBodyCombinator)
+    requires
+        ((payload_length) >= 5 && (payload_length) <= 65535),
+
+    ensures o@ == spec_certreq_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CertreqPayloadBodyCombinator(
+    Mapped {
+        inner: CertreqPayloadBodyCombinator1((cert_encoding(), bytes::Variable(((usize::ex_from(payload_length) - 5)) as usize))),
+        mapper: CertreqPayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_certreq_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_certreq_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<CertreqPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 5 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_certreq_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_certreq_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_certreq_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_certreq_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = certreq_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_certreq_payload_body<'a>(v: <CertreqPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_certreq_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 5 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_certreq_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 5 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_certreq_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = certreq_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub enum SpecEapPayloadBodyEapRest {
+    Success(SpecEapSuccessRest),
+    Failure(SpecEapFailureRest),
+    Request(SpecEapReqRespRest),
+    Response(SpecEapReqRespRest),
+}
+
+pub type SpecEapPayloadBodyEapRestInner = Either<SpecEapSuccessRest, Either<SpecEapFailureRest, Either<SpecEapReqRespRest, SpecEapReqRespRest>>>;
+
+impl SpecFrom<SpecEapPayloadBodyEapRest> for SpecEapPayloadBodyEapRestInner {
+    open spec fn spec_from(m: SpecEapPayloadBodyEapRest) -> SpecEapPayloadBodyEapRestInner {
+        match m {
+            SpecEapPayloadBodyEapRest::Success(m) => Either::Left(m),
+            SpecEapPayloadBodyEapRest::Failure(m) => Either::Right(Either::Left(m)),
+            SpecEapPayloadBodyEapRest::Request(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecEapPayloadBodyEapRest::Response(m) => Either::Right(Either::Right(Either::Right(m))),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecEapPayloadBodyEapRestInner> for SpecEapPayloadBodyEapRest {
+    open spec fn spec_from(m: SpecEapPayloadBodyEapRestInner) -> SpecEapPayloadBodyEapRest {
+        match m {
+            Either::Left(m) => SpecEapPayloadBodyEapRest::Success(m),
+            Either::Right(Either::Left(m)) => SpecEapPayloadBodyEapRest::Failure(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecEapPayloadBodyEapRest::Request(m),
+            Either::Right(Either::Right(Either::Right(m))) => SpecEapPayloadBodyEapRest::Response(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EapPayloadBodyEapRest<'a> {
+    Success(EapSuccessRest),
+    Failure(EapFailureRest),
+    Request(EapReqRespRest<'a>),
+    Response(EapReqRespRest<'a>),
+}
+
+pub type EapPayloadBodyEapRestInner<'a> = Either<EapSuccessRest, Either<EapFailureRest, Either<EapReqRespRest<'a>, EapReqRespRest<'a>>>>;
+
+pub type EapPayloadBodyEapRestInnerRef<'a> = Either<&'a EapSuccessRest, Either<&'a EapFailureRest, Either<&'a EapReqRespRest<'a>, &'a EapReqRespRest<'a>>>>;
+
+
+impl<'a> View for EapPayloadBodyEapRest<'a> {
+    type V = SpecEapPayloadBodyEapRest;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            EapPayloadBodyEapRest::Success(m) => SpecEapPayloadBodyEapRest::Success(m@),
+            EapPayloadBodyEapRest::Failure(m) => SpecEapPayloadBodyEapRest::Failure(m@),
+            EapPayloadBodyEapRest::Request(m) => SpecEapPayloadBodyEapRest::Request(m@),
+            EapPayloadBodyEapRest::Response(m) => SpecEapPayloadBodyEapRest::Response(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a EapPayloadBodyEapRest<'a>> for EapPayloadBodyEapRestInnerRef<'a> {
+    fn ex_from(m: &'a EapPayloadBodyEapRest<'a>) -> EapPayloadBodyEapRestInnerRef<'a> {
+        match m {
+            EapPayloadBodyEapRest::Success(m) => Either::Left(m),
+            EapPayloadBodyEapRest::Failure(m) => Either::Right(Either::Left(m)),
+            EapPayloadBodyEapRest::Request(m) => Either::Right(Either::Right(Either::Left(m))),
+            EapPayloadBodyEapRest::Response(m) => Either::Right(Either::Right(Either::Right(m))),
+        }
+    }
+
+}
+
+impl<'a> From<EapPayloadBodyEapRestInner<'a>> for EapPayloadBodyEapRest<'a> {
+    fn ex_from(m: EapPayloadBodyEapRestInner<'a>) -> EapPayloadBodyEapRest<'a> {
+        match m {
+            Either::Left(m) => EapPayloadBodyEapRest::Success(m),
+            Either::Right(Either::Left(m)) => EapPayloadBodyEapRest::Failure(m),
+            Either::Right(Either::Right(Either::Left(m))) => EapPayloadBodyEapRest::Request(m),
+            Either::Right(Either::Right(Either::Right(m))) => EapPayloadBodyEapRest::Response(m),
+        }
+    }
+    
+}
+
+
+pub struct EapPayloadBodyEapRestMapper;
+impl View for EapPayloadBodyEapRestMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for EapPayloadBodyEapRestMapper {
+    type Src = SpecEapPayloadBodyEapRestInner;
+    type Dst = SpecEapPayloadBodyEapRest;
+}
+impl SpecIsoProof for EapPayloadBodyEapRestMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for EapPayloadBodyEapRestMapper {
+    type Src = EapPayloadBodyEapRestInner<'a>;
+    type Dst = EapPayloadBodyEapRest<'a>;
+    type RefSrc = EapPayloadBodyEapRestInnerRef<'a>;
+}
+
+type SpecEapPayloadBodyEapRestCombinatorAlias1 = Choice<Cond<SpecEapReqRespRestCombinator>, Cond<SpecEapReqRespRestCombinator>>;
+type SpecEapPayloadBodyEapRestCombinatorAlias2 = Choice<Cond<SpecEapFailureRestCombinator>, SpecEapPayloadBodyEapRestCombinatorAlias1>;
+type SpecEapPayloadBodyEapRestCombinatorAlias3 = Choice<Cond<SpecEapSuccessRestCombinator>, SpecEapPayloadBodyEapRestCombinatorAlias2>;
+pub struct SpecEapPayloadBodyEapRestCombinator(pub SpecEapPayloadBodyEapRestCombinatorAlias);
+
+impl SpecCombinator for SpecEapPayloadBodyEapRestCombinator {
+    type Type = SpecEapPayloadBodyEapRest;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecEapPayloadBodyEapRestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEapPayloadBodyEapRestCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecEapPayloadBodyEapRestCombinatorAlias = Mapped<SpecEapPayloadBodyEapRestCombinatorAlias3, EapPayloadBodyEapRestMapper>;
+type EapPayloadBodyEapRestCombinatorAlias1 = Choice<Cond<EapReqRespRestCombinator>, Cond<EapReqRespRestCombinator>>;
+type EapPayloadBodyEapRestCombinatorAlias2 = Choice<Cond<EapFailureRestCombinator>, EapPayloadBodyEapRestCombinator1>;
+type EapPayloadBodyEapRestCombinatorAlias3 = Choice<Cond<EapSuccessRestCombinator>, EapPayloadBodyEapRestCombinator2>;
+pub struct EapPayloadBodyEapRestCombinator1(pub EapPayloadBodyEapRestCombinatorAlias1);
+impl View for EapPayloadBodyEapRestCombinator1 {
+    type V = SpecEapPayloadBodyEapRestCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(EapPayloadBodyEapRestCombinator1, EapPayloadBodyEapRestCombinatorAlias1);
+
+pub struct EapPayloadBodyEapRestCombinator2(pub EapPayloadBodyEapRestCombinatorAlias2);
+impl View for EapPayloadBodyEapRestCombinator2 {
+    type V = SpecEapPayloadBodyEapRestCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(EapPayloadBodyEapRestCombinator2, EapPayloadBodyEapRestCombinatorAlias2);
+
+pub struct EapPayloadBodyEapRestCombinator3(pub EapPayloadBodyEapRestCombinatorAlias3);
+impl View for EapPayloadBodyEapRestCombinator3 {
+    type V = SpecEapPayloadBodyEapRestCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(EapPayloadBodyEapRestCombinator3, EapPayloadBodyEapRestCombinatorAlias3);
+
+pub struct EapPayloadBodyEapRestCombinator(pub EapPayloadBodyEapRestCombinatorAlias);
+
+impl View for EapPayloadBodyEapRestCombinator {
+    type V = SpecEapPayloadBodyEapRestCombinator;
+    open spec fn view(&self) -> Self::V { SpecEapPayloadBodyEapRestCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapPayloadBodyEapRestCombinator {
+    type Type = EapPayloadBodyEapRest<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type EapPayloadBodyEapRestCombinatorAlias = Mapped<EapPayloadBodyEapRestCombinator3, EapPayloadBodyEapRestMapper>;
+
+
+pub open spec fn spec_eap_payload_body_eap_rest(code: u8) -> SpecEapPayloadBodyEapRestCombinator {
+    SpecEapPayloadBodyEapRestCombinator(Mapped { inner: Choice(Cond { cond: code == EapCode::SPEC_Success, inner: spec_eap_success_rest() }, Choice(Cond { cond: code == EapCode::SPEC_Failure, inner: spec_eap_failure_rest() }, Choice(Cond { cond: code == EapCode::SPEC_Request, inner: spec_eap_req_resp_rest() }, Cond { cond: code == EapCode::SPEC_Response, inner: spec_eap_req_resp_rest() }))), mapper: EapPayloadBodyEapRestMapper })
+}
+
+pub fn eap_payload_body_eap_rest<'a>(code: u8) -> (o: EapPayloadBodyEapRestCombinator)
+    requires
+        spec_eap_code().wf(code@),
+
+    ensures o@ == spec_eap_payload_body_eap_rest(code@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = EapPayloadBodyEapRestCombinator(Mapped { inner: EapPayloadBodyEapRestCombinator3(Choice::new(Cond { cond: code == EapCode::Success, inner: eap_success_rest() }, EapPayloadBodyEapRestCombinator2(Choice::new(Cond { cond: code == EapCode::Failure, inner: eap_failure_rest() }, EapPayloadBodyEapRestCombinator1(Choice::new(Cond { cond: code == EapCode::Request, inner: eap_req_resp_rest() }, Cond { cond: code == EapCode::Response, inner: eap_req_resp_rest() })))))), mapper: EapPayloadBodyEapRestMapper });
+    // assert({
+    //     &&& combinator@ == spec_eap_payload_body_eap_rest(code@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_eap_payload_body_eap_rest<'a>(input: &'a [u8], code: u8) -> (res: PResult<<EapPayloadBodyEapRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_eap_code().wf(code@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_eap_payload_body_eap_rest(code@).spec_parse(input@) == Some((n as int, v@)),
+        spec_eap_payload_body_eap_rest(code@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_eap_payload_body_eap_rest(code@).spec_parse(input@) is None,
+        spec_eap_payload_body_eap_rest(code@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = eap_payload_body_eap_rest( code );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_eap_payload_body_eap_rest<'a>(v: <EapPayloadBodyEapRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, code: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_payload_body_eap_rest(code@).wf(v@),
+        spec_eap_code().wf(code@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_eap_payload_body_eap_rest(code@).spec_serialize(v@).len() <= usize::MAX,
+        spec_eap_code().wf(code@),
+
+    ensures
+        serialize_len == spec_eap_payload_body_eap_rest(code@).spec_serialize(v@).len(),
+{
+    let combinator = eap_payload_body_eap_rest( code );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub mod CfgType {
+    use super::*;
+    pub spec const SPEC_CFG_REQUEST: u8 = 1;
+    pub spec const SPEC_CFG_REPLY: u8 = 2;
+    pub spec const SPEC_CFG_SET: u8 = 3;
+    pub spec const SPEC_CFG_ACK: u8 = 4;
+    pub exec const CFG_REQUEST: u8 ensures CFG_REQUEST == SPEC_CFG_REQUEST { 1 }
+    pub exec const CFG_REPLY: u8 ensures CFG_REPLY == SPEC_CFG_REPLY { 2 }
+    pub exec const CFG_SET: u8 ensures CFG_SET == SPEC_CFG_SET { 3 }
+    pub exec const CFG_ACK: u8 ensures CFG_ACK == SPEC_CFG_ACK { 4 }
+}
+
+
+pub struct SpecCfgTypeCombinator(pub SpecCfgTypeCombinatorAlias);
+
+impl SpecCombinator for SpecCfgTypeCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCfgTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCfgTypeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCfgTypeCombinatorAlias = U8;
+
+pub struct CfgTypeCombinator(pub CfgTypeCombinatorAlias);
+
+impl View for CfgTypeCombinator {
+    type V = SpecCfgTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecCfgTypeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CfgTypeCombinator {
+    type Type = u8;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CfgTypeCombinatorAlias = U8;
+
+
+pub open spec fn spec_cfg_type() -> SpecCfgTypeCombinator {
+    SpecCfgTypeCombinator(U8)
+}
+
+                
+pub fn cfg_type<'a>() -> (o: CfgTypeCombinator)
+    ensures o@ == spec_cfg_type(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CfgTypeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_cfg_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_cfg_type<'a>(input: &'a [u8]) -> (res: PResult<<CfgTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_cfg_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_cfg_type().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_cfg_type().spec_parse(input@) is None,
+        spec_cfg_type().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = cfg_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_cfg_type<'a>(v: <CfgTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cfg_type().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_cfg_type().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_cfg_type().spec_serialize(v@).len(),
+{
+    let combinator = cfg_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecCpPayloadBody {
+    pub cfg_type: u8,
+    pub reserved: Seq<u8>,
+    pub attributes: Seq<SpecCfgAttribute>,
+}
+
+pub type SpecCpPayloadBodyInner = (u8, (Seq<u8>, Seq<SpecCfgAttribute>));
+
+
+impl SpecFrom<SpecCpPayloadBody> for SpecCpPayloadBodyInner {
+    open spec fn spec_from(m: SpecCpPayloadBody) -> SpecCpPayloadBodyInner {
+        (m.cfg_type, (m.reserved, m.attributes))
+    }
+}
+
+impl SpecFrom<SpecCpPayloadBodyInner> for SpecCpPayloadBody {
+    open spec fn spec_from(m: SpecCpPayloadBodyInner) -> SpecCpPayloadBody {
+        let (cfg_type, (reserved, attributes)) = m;
+        SpecCpPayloadBody { cfg_type, reserved, attributes }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CpPayloadBody<'a> {
+    pub cfg_type: u8,
+    pub reserved: &'a [u8],
+    pub attributes: RepeatResult<CfgAttribute<'a>>,
+}
+
+impl View for CpPayloadBody<'_> {
+    type V = SpecCpPayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCpPayloadBody {
+            cfg_type: self.cfg_type@,
+            reserved: self.reserved@,
+            attributes: self.attributes@,
+        }
+    }
+}
+pub type CpPayloadBodyInner<'a> = (u8, (&'a [u8], RepeatResult<CfgAttribute<'a>>));
+
+pub type CpPayloadBodyInnerRef<'a> = (&'a u8, (&'a &'a [u8], &'a RepeatResult<CfgAttribute<'a>>));
+impl<'a> From<&'a CpPayloadBody<'a>> for CpPayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a CpPayloadBody) -> CpPayloadBodyInnerRef<'a> {
+        (&m.cfg_type, (&m.reserved, &m.attributes))
+    }
+}
+
+impl<'a> From<CpPayloadBodyInner<'a>> for CpPayloadBody<'a> {
+    fn ex_from(m: CpPayloadBodyInner) -> CpPayloadBody {
+        let (cfg_type, (reserved, attributes)) = m;
+        CpPayloadBody { cfg_type, reserved, attributes }
+    }
+}
+
+pub struct CpPayloadBodyMapper;
+impl View for CpPayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CpPayloadBodyMapper {
+    type Src = SpecCpPayloadBodyInner;
+    type Dst = SpecCpPayloadBody;
+}
+impl SpecIsoProof for CpPayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CpPayloadBodyMapper {
+    type Src = CpPayloadBodyInner<'a>;
+    type Dst = CpPayloadBody<'a>;
+    type RefSrc = CpPayloadBodyInnerRef<'a>;
+}
+pub spec const SPEC_CPPAYLOADBODYRESERVED_CONST: Seq<u8> = seq![0; 3];type SpecCpPayloadBodyCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, AndThen<bytes::Variable, Repeat<SpecCfgAttributeCombinator>>);
+type SpecCpPayloadBodyCombinatorAlias2 = (SpecCfgTypeCombinator, SpecCpPayloadBodyCombinatorAlias1);
+pub struct SpecCpPayloadBodyCombinator(pub SpecCpPayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecCpPayloadBodyCombinator {
+    type Type = SpecCpPayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCpPayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCpPayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCpPayloadBodyCombinatorAlias = Mapped<SpecCpPayloadBodyCombinatorAlias2, CpPayloadBodyMapper>;
+pub exec static CPPAYLOADBODYRESERVED_CONST: [u8; 3]
+    ensures CPPAYLOADBODYRESERVED_CONST@ == SPEC_CPPAYLOADBODYRESERVED_CONST,
+{
+    let arr: [u8; 3] = [0; 3];
+    assert(arr@ == SPEC_CPPAYLOADBODYRESERVED_CONST);
+    arr
+}
+type CpPayloadBodyCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, AndThen<bytes::Variable, Repeat<CfgAttributeCombinator>>);
+type CpPayloadBodyCombinatorAlias2 = (CfgTypeCombinator, CpPayloadBodyCombinator1);
+pub struct CpPayloadBodyCombinator1(pub CpPayloadBodyCombinatorAlias1);
+impl View for CpPayloadBodyCombinator1 {
+    type V = SpecCpPayloadBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CpPayloadBodyCombinator1, CpPayloadBodyCombinatorAlias1);
+
+pub struct CpPayloadBodyCombinator2(pub CpPayloadBodyCombinatorAlias2);
+impl View for CpPayloadBodyCombinator2 {
+    type V = SpecCpPayloadBodyCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CpPayloadBodyCombinator2, CpPayloadBodyCombinatorAlias2);
+
+pub struct CpPayloadBodyCombinator(pub CpPayloadBodyCombinatorAlias);
+
+impl View for CpPayloadBodyCombinator {
+    type V = SpecCpPayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecCpPayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CpPayloadBodyCombinator {
+    type Type = CpPayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CpPayloadBodyCombinatorAlias = Mapped<CpPayloadBodyCombinator2, CpPayloadBodyMapper>;
+
+
+pub open spec fn spec_cp_payload_body(payload_length: u16) -> SpecCpPayloadBodyCombinator {
+    SpecCpPayloadBodyCombinator(
+    Mapped {
+        inner: (spec_cfg_type(), (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(SPEC_CPPAYLOADBODYRESERVED_CONST) }, AndThen(bytes::Variable(((usize::spec_from(payload_length) - 8)) as usize), Repeat(spec_cfg_attribute())))),
+        mapper: CpPayloadBodyMapper,
+    })
+}
+
+pub fn cp_payload_body<'a>(payload_length: u16) -> (o: CpPayloadBodyCombinator)
+    requires
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures o@ == spec_cp_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CpPayloadBodyCombinator(
+    Mapped {
+        inner: CpPayloadBodyCombinator2((cfg_type(), CpPayloadBodyCombinator1((Refined { inner: bytes::Fixed::<3>, predicate: TagPred(CPPAYLOADBODYRESERVED_CONST) }, AndThen(bytes::Variable(((usize::ex_from(payload_length) - 8)) as usize), Repeat::new(cfg_attribute())))))),
+        mapper: CpPayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_cp_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_cp_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<CpPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_cp_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_cp_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_cp_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_cp_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = cp_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_cp_payload_body<'a>(v: <CpPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cp_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_cp_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_cp_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = cp_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecEapPayloadBody {
+    pub code: u8,
+    pub eap_rest: SpecEapPayloadBodyEapRest,
+}
+
+pub type SpecEapPayloadBodyInner = (u8, SpecEapPayloadBodyEapRest);
+
+
+impl SpecFrom<SpecEapPayloadBody> for SpecEapPayloadBodyInner {
+    open spec fn spec_from(m: SpecEapPayloadBody) -> SpecEapPayloadBodyInner {
+        (m.code, m.eap_rest)
+    }
+}
+
+impl SpecFrom<SpecEapPayloadBodyInner> for SpecEapPayloadBody {
+    open spec fn spec_from(m: SpecEapPayloadBodyInner) -> SpecEapPayloadBody {
+        let (code, eap_rest) = m;
+        SpecEapPayloadBody { code, eap_rest }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct EapPayloadBody<'a> {
+    pub code: u8,
+    pub eap_rest: EapPayloadBodyEapRest<'a>,
+}
+
+impl View for EapPayloadBody<'_> {
+    type V = SpecEapPayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecEapPayloadBody {
+            code: self.code@,
+            eap_rest: self.eap_rest@,
+        }
+    }
+}
+pub type EapPayloadBodyInner<'a> = (u8, EapPayloadBodyEapRest<'a>);
+
+pub type EapPayloadBodyInnerRef<'a> = (&'a u8, &'a EapPayloadBodyEapRest<'a>);
+impl<'a> From<&'a EapPayloadBody<'a>> for EapPayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a EapPayloadBody) -> EapPayloadBodyInnerRef<'a> {
+        (&m.code, &m.eap_rest)
+    }
+}
+
+impl<'a> From<EapPayloadBodyInner<'a>> for EapPayloadBody<'a> {
+    fn ex_from(m: EapPayloadBodyInner) -> EapPayloadBody {
+        let (code, eap_rest) = m;
+        EapPayloadBody { code, eap_rest }
+    }
+}
+
+pub struct EapPayloadBodyMapper;
+impl View for EapPayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for EapPayloadBodyMapper {
+    type Src = SpecEapPayloadBodyInner;
+    type Dst = SpecEapPayloadBody;
+}
+impl SpecIsoProof for EapPayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for EapPayloadBodyMapper {
+    type Src = EapPayloadBodyInner<'a>;
+    type Dst = EapPayloadBody<'a>;
+    type RefSrc = EapPayloadBodyInnerRef<'a>;
+}
+
+pub struct SpecEapPayloadBodyCombinator(pub SpecEapPayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecEapPayloadBodyCombinator {
+    type Type = SpecEapPayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecEapPayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEapPayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecEapPayloadBodyCombinatorAlias = Mapped<SpecPair<SpecEapCodeCombinator, SpecEapPayloadBodyEapRestCombinator>, EapPayloadBodyMapper>;
+
+pub struct EapPayloadBodyCombinator(pub EapPayloadBodyCombinatorAlias);
+
+impl View for EapPayloadBodyCombinator {
+    type V = SpecEapPayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecEapPayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapPayloadBodyCombinator {
+    type Type = EapPayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type EapPayloadBodyCombinatorAlias = Mapped<Pair<EapCodeCombinator, EapPayloadBodyEapRestCombinator, EapPayloadBodyCont0>, EapPayloadBodyMapper>;
+
+
+pub open spec fn spec_eap_payload_body(payload_length: u16) -> SpecEapPayloadBodyCombinator {
+    SpecEapPayloadBodyCombinator(
+    Mapped {
+        inner: Pair::spec_new(spec_eap_code(), |deps| spec_eap_payload_body_cont0(payload_length, deps)),
+        mapper: EapPayloadBodyMapper,
+    })
+}
+
+pub open spec fn spec_eap_payload_body_cont0(payload_length: u16, deps: u8) -> SpecEapPayloadBodyEapRestCombinator {
+    let code = deps;
+    spec_eap_payload_body_eap_rest(code)
+}
+
+impl View for EapPayloadBodyCont0 {
+    type V = spec_fn(u8) -> SpecEapPayloadBodyEapRestCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_eap_payload_body_cont0(self.payload_length@, deps)
+        }
+    }
+}
+
+pub fn eap_payload_body<'a>(payload_length: u16) -> (o: EapPayloadBodyCombinator)
+    requires
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures o@ == spec_eap_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = EapPayloadBodyCombinator(
+    Mapped {
+        inner: Pair::new(eap_code(), EapPayloadBodyCont0 { payload_length }),
+        mapper: EapPayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_eap_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_eap_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<EapPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_eap_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_eap_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_eap_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_eap_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = eap_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_eap_payload_body<'a>(v: <EapPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_eap_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_eap_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = eap_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct EapPayloadBodyCont0 {
+    pub payload_length: u16,
+}
+type EapPayloadBodyCont0Type<'a, 'b> = &'b u8;
+type EapPayloadBodyCont0SType<'a, 'x> = &'x u8;
+type EapPayloadBodyCont0Input<'a, 'b, 'x> = POrSType<EapPayloadBodyCont0Type<'a, 'b>, EapPayloadBodyCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<EapPayloadBodyCont0Input<'a, 'b, 'x>> for EapPayloadBodyCont0 {
+    type Output = EapPayloadBodyEapRestCombinator;
+
+    open spec fn requires(&self, deps: EapPayloadBodyCont0Input<'a, 'b, 'x>) -> bool {        let payload_length = self.payload_length@;
+
+        &&& ((self.payload_length@) >= 8 && (self.payload_length@) <= 65535)
+        &&& (spec_eap_code()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: EapPayloadBodyCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_eap_payload_body_cont0(self.payload_length@, deps@)
+    }
+
+    fn apply(&self, deps: EapPayloadBodyCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let code = deps;
+                let payload_length = self.payload_length;
+                let code = *code;
+                eap_payload_body_eap_rest(code)
+            }
+            POrSType::S(deps) => {
+                let code = deps;
+                let payload_length = self.payload_length;
+                let code = *code;
+                eap_payload_body_eap_rest(code)
+            }
+        }
+    }
+}
+pub mod ExchangeType {
+    use super::*;
+    pub spec const SPEC_IKE_SA_INIT: u8 = 34;
+    pub spec const SPEC_IKE_AUTH: u8 = 35;
+    pub spec const SPEC_CREATE_CHILD_SA: u8 = 36;
+    pub spec const SPEC_INFORMATIONAL: u8 = 37;
+    pub exec const IKE_SA_INIT: u8 ensures IKE_SA_INIT == SPEC_IKE_SA_INIT { 34 }
+    pub exec const IKE_AUTH: u8 ensures IKE_AUTH == SPEC_IKE_AUTH { 35 }
+    pub exec const CREATE_CHILD_SA: u8 ensures CREATE_CHILD_SA == SPEC_CREATE_CHILD_SA { 36 }
+    pub exec const INFORMATIONAL: u8 ensures INFORMATIONAL == SPEC_INFORMATIONAL { 37 }
+}
+
+
+pub struct SpecExchangeTypeCombinator(pub SpecExchangeTypeCombinatorAlias);
+
+impl SpecCombinator for SpecExchangeTypeCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecExchangeTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecExchangeTypeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecExchangeTypeCombinatorAlias = U8;
+
+pub struct ExchangeTypeCombinator(pub ExchangeTypeCombinatorAlias);
+
+impl View for ExchangeTypeCombinator {
+    type V = SpecExchangeTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecExchangeTypeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExchangeTypeCombinator {
+    type Type = u8;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ExchangeTypeCombinatorAlias = U8;
+
+
+pub open spec fn spec_exchange_type() -> SpecExchangeTypeCombinator {
+    SpecExchangeTypeCombinator(U8)
+}
+
+                
+pub fn exchange_type<'a>() -> (o: ExchangeTypeCombinator)
+    ensures o@ == spec_exchange_type(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ExchangeTypeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_exchange_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_exchange_type<'a>(input: &'a [u8]) -> (res: PResult<<ExchangeTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_exchange_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_exchange_type().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_exchange_type().spec_parse(input@) is None,
+        spec_exchange_type().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = exchange_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_exchange_type<'a>(v: <ExchangeTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_exchange_type().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_exchange_type().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_exchange_type().spec_serialize(v@).len(),
+{
+    let combinator = exchange_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub mod NotifyMsgType {
+    use super::*;
+    pub spec const SPEC_UNSUPPORTED_CRITICAL_PAYLOAD: u16 = 1;
+    pub spec const SPEC_INVALID_IKE_SPI: u16 = 4;
+    pub spec const SPEC_INVALID_MAJOR_VERSION: u16 = 5;
+    pub spec const SPEC_INVALID_SYNTAX: u16 = 7;
+    pub spec const SPEC_INVALID_MESSAGE_ID: u16 = 9;
+    pub spec const SPEC_INVALID_SPI: u16 = 11;
+    pub spec const SPEC_NO_PROPOSAL_CHOSEN: u16 = 14;
+    pub spec const SPEC_INVALID_KE_PAYLOAD: u16 = 17;
+    pub spec const SPEC_AUTHENTICATION_FAILED: u16 = 24;
+    pub spec const SPEC_SINGLE_PAIR_REQUIRED: u16 = 34;
+    pub spec const SPEC_NO_ADDITIONAL_SAS: u16 = 35;
+    pub spec const SPEC_INTERNAL_ADDRESS_FAILURE: u16 = 36;
+    pub spec const SPEC_FAILED_CP_REQUIRED: u16 = 37;
+    pub spec const SPEC_TS_UNACCEPTABLE: u16 = 38;
+    pub spec const SPEC_INVALID_SELECTORS: u16 = 39;
+    pub spec const SPEC_TEMPORARY_FAILURE: u16 = 43;
+    pub spec const SPEC_CHILD_SA_NOT_FOUND: u16 = 44;
+    pub spec const SPEC_INITIAL_CONTACT: u16 = 16384;
+    pub spec const SPEC_SET_WINDOW_SIZE: u16 = 16385;
+    pub spec const SPEC_ADDITIONAL_TS_POSSIBLE: u16 = 16386;
+    pub spec const SPEC_IPCOMP_SUPPORTED: u16 = 16387;
+    pub spec const SPEC_NAT_DETECTION_SOURCE_IP: u16 = 16388;
+    pub spec const SPEC_NAT_DETECTION_DESTINATION_IP: u16 = 16389;
+    pub spec const SPEC_COOKIE: u16 = 16390;
+    pub spec const SPEC_USE_TRANSPORT_MODE: u16 = 16391;
+    pub spec const SPEC_HTTP_CERT_LOOKUP_SUPPORTED: u16 = 16392;
+    pub spec const SPEC_REKEY_SA: u16 = 16393;
+    pub spec const SPEC_ESP_TFC_PADDING_NOT_SUPPORTED: u16 = 16394;
+    pub spec const SPEC_NON_FIRST_FRAGMENTS_ALSO: u16 = 16395;
+    pub exec const UNSUPPORTED_CRITICAL_PAYLOAD: u16 ensures UNSUPPORTED_CRITICAL_PAYLOAD == SPEC_UNSUPPORTED_CRITICAL_PAYLOAD { 1 }
+    pub exec const INVALID_IKE_SPI: u16 ensures INVALID_IKE_SPI == SPEC_INVALID_IKE_SPI { 4 }
+    pub exec const INVALID_MAJOR_VERSION: u16 ensures INVALID_MAJOR_VERSION == SPEC_INVALID_MAJOR_VERSION { 5 }
+    pub exec const INVALID_SYNTAX: u16 ensures INVALID_SYNTAX == SPEC_INVALID_SYNTAX { 7 }
+    pub exec const INVALID_MESSAGE_ID: u16 ensures INVALID_MESSAGE_ID == SPEC_INVALID_MESSAGE_ID { 9 }
+    pub exec const INVALID_SPI: u16 ensures INVALID_SPI == SPEC_INVALID_SPI { 11 }
+    pub exec const NO_PROPOSAL_CHOSEN: u16 ensures NO_PROPOSAL_CHOSEN == SPEC_NO_PROPOSAL_CHOSEN { 14 }
+    pub exec const INVALID_KE_PAYLOAD: u16 ensures INVALID_KE_PAYLOAD == SPEC_INVALID_KE_PAYLOAD { 17 }
+    pub exec const AUTHENTICATION_FAILED: u16 ensures AUTHENTICATION_FAILED == SPEC_AUTHENTICATION_FAILED { 24 }
+    pub exec const SINGLE_PAIR_REQUIRED: u16 ensures SINGLE_PAIR_REQUIRED == SPEC_SINGLE_PAIR_REQUIRED { 34 }
+    pub exec const NO_ADDITIONAL_SAS: u16 ensures NO_ADDITIONAL_SAS == SPEC_NO_ADDITIONAL_SAS { 35 }
+    pub exec const INTERNAL_ADDRESS_FAILURE: u16 ensures INTERNAL_ADDRESS_FAILURE == SPEC_INTERNAL_ADDRESS_FAILURE { 36 }
+    pub exec const FAILED_CP_REQUIRED: u16 ensures FAILED_CP_REQUIRED == SPEC_FAILED_CP_REQUIRED { 37 }
+    pub exec const TS_UNACCEPTABLE: u16 ensures TS_UNACCEPTABLE == SPEC_TS_UNACCEPTABLE { 38 }
+    pub exec const INVALID_SELECTORS: u16 ensures INVALID_SELECTORS == SPEC_INVALID_SELECTORS { 39 }
+    pub exec const TEMPORARY_FAILURE: u16 ensures TEMPORARY_FAILURE == SPEC_TEMPORARY_FAILURE { 43 }
+    pub exec const CHILD_SA_NOT_FOUND: u16 ensures CHILD_SA_NOT_FOUND == SPEC_CHILD_SA_NOT_FOUND { 44 }
+    pub exec const INITIAL_CONTACT: u16 ensures INITIAL_CONTACT == SPEC_INITIAL_CONTACT { 16384 }
+    pub exec const SET_WINDOW_SIZE: u16 ensures SET_WINDOW_SIZE == SPEC_SET_WINDOW_SIZE { 16385 }
+    pub exec const ADDITIONAL_TS_POSSIBLE: u16 ensures ADDITIONAL_TS_POSSIBLE == SPEC_ADDITIONAL_TS_POSSIBLE { 16386 }
+    pub exec const IPCOMP_SUPPORTED: u16 ensures IPCOMP_SUPPORTED == SPEC_IPCOMP_SUPPORTED { 16387 }
+    pub exec const NAT_DETECTION_SOURCE_IP: u16 ensures NAT_DETECTION_SOURCE_IP == SPEC_NAT_DETECTION_SOURCE_IP { 16388 }
+    pub exec const NAT_DETECTION_DESTINATION_IP: u16 ensures NAT_DETECTION_DESTINATION_IP == SPEC_NAT_DETECTION_DESTINATION_IP { 16389 }
+    pub exec const COOKIE: u16 ensures COOKIE == SPEC_COOKIE { 16390 }
+    pub exec const USE_TRANSPORT_MODE: u16 ensures USE_TRANSPORT_MODE == SPEC_USE_TRANSPORT_MODE { 16391 }
+    pub exec const HTTP_CERT_LOOKUP_SUPPORTED: u16 ensures HTTP_CERT_LOOKUP_SUPPORTED == SPEC_HTTP_CERT_LOOKUP_SUPPORTED { 16392 }
+    pub exec const REKEY_SA: u16 ensures REKEY_SA == SPEC_REKEY_SA { 16393 }
+    pub exec const ESP_TFC_PADDING_NOT_SUPPORTED: u16 ensures ESP_TFC_PADDING_NOT_SUPPORTED == SPEC_ESP_TFC_PADDING_NOT_SUPPORTED { 16394 }
+    pub exec const NON_FIRST_FRAGMENTS_ALSO: u16 ensures NON_FIRST_FRAGMENTS_ALSO == SPEC_NON_FIRST_FRAGMENTS_ALSO { 16395 }
+}
+
+
+pub struct SpecNotifyMsgTypeCombinator(pub SpecNotifyMsgTypeCombinatorAlias);
+
+impl SpecCombinator for SpecNotifyMsgTypeCombinator {
+    type Type = u16;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNotifyMsgTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNotifyMsgTypeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNotifyMsgTypeCombinatorAlias = U16Be;
+
+pub struct NotifyMsgTypeCombinator(pub NotifyMsgTypeCombinatorAlias);
+
+impl View for NotifyMsgTypeCombinator {
+    type V = SpecNotifyMsgTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecNotifyMsgTypeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyMsgTypeCombinator {
+    type Type = u16;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NotifyMsgTypeCombinatorAlias = U16Be;
+
+
+pub open spec fn spec_notify_msg_type() -> SpecNotifyMsgTypeCombinator {
+    SpecNotifyMsgTypeCombinator(U16Be)
+}
+
+                
+pub fn notify_msg_type<'a>() -> (o: NotifyMsgTypeCombinator)
+    ensures o@ == spec_notify_msg_type(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NotifyMsgTypeCombinator(U16Be);
+    // assert({
+    //     &&& combinator@ == spec_notify_msg_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_notify_msg_type<'a>(input: &'a [u8]) -> (res: PResult<<NotifyMsgTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_notify_msg_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_notify_msg_type().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_notify_msg_type().spec_parse(input@) is None,
+        spec_notify_msg_type().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = notify_msg_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_notify_msg_type<'a>(v: <NotifyMsgTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_notify_msg_type().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_notify_msg_type().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_notify_msg_type().spec_serialize(v@).len(),
+{
+    let combinator = notify_msg_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecKePayloadBody {
+    pub dh_group_num: u16,
+    pub reserved: u16,
+    pub ke_data: Seq<u8>,
+}
+
+pub type SpecKePayloadBodyInner = (u16, (u16, Seq<u8>));
+
+
+impl SpecFrom<SpecKePayloadBody> for SpecKePayloadBodyInner {
+    open spec fn spec_from(m: SpecKePayloadBody) -> SpecKePayloadBodyInner {
+        (m.dh_group_num, (m.reserved, m.ke_data))
+    }
+}
+
+impl SpecFrom<SpecKePayloadBodyInner> for SpecKePayloadBody {
+    open spec fn spec_from(m: SpecKePayloadBodyInner) -> SpecKePayloadBody {
+        let (dh_group_num, (reserved, ke_data)) = m;
+        SpecKePayloadBody { dh_group_num, reserved, ke_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct KePayloadBody<'a> {
+    pub dh_group_num: u16,
+    pub reserved: u16,
+    pub ke_data: &'a [u8],
+}
+
+impl View for KePayloadBody<'_> {
+    type V = SpecKePayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecKePayloadBody {
+            dh_group_num: self.dh_group_num@,
+            reserved: self.reserved@,
+            ke_data: self.ke_data@,
+        }
+    }
+}
+pub type KePayloadBodyInner<'a> = (u16, (u16, &'a [u8]));
+
+pub type KePayloadBodyInnerRef<'a> = (&'a u16, (&'a u16, &'a &'a [u8]));
+impl<'a> From<&'a KePayloadBody<'a>> for KePayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a KePayloadBody) -> KePayloadBodyInnerRef<'a> {
+        (&m.dh_group_num, (&m.reserved, &m.ke_data))
+    }
+}
+
+impl<'a> From<KePayloadBodyInner<'a>> for KePayloadBody<'a> {
+    fn ex_from(m: KePayloadBodyInner) -> KePayloadBody {
+        let (dh_group_num, (reserved, ke_data)) = m;
+        KePayloadBody { dh_group_num, reserved, ke_data }
+    }
+}
+
+pub struct KePayloadBodyMapper;
+impl View for KePayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for KePayloadBodyMapper {
+    type Src = SpecKePayloadBodyInner;
+    type Dst = SpecKePayloadBody;
+}
+impl SpecIsoProof for KePayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for KePayloadBodyMapper {
+    type Src = KePayloadBodyInner<'a>;
+    type Dst = KePayloadBody<'a>;
+    type RefSrc = KePayloadBodyInnerRef<'a>;
+}
+pub const KEPAYLOADBODYRESERVED_CONST: u16 = 0;
+type SpecKePayloadBodyCombinatorAlias1 = (Refined<U16Be, TagPred<u16>>, bytes::Variable);
+type SpecKePayloadBodyCombinatorAlias2 = (SpecDhIdCombinator, SpecKePayloadBodyCombinatorAlias1);
+pub struct SpecKePayloadBodyCombinator(pub SpecKePayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecKePayloadBodyCombinator {
+    type Type = SpecKePayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecKePayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecKePayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecKePayloadBodyCombinatorAlias = Mapped<SpecKePayloadBodyCombinatorAlias2, KePayloadBodyMapper>;
+type KePayloadBodyCombinatorAlias1 = (Refined<U16Be, TagPred<u16>>, bytes::Variable);
+type KePayloadBodyCombinatorAlias2 = (DhIdCombinator, KePayloadBodyCombinator1);
+pub struct KePayloadBodyCombinator1(pub KePayloadBodyCombinatorAlias1);
+impl View for KePayloadBodyCombinator1 {
+    type V = SpecKePayloadBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(KePayloadBodyCombinator1, KePayloadBodyCombinatorAlias1);
+
+pub struct KePayloadBodyCombinator2(pub KePayloadBodyCombinatorAlias2);
+impl View for KePayloadBodyCombinator2 {
+    type V = SpecKePayloadBodyCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(KePayloadBodyCombinator2, KePayloadBodyCombinatorAlias2);
+
+pub struct KePayloadBodyCombinator(pub KePayloadBodyCombinatorAlias);
+
+impl View for KePayloadBodyCombinator {
+    type V = SpecKePayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecKePayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for KePayloadBodyCombinator {
+    type Type = KePayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type KePayloadBodyCombinatorAlias = Mapped<KePayloadBodyCombinator2, KePayloadBodyMapper>;
+
+
+pub open spec fn spec_ke_payload_body(payload_length: u16) -> SpecKePayloadBodyCombinator {
+    SpecKePayloadBodyCombinator(
+    Mapped {
+        inner: (spec_dh_id(), (Refined { inner: U16Be, predicate: TagPred(KEPAYLOADBODYRESERVED_CONST) }, bytes::Variable(((usize::spec_from(payload_length) - 8)) as usize))),
+        mapper: KePayloadBodyMapper,
+    })
+}
+
+pub fn ke_payload_body<'a>(payload_length: u16) -> (o: KePayloadBodyCombinator)
+    requires
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures o@ == spec_ke_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = KePayloadBodyCombinator(
+    Mapped {
+        inner: KePayloadBodyCombinator2((dh_id(), KePayloadBodyCombinator1((Refined { inner: U16Be, predicate: TagPred(KEPAYLOADBODYRESERVED_CONST) }, bytes::Variable(((usize::ex_from(payload_length) - 8)) as usize))))),
+        mapper: KePayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ke_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ke_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<KePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_ke_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_ke_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ke_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_ke_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ke_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ke_payload_body<'a>(v: <KePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ke_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_ke_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_ke_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = ke_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub mod NextPayloadType {
+    use super::*;
+    pub spec const SPEC_NoNextPayload: u8 = 0;
+    pub spec const SPEC_SA: u8 = 33;
+    pub spec const SPEC_KE: u8 = 34;
+    pub spec const SPEC_IDi: u8 = 35;
+    pub spec const SPEC_IDr: u8 = 36;
+    pub spec const SPEC_CERT: u8 = 37;
+    pub spec const SPEC_CERTREQ: u8 = 38;
+    pub spec const SPEC_AUTH: u8 = 39;
+    pub spec const SPEC_Nonce: u8 = 40;
+    pub spec const SPEC_Notify: u8 = 41;
+    pub spec const SPEC_Delete: u8 = 42;
+    pub spec const SPEC_VendorID: u8 = 43;
+    pub spec const SPEC_TSi: u8 = 44;
+    pub spec const SPEC_TSr: u8 = 45;
+    pub spec const SPEC_SK: u8 = 46;
+    pub spec const SPEC_CP: u8 = 47;
+    pub spec const SPEC_EAP: u8 = 48;
+    pub exec const NoNextPayload: u8 ensures NoNextPayload == SPEC_NoNextPayload { 0 }
+    pub exec const SA: u8 ensures SA == SPEC_SA { 33 }
+    pub exec const KE: u8 ensures KE == SPEC_KE { 34 }
+    pub exec const IDi: u8 ensures IDi == SPEC_IDi { 35 }
+    pub exec const IDr: u8 ensures IDr == SPEC_IDr { 36 }
+    pub exec const CERT: u8 ensures CERT == SPEC_CERT { 37 }
+    pub exec const CERTREQ: u8 ensures CERTREQ == SPEC_CERTREQ { 38 }
+    pub exec const AUTH: u8 ensures AUTH == SPEC_AUTH { 39 }
+    pub exec const Nonce: u8 ensures Nonce == SPEC_Nonce { 40 }
+    pub exec const Notify: u8 ensures Notify == SPEC_Notify { 41 }
+    pub exec const Delete: u8 ensures Delete == SPEC_Delete { 42 }
+    pub exec const VendorID: u8 ensures VendorID == SPEC_VendorID { 43 }
+    pub exec const TSi: u8 ensures TSi == SPEC_TSi { 44 }
+    pub exec const TSr: u8 ensures TSr == SPEC_TSr { 45 }
+    pub exec const SK: u8 ensures SK == SPEC_SK { 46 }
+    pub exec const CP: u8 ensures CP == SPEC_CP { 47 }
+    pub exec const EAP: u8 ensures EAP == SPEC_EAP { 48 }
+}
+
+
+pub struct SpecNextPayloadTypeCombinator(pub SpecNextPayloadTypeCombinatorAlias);
+
+impl SpecCombinator for SpecNextPayloadTypeCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNextPayloadTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNextPayloadTypeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNextPayloadTypeCombinatorAlias = U8;
+
+pub struct NextPayloadTypeCombinator(pub NextPayloadTypeCombinatorAlias);
+
+impl View for NextPayloadTypeCombinator {
+    type V = SpecNextPayloadTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecNextPayloadTypeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NextPayloadTypeCombinator {
+    type Type = u8;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NextPayloadTypeCombinatorAlias = U8;
+
+
+pub open spec fn spec_next_payload_type() -> SpecNextPayloadTypeCombinator {
+    SpecNextPayloadTypeCombinator(U8)
+}
+
+                
+pub fn next_payload_type<'a>() -> (o: NextPayloadTypeCombinator)
+    ensures o@ == spec_next_payload_type(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NextPayloadTypeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_next_payload_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_next_payload_type<'a>(input: &'a [u8]) -> (res: PResult<<NextPayloadTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_next_payload_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_next_payload_type().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_next_payload_type().spec_parse(input@) is None,
+        spec_next_payload_type().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = next_payload_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_next_payload_type<'a>(v: <NextPayloadTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_next_payload_type().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_next_payload_type().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_next_payload_type().spec_serialize(v@).len(),
+{
+    let combinator = next_payload_type();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub type SpecIkeVersionByte = u8;
+pub type IkeVersionByte = u8;
+pub type IkeVersionByteRef<'a> = &'a u8;
+
+
+pub struct SpecIkeVersionByteCombinator(pub SpecIkeVersionByteCombinatorAlias);
+
+impl SpecCombinator for SpecIkeVersionByteCombinator {
+    type Type = SpecIkeVersionByte;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkeVersionByteCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkeVersionByteCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkeVersionByteCombinatorAlias = Refined<U8, Predicate10005340194363141588>;
+pub struct Predicate10005340194363141588;
+impl View for Predicate10005340194363141588 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate10005340194363141588 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 32 && i <= 47)
+    }
+}
+impl SpecPred<u8> for Predicate10005340194363141588 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 32 && i <= 47)
+    }
+}
+
+pub struct IkeVersionByteCombinator(pub IkeVersionByteCombinatorAlias);
+
+impl View for IkeVersionByteCombinator {
+    type V = SpecIkeVersionByteCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkeVersionByteCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeVersionByteCombinator {
+    type Type = IkeVersionByte;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type IkeVersionByteCombinatorAlias = Refined<U8, Predicate10005340194363141588>;
+
+
+pub open spec fn spec_ike_version_byte() -> SpecIkeVersionByteCombinator {
+    SpecIkeVersionByteCombinator(Refined { inner: U8, predicate: Predicate10005340194363141588 })
+}
+
+                
+pub fn ike_version_byte<'a>() -> (o: IkeVersionByteCombinator)
+    ensures o@ == spec_ike_version_byte(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = IkeVersionByteCombinator(Refined { inner: U8, predicate: Predicate10005340194363141588 });
+    // assert({
+    //     &&& combinator@ == spec_ike_version_byte()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ike_version_byte<'a>(input: &'a [u8]) -> (res: PResult<<IkeVersionByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ike_version_byte().spec_parse(input@) == Some((n as int, v@)),
+        spec_ike_version_byte().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ike_version_byte().spec_parse(input@) is None,
+        spec_ike_version_byte().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ike_version_byte();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ike_version_byte<'a>(v: <IkeVersionByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ike_version_byte().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ike_version_byte().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ike_version_byte().spec_serialize(v@).len(),
+{
+    let combinator = ike_version_byte();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub spec const SPEC_IkeFlags_ResponderRequest: u8 = 0;
+pub spec const SPEC_IkeFlags_InitiatorRequest: u8 = 8;
+pub spec const SPEC_IkeFlags_ResponderResponse: u8 = 32;
+pub spec const SPEC_IkeFlags_InitiatorResponse: u8 = 40;
+pub exec static EXEC_IkeFlags_ResponderRequest: u8 ensures EXEC_IkeFlags_ResponderRequest == SPEC_IkeFlags_ResponderRequest { 0 }
+pub exec static EXEC_IkeFlags_InitiatorRequest: u8 ensures EXEC_IkeFlags_InitiatorRequest == SPEC_IkeFlags_InitiatorRequest { 8 }
+pub exec static EXEC_IkeFlags_ResponderResponse: u8 ensures EXEC_IkeFlags_ResponderResponse == SPEC_IkeFlags_ResponderResponse { 32 }
+pub exec static EXEC_IkeFlags_InitiatorResponse: u8 ensures EXEC_IkeFlags_InitiatorResponse == SPEC_IkeFlags_InitiatorResponse { 40 }
+
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum IkeFlags {
+    ResponderRequest = 0,
+InitiatorRequest = 8,
+ResponderResponse = 32,
+InitiatorResponse = 40
+}
+pub type SpecIkeFlags = IkeFlags;
+
+pub type IkeFlagsInner = u8;
+
+pub type IkeFlagsInnerRef<'a> = &'a u8;
+
+impl View for IkeFlags {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecTryFrom<IkeFlagsInner> for IkeFlags {
+    type Error = ();
+
+    open spec fn spec_try_from(v: IkeFlagsInner) -> Result<IkeFlags, ()> {
+        match v {
+            0u8 => Ok(IkeFlags::ResponderRequest),
+            8u8 => Ok(IkeFlags::InitiatorRequest),
+            32u8 => Ok(IkeFlags::ResponderResponse),
+            40u8 => Ok(IkeFlags::InitiatorResponse),
+            _ => Err(()),
+        }
+    }
+}
+
+impl SpecTryFrom<IkeFlags> for IkeFlagsInner {
+    type Error = ();
+
+    open spec fn spec_try_from(v: IkeFlags) -> Result<IkeFlagsInner, ()> {
+        match v {
+            IkeFlags::ResponderRequest => Ok(SPEC_IkeFlags_ResponderRequest),
+            IkeFlags::InitiatorRequest => Ok(SPEC_IkeFlags_InitiatorRequest),
+            IkeFlags::ResponderResponse => Ok(SPEC_IkeFlags_ResponderResponse),
+            IkeFlags::InitiatorResponse => Ok(SPEC_IkeFlags_InitiatorResponse),
+        }
+    }
+}
+
+impl TryFrom<IkeFlagsInner> for IkeFlags {
+    type Error = ();
+
+    fn ex_try_from(v: IkeFlagsInner) -> Result<IkeFlags, ()> {
+        match v {
+            0u8 => Ok(IkeFlags::ResponderRequest),
+            8u8 => Ok(IkeFlags::InitiatorRequest),
+            32u8 => Ok(IkeFlags::ResponderResponse),
+            40u8 => Ok(IkeFlags::InitiatorResponse),
+            _ => Err(()),
+        }
+    }
+}
+
+impl<'a> TryFrom<&'a IkeFlags> for IkeFlagsInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a IkeFlags) -> Result<IkeFlagsInnerRef<'a>, ()> {
+        match v {
+            IkeFlags::ResponderRequest => Ok(&EXEC_IkeFlags_ResponderRequest),
+            IkeFlags::InitiatorRequest => Ok(&EXEC_IkeFlags_InitiatorRequest),
+            IkeFlags::ResponderResponse => Ok(&EXEC_IkeFlags_ResponderResponse),
+            IkeFlags::InitiatorResponse => Ok(&EXEC_IkeFlags_InitiatorResponse),
+        }
+    }
+}
+
+pub struct IkeFlagsMapper;
+
+impl View for IkeFlagsMapper {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecPartialIso for IkeFlagsMapper {
+    type Src = IkeFlagsInner;
+    type Dst = IkeFlags;
+}
+
+impl SpecPartialIsoProof for IkeFlagsMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+}
+
+impl<'a> PartialIso<'a> for IkeFlagsMapper {
+    type Src = IkeFlagsInner;
+    type Dst = IkeFlags;
+    type RefSrc = IkeFlagsInnerRef<'a>;
+}
+
+
+pub struct SpecIkeFlagsCombinator(pub SpecIkeFlagsCombinatorAlias);
+
+impl SpecCombinator for SpecIkeFlagsCombinator {
+    type Type = SpecIkeFlags;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkeFlagsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkeFlagsCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkeFlagsCombinatorAlias = TryMap<U8, IkeFlagsMapper>;
+
+pub struct IkeFlagsCombinator(pub IkeFlagsCombinatorAlias);
+
+impl View for IkeFlagsCombinator {
+    type V = SpecIkeFlagsCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkeFlagsCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeFlagsCombinator {
+    type Type = IkeFlags;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type IkeFlagsCombinatorAlias = TryMap<U8, IkeFlagsMapper>;
+
+
+pub open spec fn spec_ike_flags() -> SpecIkeFlagsCombinator {
+    SpecIkeFlagsCombinator(TryMap { inner: U8, mapper: IkeFlagsMapper })
+}
+
+                
+pub fn ike_flags<'a>() -> (o: IkeFlagsCombinator)
+    ensures o@ == spec_ike_flags(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = IkeFlagsCombinator(TryMap { inner: U8, mapper: IkeFlagsMapper });
+    // assert({
+    //     &&& combinator@ == spec_ike_flags()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ike_flags<'a>(input: &'a [u8]) -> (res: PResult<<IkeFlagsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ike_flags().spec_parse(input@) == Some((n as int, v@)),
+        spec_ike_flags().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ike_flags().spec_parse(input@) is None,
+        spec_ike_flags().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ike_flags();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ike_flags<'a>(v: <IkeFlagsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ike_flags().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ike_flags().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ike_flags().spec_serialize(v@).len(),
+{
+    let combinator = ike_flags();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecIkeHeader {
+    pub initiator_spi: Seq<u8>,
+    pub responder_spi: Seq<u8>,
+    pub next_payload: u8,
+    pub version: SpecIkeVersionByte,
+    pub exchange_type: u8,
+    pub flags: SpecIkeFlags,
+    pub message_id: u32,
+    pub length: u32,
+}
+
+pub type SpecIkeHeaderInner = (Seq<u8>, (Seq<u8>, (u8, (SpecIkeVersionByte, (u8, (SpecIkeFlags, (u32, u32)))))));
+
+
+impl SpecFrom<SpecIkeHeader> for SpecIkeHeaderInner {
+    open spec fn spec_from(m: SpecIkeHeader) -> SpecIkeHeaderInner {
+        (m.initiator_spi, (m.responder_spi, (m.next_payload, (m.version, (m.exchange_type, (m.flags, (m.message_id, m.length)))))))
+    }
+}
+
+impl SpecFrom<SpecIkeHeaderInner> for SpecIkeHeader {
+    open spec fn spec_from(m: SpecIkeHeaderInner) -> SpecIkeHeader {
+        let (initiator_spi, (responder_spi, (next_payload, (version, (exchange_type, (flags, (message_id, length))))))) = m;
+        SpecIkeHeader { initiator_spi, responder_spi, next_payload, version, exchange_type, flags, message_id, length }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct IkeHeader<'a> {
+    pub initiator_spi: &'a [u8],
+    pub responder_spi: &'a [u8],
+    pub next_payload: u8,
+    pub version: IkeVersionByte,
+    pub exchange_type: u8,
+    pub flags: IkeFlags,
+    pub message_id: u32,
+    pub length: u32,
+}
+
+impl View for IkeHeader<'_> {
+    type V = SpecIkeHeader;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkeHeader {
+            initiator_spi: self.initiator_spi@,
+            responder_spi: self.responder_spi@,
+            next_payload: self.next_payload@,
+            version: self.version@,
+            exchange_type: self.exchange_type@,
+            flags: self.flags@,
+            message_id: self.message_id@,
+            length: self.length@,
+        }
+    }
+}
+pub type IkeHeaderInner<'a> = (&'a [u8], (&'a [u8], (u8, (IkeVersionByte, (u8, (IkeFlags, (u32, u32)))))));
+
+pub type IkeHeaderInnerRef<'a> = (&'a &'a [u8], (&'a &'a [u8], (&'a u8, (&'a IkeVersionByte, (&'a u8, (&'a IkeFlags, (&'a u32, &'a u32)))))));
+impl<'a> From<&'a IkeHeader<'a>> for IkeHeaderInnerRef<'a> {
+    fn ex_from(m: &'a IkeHeader) -> IkeHeaderInnerRef<'a> {
+        (&m.initiator_spi, (&m.responder_spi, (&m.next_payload, (&m.version, (&m.exchange_type, (&m.flags, (&m.message_id, &m.length)))))))
+    }
+}
+
+impl<'a> From<IkeHeaderInner<'a>> for IkeHeader<'a> {
+    fn ex_from(m: IkeHeaderInner) -> IkeHeader {
+        let (initiator_spi, (responder_spi, (next_payload, (version, (exchange_type, (flags, (message_id, length))))))) = m;
+        IkeHeader { initiator_spi, responder_spi, next_payload, version, exchange_type, flags, message_id, length }
+    }
+}
+
+pub struct IkeHeaderMapper;
+impl View for IkeHeaderMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for IkeHeaderMapper {
+    type Src = SpecIkeHeaderInner;
+    type Dst = SpecIkeHeader;
+}
+impl SpecIsoProof for IkeHeaderMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for IkeHeaderMapper {
+    type Src = IkeHeaderInner<'a>;
+    type Dst = IkeHeader<'a>;
+    type RefSrc = IkeHeaderInnerRef<'a>;
+}
+type SpecIkeHeaderCombinatorAlias1 = (U32Be, Refined<U32Be, Predicate4866237765496934330>);
+type SpecIkeHeaderCombinatorAlias2 = (SpecIkeFlagsCombinator, SpecIkeHeaderCombinatorAlias1);
+type SpecIkeHeaderCombinatorAlias3 = (SpecExchangeTypeCombinator, SpecIkeHeaderCombinatorAlias2);
+type SpecIkeHeaderCombinatorAlias4 = (SpecIkeVersionByteCombinator, SpecIkeHeaderCombinatorAlias3);
+type SpecIkeHeaderCombinatorAlias5 = (SpecNextPayloadTypeCombinator, SpecIkeHeaderCombinatorAlias4);
+type SpecIkeHeaderCombinatorAlias6 = (bytes::Fixed<8>, SpecIkeHeaderCombinatorAlias5);
+type SpecIkeHeaderCombinatorAlias7 = (bytes::Fixed<8>, SpecIkeHeaderCombinatorAlias6);
+pub struct SpecIkeHeaderCombinator(pub SpecIkeHeaderCombinatorAlias);
+
+impl SpecCombinator for SpecIkeHeaderCombinator {
+    type Type = SpecIkeHeader;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkeHeaderCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkeHeaderCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkeHeaderCombinatorAlias = Mapped<SpecIkeHeaderCombinatorAlias7, IkeHeaderMapper>;
+pub struct Predicate4866237765496934330;
+impl View for Predicate4866237765496934330 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u32> for Predicate4866237765496934330 {
+    fn apply(&self, i: &u32) -> bool {
+        let i = (*i);
+        (i >= 28 && i <= 4294967295)
+    }
+}
+impl SpecPred<u32> for Predicate4866237765496934330 {
+    open spec fn spec_apply(&self, i: &u32) -> bool {
+        let i = (*i);
+        (i >= 28 && i <= 4294967295)
+    }
+}
+type IkeHeaderCombinatorAlias1 = (U32Be, Refined<U32Be, Predicate4866237765496934330>);
+type IkeHeaderCombinatorAlias2 = (IkeFlagsCombinator, IkeHeaderCombinator1);
+type IkeHeaderCombinatorAlias3 = (ExchangeTypeCombinator, IkeHeaderCombinator2);
+type IkeHeaderCombinatorAlias4 = (IkeVersionByteCombinator, IkeHeaderCombinator3);
+type IkeHeaderCombinatorAlias5 = (NextPayloadTypeCombinator, IkeHeaderCombinator4);
+type IkeHeaderCombinatorAlias6 = (bytes::Fixed<8>, IkeHeaderCombinator5);
+type IkeHeaderCombinatorAlias7 = (bytes::Fixed<8>, IkeHeaderCombinator6);
+pub struct IkeHeaderCombinator1(pub IkeHeaderCombinatorAlias1);
+impl View for IkeHeaderCombinator1 {
+    type V = SpecIkeHeaderCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(IkeHeaderCombinator1, IkeHeaderCombinatorAlias1);
+
+pub struct IkeHeaderCombinator2(pub IkeHeaderCombinatorAlias2);
+impl View for IkeHeaderCombinator2 {
+    type V = SpecIkeHeaderCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(IkeHeaderCombinator2, IkeHeaderCombinatorAlias2);
+
+pub struct IkeHeaderCombinator3(pub IkeHeaderCombinatorAlias3);
+impl View for IkeHeaderCombinator3 {
+    type V = SpecIkeHeaderCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(IkeHeaderCombinator3, IkeHeaderCombinatorAlias3);
+
+pub struct IkeHeaderCombinator4(pub IkeHeaderCombinatorAlias4);
+impl View for IkeHeaderCombinator4 {
+    type V = SpecIkeHeaderCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(IkeHeaderCombinator4, IkeHeaderCombinatorAlias4);
+
+pub struct IkeHeaderCombinator5(pub IkeHeaderCombinatorAlias5);
+impl View for IkeHeaderCombinator5 {
+    type V = SpecIkeHeaderCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(IkeHeaderCombinator5, IkeHeaderCombinatorAlias5);
+
+pub struct IkeHeaderCombinator6(pub IkeHeaderCombinatorAlias6);
+impl View for IkeHeaderCombinator6 {
+    type V = SpecIkeHeaderCombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(IkeHeaderCombinator6, IkeHeaderCombinatorAlias6);
+
+pub struct IkeHeaderCombinator7(pub IkeHeaderCombinatorAlias7);
+impl View for IkeHeaderCombinator7 {
+    type V = SpecIkeHeaderCombinatorAlias7;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(IkeHeaderCombinator7, IkeHeaderCombinatorAlias7);
+
+pub struct IkeHeaderCombinator(pub IkeHeaderCombinatorAlias);
+
+impl View for IkeHeaderCombinator {
+    type V = SpecIkeHeaderCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkeHeaderCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeHeaderCombinator {
+    type Type = IkeHeader<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type IkeHeaderCombinatorAlias = Mapped<IkeHeaderCombinator7, IkeHeaderMapper>;
+
+
+pub open spec fn spec_ike_header() -> SpecIkeHeaderCombinator {
+    SpecIkeHeaderCombinator(
+    Mapped {
+        inner: (bytes::Fixed::<8>, (bytes::Fixed::<8>, (spec_next_payload_type(), (spec_ike_version_byte(), (spec_exchange_type(), (spec_ike_flags(), (U32Be, Refined { inner: U32Be, predicate: Predicate4866237765496934330 }))))))),
+        mapper: IkeHeaderMapper,
+    })
+}
+
+                
+pub fn ike_header<'a>() -> (o: IkeHeaderCombinator)
+    ensures o@ == spec_ike_header(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = IkeHeaderCombinator(
+    Mapped {
+        inner: IkeHeaderCombinator7((bytes::Fixed::<8>, IkeHeaderCombinator6((bytes::Fixed::<8>, IkeHeaderCombinator5((next_payload_type(), IkeHeaderCombinator4((ike_version_byte(), IkeHeaderCombinator3((exchange_type(), IkeHeaderCombinator2((ike_flags(), IkeHeaderCombinator1((U32Be, Refined { inner: U32Be, predicate: Predicate4866237765496934330 })))))))))))))),
+        mapper: IkeHeaderMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ike_header()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ike_header<'a>(input: &'a [u8]) -> (res: PResult<<IkeHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ike_header().spec_parse(input@) == Some((n as int, v@)),
+        spec_ike_header().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ike_header().spec_parse(input@) is None,
+        spec_ike_header().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ike_header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ike_header<'a>(v: <IkeHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ike_header().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ike_header().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ike_header().spec_serialize(v@).len(),
+{
+    let combinator = ike_header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub type SpecDeletePayloadSpisNone = Seq<u8>;
+pub type DeletePayloadSpisNone<'a> = &'a [u8];
+pub type DeletePayloadSpisNoneRef<'a> = &'a &'a [u8];
+
+
+pub struct SpecDeletePayloadSpisNoneCombinator(pub SpecDeletePayloadSpisNoneCombinatorAlias);
+
+impl SpecCombinator for SpecDeletePayloadSpisNoneCombinator {
+    type Type = SpecDeletePayloadSpisNone;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecDeletePayloadSpisNoneCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDeletePayloadSpisNoneCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecDeletePayloadSpisNoneCombinatorAlias = bytes::Fixed<0>;
+
+pub struct DeletePayloadSpisNoneCombinator(pub DeletePayloadSpisNoneCombinatorAlias);
+
+impl View for DeletePayloadSpisNoneCombinator {
+    type V = SpecDeletePayloadSpisNoneCombinator;
+    open spec fn view(&self) -> Self::V { SpecDeletePayloadSpisNoneCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadSpisNoneCombinator {
+    type Type = DeletePayloadSpisNone<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type DeletePayloadSpisNoneCombinatorAlias = bytes::Fixed<0>;
+
+
+pub open spec fn spec_delete_payload_spis_none() -> SpecDeletePayloadSpisNoneCombinator {
+    SpecDeletePayloadSpisNoneCombinator(bytes::Fixed::<0>)
+}
+
+                
+pub fn delete_payload_spis_none<'a>() -> (o: DeletePayloadSpisNoneCombinator)
+    ensures o@ == spec_delete_payload_spis_none(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = DeletePayloadSpisNoneCombinator(bytes::Fixed::<0>);
+    // assert({
+    //     &&& combinator@ == spec_delete_payload_spis_none()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_delete_payload_spis_none<'a>(input: &'a [u8]) -> (res: PResult<<DeletePayloadSpisNoneCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_delete_payload_spis_none().spec_parse(input@) == Some((n as int, v@)),
+        spec_delete_payload_spis_none().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_delete_payload_spis_none().spec_parse(input@) is None,
+        spec_delete_payload_spis_none().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = delete_payload_spis_none();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_delete_payload_spis_none<'a>(v: <DeletePayloadSpisNoneCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_delete_payload_spis_none().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_delete_payload_spis_none().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_delete_payload_spis_none().spec_serialize(v@).len(),
+{
+    let combinator = delete_payload_spis_none();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecEapMessageSuccessFailure {
+    pub code: u8,
+    pub identifier: u8,
+    pub eap_length: u16,
+}
+
+pub type SpecEapMessageSuccessFailureInner = (u8, (u8, u16));
+
+
+impl SpecFrom<SpecEapMessageSuccessFailure> for SpecEapMessageSuccessFailureInner {
+    open spec fn spec_from(m: SpecEapMessageSuccessFailure) -> SpecEapMessageSuccessFailureInner {
+        (m.code, (m.identifier, m.eap_length))
+    }
+}
+
+impl SpecFrom<SpecEapMessageSuccessFailureInner> for SpecEapMessageSuccessFailure {
+    open spec fn spec_from(m: SpecEapMessageSuccessFailureInner) -> SpecEapMessageSuccessFailure {
+        let (code, (identifier, eap_length)) = m;
+        SpecEapMessageSuccessFailure { code, identifier, eap_length }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct EapMessageSuccessFailure {
+    pub code: u8,
+    pub identifier: u8,
+    pub eap_length: u16,
+}
+
+impl View for EapMessageSuccessFailure {
+    type V = SpecEapMessageSuccessFailure;
+
+    open spec fn view(&self) -> Self::V {
+        SpecEapMessageSuccessFailure {
+            code: self.code@,
+            identifier: self.identifier@,
+            eap_length: self.eap_length@,
+        }
+    }
+}
+pub type EapMessageSuccessFailureInner = (u8, (u8, u16));
+
+pub type EapMessageSuccessFailureInnerRef<'a> = (&'a u8, (&'a u8, &'a u16));
+impl<'a> From<&'a EapMessageSuccessFailure> for EapMessageSuccessFailureInnerRef<'a> {
+    fn ex_from(m: &'a EapMessageSuccessFailure) -> EapMessageSuccessFailureInnerRef<'a> {
+        (&m.code, (&m.identifier, &m.eap_length))
+    }
+}
+
+impl From<EapMessageSuccessFailureInner> for EapMessageSuccessFailure {
+    fn ex_from(m: EapMessageSuccessFailureInner) -> EapMessageSuccessFailure {
+        let (code, (identifier, eap_length)) = m;
+        EapMessageSuccessFailure { code, identifier, eap_length }
+    }
+}
+
+pub struct EapMessageSuccessFailureMapper;
+impl View for EapMessageSuccessFailureMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for EapMessageSuccessFailureMapper {
+    type Src = SpecEapMessageSuccessFailureInner;
+    type Dst = SpecEapMessageSuccessFailure;
+}
+impl SpecIsoProof for EapMessageSuccessFailureMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for EapMessageSuccessFailureMapper {
+    type Src = EapMessageSuccessFailureInner;
+    type Dst = EapMessageSuccessFailure;
+    type RefSrc = EapMessageSuccessFailureInnerRef<'a>;
+}
+pub const EAPMESSAGESUCCESSFAILUREEAP_LENGTH_CONST: u16 = 4;
+type SpecEapMessageSuccessFailureCombinatorAlias1 = (U8, Refined<U16Be, TagPred<u16>>);
+type SpecEapMessageSuccessFailureCombinatorAlias2 = (Refined<SpecEapCodeCombinator, Predicate7863829697870102672>, SpecEapMessageSuccessFailureCombinatorAlias1);
+pub struct SpecEapMessageSuccessFailureCombinator(pub SpecEapMessageSuccessFailureCombinatorAlias);
+
+impl SpecCombinator for SpecEapMessageSuccessFailureCombinator {
+    type Type = SpecEapMessageSuccessFailure;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecEapMessageSuccessFailureCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEapMessageSuccessFailureCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecEapMessageSuccessFailureCombinatorAlias = Mapped<SpecEapMessageSuccessFailureCombinatorAlias2, EapMessageSuccessFailureMapper>;
+pub struct Predicate7863829697870102672;
+impl View for Predicate7863829697870102672 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate7863829697870102672 {
+    fn apply(&self, e: &u8) -> bool {
+        (*e) == 3 || (*e) == 4
+    }
+}
+impl SpecPred<u8> for Predicate7863829697870102672 {
+    open spec fn spec_apply(&self, e: &u8) -> bool {
+        (*e) == 3 || (*e) == 4
+    }
+}
+type EapMessageSuccessFailureCombinatorAlias1 = (U8, Refined<U16Be, TagPred<u16>>);
+type EapMessageSuccessFailureCombinatorAlias2 = (Refined<EapCodeCombinator, Predicate7863829697870102672>, EapMessageSuccessFailureCombinator1);
+pub struct EapMessageSuccessFailureCombinator1(pub EapMessageSuccessFailureCombinatorAlias1);
+impl View for EapMessageSuccessFailureCombinator1 {
+    type V = SpecEapMessageSuccessFailureCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(EapMessageSuccessFailureCombinator1, EapMessageSuccessFailureCombinatorAlias1);
+
+pub struct EapMessageSuccessFailureCombinator2(pub EapMessageSuccessFailureCombinatorAlias2);
+impl View for EapMessageSuccessFailureCombinator2 {
+    type V = SpecEapMessageSuccessFailureCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(EapMessageSuccessFailureCombinator2, EapMessageSuccessFailureCombinatorAlias2);
+
+pub struct EapMessageSuccessFailureCombinator(pub EapMessageSuccessFailureCombinatorAlias);
+
+impl View for EapMessageSuccessFailureCombinator {
+    type V = SpecEapMessageSuccessFailureCombinator;
+    open spec fn view(&self) -> Self::V { SpecEapMessageSuccessFailureCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapMessageSuccessFailureCombinator {
+    type Type = EapMessageSuccessFailure;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type EapMessageSuccessFailureCombinatorAlias = Mapped<EapMessageSuccessFailureCombinator2, EapMessageSuccessFailureMapper>;
+
+
+pub open spec fn spec_eap_message_success_failure() -> SpecEapMessageSuccessFailureCombinator {
+    SpecEapMessageSuccessFailureCombinator(
+    Mapped {
+        inner: (Refined { inner: spec_eap_code(), predicate: Predicate7863829697870102672 }, (U8, Refined { inner: U16Be, predicate: TagPred(EAPMESSAGESUCCESSFAILUREEAP_LENGTH_CONST) })),
+        mapper: EapMessageSuccessFailureMapper,
+    })
+}
+
+                
+pub fn eap_message_success_failure<'a>() -> (o: EapMessageSuccessFailureCombinator)
+    ensures o@ == spec_eap_message_success_failure(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = EapMessageSuccessFailureCombinator(
+    Mapped {
+        inner: EapMessageSuccessFailureCombinator2((Refined { inner: eap_code(), predicate: Predicate7863829697870102672 }, EapMessageSuccessFailureCombinator1((U8, Refined { inner: U16Be, predicate: TagPred(EAPMESSAGESUCCESSFAILUREEAP_LENGTH_CONST) })))),
+        mapper: EapMessageSuccessFailureMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_eap_message_success_failure()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_eap_message_success_failure<'a>(input: &'a [u8]) -> (res: PResult<<EapMessageSuccessFailureCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_eap_message_success_failure().spec_parse(input@) == Some((n as int, v@)),
+        spec_eap_message_success_failure().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_eap_message_success_failure().spec_parse(input@) is None,
+        spec_eap_message_success_failure().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = eap_message_success_failure();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_eap_message_success_failure<'a>(v: <EapMessageSuccessFailureCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_message_success_failure().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_eap_message_success_failure().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_eap_message_success_failure().spec_serialize(v@).len(),
+{
+    let combinator = eap_message_success_failure();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecIkev2CertPayloadInner {
+    pub cert_encoding: u8,
+    pub cert_data: Seq<u8>,
+}
+
+pub type SpecIkev2CertPayloadInnerInner = (u8, Seq<u8>);
+
+
+impl SpecFrom<SpecIkev2CertPayloadInner> for SpecIkev2CertPayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2CertPayloadInner) -> SpecIkev2CertPayloadInnerInner {
+        (m.cert_encoding, m.cert_data)
+    }
+}
+
+impl SpecFrom<SpecIkev2CertPayloadInnerInner> for SpecIkev2CertPayloadInner {
+    open spec fn spec_from(m: SpecIkev2CertPayloadInnerInner) -> SpecIkev2CertPayloadInner {
+        let (cert_encoding, cert_data) = m;
+        SpecIkev2CertPayloadInner { cert_encoding, cert_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2CertPayloadInner<'a> {
+    pub cert_encoding: u8,
+    pub cert_data: &'a [u8],
+}
+
+impl View for Ikev2CertPayloadInner<'_> {
+    type V = SpecIkev2CertPayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2CertPayloadInner {
+            cert_encoding: self.cert_encoding@,
+            cert_data: self.cert_data@,
+        }
+    }
+}
+pub type Ikev2CertPayloadInnerInner<'a> = (u8, &'a [u8]);
+
+pub type Ikev2CertPayloadInnerInnerRef<'a> = (&'a u8, &'a &'a [u8]);
+impl<'a> From<&'a Ikev2CertPayloadInner<'a>> for Ikev2CertPayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2CertPayloadInner) -> Ikev2CertPayloadInnerInnerRef<'a> {
+        (&m.cert_encoding, &m.cert_data)
+    }
+}
+
+impl<'a> From<Ikev2CertPayloadInnerInner<'a>> for Ikev2CertPayloadInner<'a> {
+    fn ex_from(m: Ikev2CertPayloadInnerInner) -> Ikev2CertPayloadInner {
+        let (cert_encoding, cert_data) = m;
+        Ikev2CertPayloadInner { cert_encoding, cert_data }
+    }
+}
+
+pub struct Ikev2CertPayloadInnerMapper;
+impl View for Ikev2CertPayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2CertPayloadInnerMapper {
+    type Src = SpecIkev2CertPayloadInnerInner;
+    type Dst = SpecIkev2CertPayloadInner;
+}
+impl SpecIsoProof for Ikev2CertPayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2CertPayloadInnerMapper {
+    type Src = Ikev2CertPayloadInnerInner<'a>;
+    type Dst = Ikev2CertPayloadInner<'a>;
+    type RefSrc = Ikev2CertPayloadInnerInnerRef<'a>;
+}
+type SpecIkev2CertPayloadInnerCombinatorAlias1 = (SpecCertEncodingCombinator, bytes::Tail);
+pub struct SpecIkev2CertPayloadInnerCombinator(pub SpecIkev2CertPayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2CertPayloadInnerCombinator {
+    type Type = SpecIkev2CertPayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2CertPayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2CertPayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2CertPayloadInnerCombinatorAlias = Mapped<SpecIkev2CertPayloadInnerCombinatorAlias1, Ikev2CertPayloadInnerMapper>;
+type Ikev2CertPayloadInnerCombinatorAlias1 = (CertEncodingCombinator, bytes::Tail);
+pub struct Ikev2CertPayloadInnerCombinator1(pub Ikev2CertPayloadInnerCombinatorAlias1);
+impl View for Ikev2CertPayloadInnerCombinator1 {
+    type V = SpecIkev2CertPayloadInnerCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2CertPayloadInnerCombinator1, Ikev2CertPayloadInnerCombinatorAlias1);
+
+pub struct Ikev2CertPayloadInnerCombinator(pub Ikev2CertPayloadInnerCombinatorAlias);
+
+impl View for Ikev2CertPayloadInnerCombinator {
+    type V = SpecIkev2CertPayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2CertPayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2CertPayloadInnerCombinator {
+    type Type = Ikev2CertPayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2CertPayloadInnerCombinatorAlias = Mapped<Ikev2CertPayloadInnerCombinator1, Ikev2CertPayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_cert_payload_inner() -> SpecIkev2CertPayloadInnerCombinator {
+    SpecIkev2CertPayloadInnerCombinator(
+    Mapped {
+        inner: (spec_cert_encoding(), bytes::Tail),
+        mapper: Ikev2CertPayloadInnerMapper,
+    })
+}
+
+                
+pub fn ikev2_cert_payload_inner<'a>() -> (o: Ikev2CertPayloadInnerCombinator)
+    ensures o@ == spec_ikev2_cert_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2CertPayloadInnerCombinator(
+    Mapped {
+        inner: Ikev2CertPayloadInnerCombinator1((cert_encoding(), bytes::Tail)),
+        mapper: Ikev2CertPayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_cert_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_cert_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2CertPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_cert_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_cert_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_cert_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_cert_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_cert_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_cert_payload_inner<'a>(v: <Ikev2CertPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_cert_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_cert_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_cert_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_cert_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub mod AuthMethod {
+    use super::*;
+    pub spec const SPEC_RSADigitalSignature: u8 = 1;
+    pub spec const SPEC_SharedKeyMIC: u8 = 2;
+    pub spec const SPEC_DSSDigitalSignature: u8 = 3;
+    pub exec const RSADigitalSignature: u8 ensures RSADigitalSignature == SPEC_RSADigitalSignature { 1 }
+    pub exec const SharedKeyMIC: u8 ensures SharedKeyMIC == SPEC_SharedKeyMIC { 2 }
+    pub exec const DSSDigitalSignature: u8 ensures DSSDigitalSignature == SPEC_DSSDigitalSignature { 3 }
+}
+
+
+pub struct SpecAuthMethodCombinator(pub SpecAuthMethodCombinatorAlias);
+
+impl SpecCombinator for SpecAuthMethodCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecAuthMethodCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecAuthMethodCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecAuthMethodCombinatorAlias = U8;
+
+pub struct AuthMethodCombinator(pub AuthMethodCombinatorAlias);
+
+impl View for AuthMethodCombinator {
+    type V = SpecAuthMethodCombinator;
+    open spec fn view(&self) -> Self::V { SpecAuthMethodCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AuthMethodCombinator {
+    type Type = u8;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type AuthMethodCombinatorAlias = U8;
+
+
+pub open spec fn spec_auth_method() -> SpecAuthMethodCombinator {
+    SpecAuthMethodCombinator(U8)
+}
+
+                
+pub fn auth_method<'a>() -> (o: AuthMethodCombinator)
+    ensures o@ == spec_auth_method(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = AuthMethodCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_auth_method()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_auth_method<'a>(input: &'a [u8]) -> (res: PResult<<AuthMethodCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_auth_method().spec_parse(input@) == Some((n as int, v@)),
+        spec_auth_method().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_auth_method().spec_parse(input@) is None,
+        spec_auth_method().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = auth_method();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_auth_method<'a>(v: <AuthMethodCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_auth_method().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_auth_method().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_auth_method().spec_serialize(v@).len(),
+{
+    let combinator = auth_method();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecIkev2AuthPayloadInner {
+    pub auth_method: u8,
+    pub reserved: Seq<u8>,
+    pub auth_data: Seq<u8>,
+}
+
+pub type SpecIkev2AuthPayloadInnerInner = (u8, (Seq<u8>, Seq<u8>));
+
+
+impl SpecFrom<SpecIkev2AuthPayloadInner> for SpecIkev2AuthPayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2AuthPayloadInner) -> SpecIkev2AuthPayloadInnerInner {
+        (m.auth_method, (m.reserved, m.auth_data))
+    }
+}
+
+impl SpecFrom<SpecIkev2AuthPayloadInnerInner> for SpecIkev2AuthPayloadInner {
+    open spec fn spec_from(m: SpecIkev2AuthPayloadInnerInner) -> SpecIkev2AuthPayloadInner {
+        let (auth_method, (reserved, auth_data)) = m;
+        SpecIkev2AuthPayloadInner { auth_method, reserved, auth_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2AuthPayloadInner<'a> {
+    pub auth_method: u8,
+    pub reserved: &'a [u8],
+    pub auth_data: &'a [u8],
+}
+
+impl View for Ikev2AuthPayloadInner<'_> {
+    type V = SpecIkev2AuthPayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2AuthPayloadInner {
+            auth_method: self.auth_method@,
+            reserved: self.reserved@,
+            auth_data: self.auth_data@,
+        }
+    }
+}
+pub type Ikev2AuthPayloadInnerInner<'a> = (u8, (&'a [u8], &'a [u8]));
+
+pub type Ikev2AuthPayloadInnerInnerRef<'a> = (&'a u8, (&'a &'a [u8], &'a &'a [u8]));
+impl<'a> From<&'a Ikev2AuthPayloadInner<'a>> for Ikev2AuthPayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2AuthPayloadInner) -> Ikev2AuthPayloadInnerInnerRef<'a> {
+        (&m.auth_method, (&m.reserved, &m.auth_data))
+    }
+}
+
+impl<'a> From<Ikev2AuthPayloadInnerInner<'a>> for Ikev2AuthPayloadInner<'a> {
+    fn ex_from(m: Ikev2AuthPayloadInnerInner) -> Ikev2AuthPayloadInner {
+        let (auth_method, (reserved, auth_data)) = m;
+        Ikev2AuthPayloadInner { auth_method, reserved, auth_data }
+    }
+}
+
+pub struct Ikev2AuthPayloadInnerMapper;
+impl View for Ikev2AuthPayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2AuthPayloadInnerMapper {
+    type Src = SpecIkev2AuthPayloadInnerInner;
+    type Dst = SpecIkev2AuthPayloadInner;
+}
+impl SpecIsoProof for Ikev2AuthPayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2AuthPayloadInnerMapper {
+    type Src = Ikev2AuthPayloadInnerInner<'a>;
+    type Dst = Ikev2AuthPayloadInner<'a>;
+    type RefSrc = Ikev2AuthPayloadInnerInnerRef<'a>;
+}
+pub spec const SPEC_IKEV2AUTHPAYLOADINNERRESERVED_CONST: Seq<u8> = seq![0; 3];type SpecIkev2AuthPayloadInnerCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, bytes::Tail);
+type SpecIkev2AuthPayloadInnerCombinatorAlias2 = (SpecAuthMethodCombinator, SpecIkev2AuthPayloadInnerCombinatorAlias1);
+pub struct SpecIkev2AuthPayloadInnerCombinator(pub SpecIkev2AuthPayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2AuthPayloadInnerCombinator {
+    type Type = SpecIkev2AuthPayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2AuthPayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2AuthPayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2AuthPayloadInnerCombinatorAlias = Mapped<SpecIkev2AuthPayloadInnerCombinatorAlias2, Ikev2AuthPayloadInnerMapper>;
+pub exec static IKEV2AUTHPAYLOADINNERRESERVED_CONST: [u8; 3]
+    ensures IKEV2AUTHPAYLOADINNERRESERVED_CONST@ == SPEC_IKEV2AUTHPAYLOADINNERRESERVED_CONST,
+{
+    let arr: [u8; 3] = [0; 3];
+    assert(arr@ == SPEC_IKEV2AUTHPAYLOADINNERRESERVED_CONST);
+    arr
+}
+type Ikev2AuthPayloadInnerCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, bytes::Tail);
+type Ikev2AuthPayloadInnerCombinatorAlias2 = (AuthMethodCombinator, Ikev2AuthPayloadInnerCombinator1);
+pub struct Ikev2AuthPayloadInnerCombinator1(pub Ikev2AuthPayloadInnerCombinatorAlias1);
+impl View for Ikev2AuthPayloadInnerCombinator1 {
+    type V = SpecIkev2AuthPayloadInnerCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2AuthPayloadInnerCombinator1, Ikev2AuthPayloadInnerCombinatorAlias1);
+
+pub struct Ikev2AuthPayloadInnerCombinator2(pub Ikev2AuthPayloadInnerCombinatorAlias2);
+impl View for Ikev2AuthPayloadInnerCombinator2 {
+    type V = SpecIkev2AuthPayloadInnerCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2AuthPayloadInnerCombinator2, Ikev2AuthPayloadInnerCombinatorAlias2);
+
+pub struct Ikev2AuthPayloadInnerCombinator(pub Ikev2AuthPayloadInnerCombinatorAlias);
+
+impl View for Ikev2AuthPayloadInnerCombinator {
+    type V = SpecIkev2AuthPayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2AuthPayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2AuthPayloadInnerCombinator {
+    type Type = Ikev2AuthPayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2AuthPayloadInnerCombinatorAlias = Mapped<Ikev2AuthPayloadInnerCombinator2, Ikev2AuthPayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_auth_payload_inner() -> SpecIkev2AuthPayloadInnerCombinator {
+    SpecIkev2AuthPayloadInnerCombinator(
+    Mapped {
+        inner: (spec_auth_method(), (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(SPEC_IKEV2AUTHPAYLOADINNERRESERVED_CONST) }, bytes::Tail)),
+        mapper: Ikev2AuthPayloadInnerMapper,
+    })
+}
+
+                
+pub fn ikev2_auth_payload_inner<'a>() -> (o: Ikev2AuthPayloadInnerCombinator)
+    ensures o@ == spec_ikev2_auth_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2AuthPayloadInnerCombinator(
+    Mapped {
+        inner: Ikev2AuthPayloadInnerCombinator2((auth_method(), Ikev2AuthPayloadInnerCombinator1((Refined { inner: bytes::Fixed::<3>, predicate: TagPred(IKEV2AUTHPAYLOADINNERRESERVED_CONST) }, bytes::Tail)))),
+        mapper: Ikev2AuthPayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_auth_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_auth_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2AuthPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_auth_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_auth_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_auth_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_auth_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_auth_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_auth_payload_inner<'a>(v: <Ikev2AuthPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_auth_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_auth_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_auth_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_auth_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecIkev2NoncePayloadInner {
+    pub nonce_data: Seq<u8>,
+}
+
+pub type SpecIkev2NoncePayloadInnerInner = Seq<u8>;
+
+
+impl SpecFrom<SpecIkev2NoncePayloadInner> for SpecIkev2NoncePayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2NoncePayloadInner) -> SpecIkev2NoncePayloadInnerInner {
+        m.nonce_data
+    }
+}
+
+impl SpecFrom<SpecIkev2NoncePayloadInnerInner> for SpecIkev2NoncePayloadInner {
+    open spec fn spec_from(m: SpecIkev2NoncePayloadInnerInner) -> SpecIkev2NoncePayloadInner {
+        let nonce_data = m;
+        SpecIkev2NoncePayloadInner { nonce_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2NoncePayloadInner<'a> {
+    pub nonce_data: &'a [u8],
+}
+
+impl View for Ikev2NoncePayloadInner<'_> {
+    type V = SpecIkev2NoncePayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2NoncePayloadInner {
+            nonce_data: self.nonce_data@,
+        }
+    }
+}
+pub type Ikev2NoncePayloadInnerInner<'a> = &'a [u8];
+
+pub type Ikev2NoncePayloadInnerInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a Ikev2NoncePayloadInner<'a>> for Ikev2NoncePayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2NoncePayloadInner) -> Ikev2NoncePayloadInnerInnerRef<'a> {
+        &m.nonce_data
+    }
+}
+
+impl<'a> From<Ikev2NoncePayloadInnerInner<'a>> for Ikev2NoncePayloadInner<'a> {
+    fn ex_from(m: Ikev2NoncePayloadInnerInner) -> Ikev2NoncePayloadInner {
+        let nonce_data = m;
+        Ikev2NoncePayloadInner { nonce_data }
+    }
+}
+
+pub struct Ikev2NoncePayloadInnerMapper;
+impl View for Ikev2NoncePayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2NoncePayloadInnerMapper {
+    type Src = SpecIkev2NoncePayloadInnerInner;
+    type Dst = SpecIkev2NoncePayloadInner;
+}
+impl SpecIsoProof for Ikev2NoncePayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2NoncePayloadInnerMapper {
+    type Src = Ikev2NoncePayloadInnerInner<'a>;
+    type Dst = Ikev2NoncePayloadInner<'a>;
+    type RefSrc = Ikev2NoncePayloadInnerInnerRef<'a>;
+}
+
+pub struct SpecIkev2NoncePayloadInnerCombinator(pub SpecIkev2NoncePayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2NoncePayloadInnerCombinator {
+    type Type = SpecIkev2NoncePayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2NoncePayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2NoncePayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2NoncePayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2NoncePayloadInnerMapper>;
+
+pub struct Ikev2NoncePayloadInnerCombinator(pub Ikev2NoncePayloadInnerCombinatorAlias);
+
+impl View for Ikev2NoncePayloadInnerCombinator {
+    type V = SpecIkev2NoncePayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2NoncePayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2NoncePayloadInnerCombinator {
+    type Type = Ikev2NoncePayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2NoncePayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2NoncePayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_nonce_payload_inner() -> SpecIkev2NoncePayloadInnerCombinator {
+    SpecIkev2NoncePayloadInnerCombinator(
+    Mapped {
+        inner: bytes::Tail,
+        mapper: Ikev2NoncePayloadInnerMapper,
+    })
+}
+
+                
+pub fn ikev2_nonce_payload_inner<'a>() -> (o: Ikev2NoncePayloadInnerCombinator)
+    ensures o@ == spec_ikev2_nonce_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2NoncePayloadInnerCombinator(
+    Mapped {
+        inner: bytes::Tail,
+        mapper: Ikev2NoncePayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_nonce_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_nonce_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2NoncePayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_nonce_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_nonce_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_nonce_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_nonce_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_nonce_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_nonce_payload_inner<'a>(v: <Ikev2NoncePayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_nonce_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_nonce_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_nonce_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_nonce_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecIkev2VendorIdPayloadInner {
+    pub vendor_id: Seq<u8>,
+}
+
+pub type SpecIkev2VendorIdPayloadInnerInner = Seq<u8>;
+
+
+impl SpecFrom<SpecIkev2VendorIdPayloadInner> for SpecIkev2VendorIdPayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2VendorIdPayloadInner) -> SpecIkev2VendorIdPayloadInnerInner {
+        m.vendor_id
+    }
+}
+
+impl SpecFrom<SpecIkev2VendorIdPayloadInnerInner> for SpecIkev2VendorIdPayloadInner {
+    open spec fn spec_from(m: SpecIkev2VendorIdPayloadInnerInner) -> SpecIkev2VendorIdPayloadInner {
+        let vendor_id = m;
+        SpecIkev2VendorIdPayloadInner { vendor_id }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2VendorIdPayloadInner<'a> {
+    pub vendor_id: &'a [u8],
+}
+
+impl View for Ikev2VendorIdPayloadInner<'_> {
+    type V = SpecIkev2VendorIdPayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2VendorIdPayloadInner {
+            vendor_id: self.vendor_id@,
+        }
+    }
+}
+pub type Ikev2VendorIdPayloadInnerInner<'a> = &'a [u8];
+
+pub type Ikev2VendorIdPayloadInnerInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a Ikev2VendorIdPayloadInner<'a>> for Ikev2VendorIdPayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2VendorIdPayloadInner) -> Ikev2VendorIdPayloadInnerInnerRef<'a> {
+        &m.vendor_id
+    }
+}
+
+impl<'a> From<Ikev2VendorIdPayloadInnerInner<'a>> for Ikev2VendorIdPayloadInner<'a> {
+    fn ex_from(m: Ikev2VendorIdPayloadInnerInner) -> Ikev2VendorIdPayloadInner {
+        let vendor_id = m;
+        Ikev2VendorIdPayloadInner { vendor_id }
+    }
+}
+
+pub struct Ikev2VendorIdPayloadInnerMapper;
+impl View for Ikev2VendorIdPayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2VendorIdPayloadInnerMapper {
+    type Src = SpecIkev2VendorIdPayloadInnerInner;
+    type Dst = SpecIkev2VendorIdPayloadInner;
+}
+impl SpecIsoProof for Ikev2VendorIdPayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2VendorIdPayloadInnerMapper {
+    type Src = Ikev2VendorIdPayloadInnerInner<'a>;
+    type Dst = Ikev2VendorIdPayloadInner<'a>;
+    type RefSrc = Ikev2VendorIdPayloadInnerInnerRef<'a>;
+}
+
+pub struct SpecIkev2VendorIdPayloadInnerCombinator(pub SpecIkev2VendorIdPayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2VendorIdPayloadInnerCombinator {
+    type Type = SpecIkev2VendorIdPayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2VendorIdPayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2VendorIdPayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2VendorIdPayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2VendorIdPayloadInnerMapper>;
+
+pub struct Ikev2VendorIdPayloadInnerCombinator(pub Ikev2VendorIdPayloadInnerCombinatorAlias);
+
+impl View for Ikev2VendorIdPayloadInnerCombinator {
+    type V = SpecIkev2VendorIdPayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2VendorIdPayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2VendorIdPayloadInnerCombinator {
+    type Type = Ikev2VendorIdPayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2VendorIdPayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2VendorIdPayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_vendor_id_payload_inner() -> SpecIkev2VendorIdPayloadInnerCombinator {
+    SpecIkev2VendorIdPayloadInnerCombinator(
+    Mapped {
+        inner: bytes::Tail,
+        mapper: Ikev2VendorIdPayloadInnerMapper,
+    })
+}
+
+                
+pub fn ikev2_vendor_id_payload_inner<'a>() -> (o: Ikev2VendorIdPayloadInnerCombinator)
+    ensures o@ == spec_ikev2_vendor_id_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2VendorIdPayloadInnerCombinator(
+    Mapped {
+        inner: bytes::Tail,
+        mapper: Ikev2VendorIdPayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_vendor_id_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_vendor_id_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2VendorIdPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_vendor_id_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_vendor_id_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_vendor_id_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_vendor_id_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_vendor_id_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_vendor_id_payload_inner<'a>(v: <Ikev2VendorIdPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_vendor_id_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_vendor_id_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_vendor_id_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_vendor_id_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecSkPayloadBody {
+    pub encrypted_body: Seq<u8>,
+}
+
+pub type SpecSkPayloadBodyInner = Seq<u8>;
+
+
+impl SpecFrom<SpecSkPayloadBody> for SpecSkPayloadBodyInner {
+    open spec fn spec_from(m: SpecSkPayloadBody) -> SpecSkPayloadBodyInner {
+        m.encrypted_body
+    }
+}
+
+impl SpecFrom<SpecSkPayloadBodyInner> for SpecSkPayloadBody {
+    open spec fn spec_from(m: SpecSkPayloadBodyInner) -> SpecSkPayloadBody {
+        let encrypted_body = m;
+        SpecSkPayloadBody { encrypted_body }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct SkPayloadBody<'a> {
+    pub encrypted_body: &'a [u8],
+}
+
+impl View for SkPayloadBody<'_> {
+    type V = SpecSkPayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecSkPayloadBody {
+            encrypted_body: self.encrypted_body@,
+        }
+    }
+}
+pub type SkPayloadBodyInner<'a> = &'a [u8];
+
+pub type SkPayloadBodyInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a SkPayloadBody<'a>> for SkPayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a SkPayloadBody) -> SkPayloadBodyInnerRef<'a> {
+        &m.encrypted_body
+    }
+}
+
+impl<'a> From<SkPayloadBodyInner<'a>> for SkPayloadBody<'a> {
+    fn ex_from(m: SkPayloadBodyInner) -> SkPayloadBody {
+        let encrypted_body = m;
+        SkPayloadBody { encrypted_body }
+    }
+}
+
+pub struct SkPayloadBodyMapper;
+impl View for SkPayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for SkPayloadBodyMapper {
+    type Src = SpecSkPayloadBodyInner;
+    type Dst = SpecSkPayloadBody;
+}
+impl SpecIsoProof for SkPayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for SkPayloadBodyMapper {
+    type Src = SkPayloadBodyInner<'a>;
+    type Dst = SkPayloadBody<'a>;
+    type RefSrc = SkPayloadBodyInnerRef<'a>;
+}
+
+pub struct SpecSkPayloadBodyCombinator(pub SpecSkPayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecSkPayloadBodyCombinator {
+    type Type = SpecSkPayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecSkPayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSkPayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecSkPayloadBodyCombinatorAlias = Mapped<bytes::Variable, SkPayloadBodyMapper>;
+
+pub struct SkPayloadBodyCombinator(pub SkPayloadBodyCombinatorAlias);
+
+impl View for SkPayloadBodyCombinator {
+    type V = SpecSkPayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecSkPayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SkPayloadBodyCombinator {
+    type Type = SkPayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type SkPayloadBodyCombinatorAlias = Mapped<bytes::Variable, SkPayloadBodyMapper>;
+
+
+pub open spec fn spec_sk_payload_body(payload_length: u16) -> SpecSkPayloadBodyCombinator {
+    SpecSkPayloadBodyCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::spec_from(payload_length) - 4)) as usize),
+        mapper: SkPayloadBodyMapper,
+    })
+}
+
+pub fn sk_payload_body<'a>(payload_length: u16) -> (o: SkPayloadBodyCombinator)
+    requires
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures o@ == spec_sk_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = SkPayloadBodyCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::ex_from(payload_length) - 4)) as usize),
+        mapper: SkPayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_sk_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_sk_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<SkPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_sk_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_sk_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_sk_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_sk_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = sk_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_sk_payload_body<'a>(v: <SkPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_sk_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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)
+    requires
+        spec_sk_payload_body(payload_length@).wf(v@),
+        spec_sk_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_sk_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = sk_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub spec const SPEC_NotifyProtocolId_NotifyNoSpi: u8 = 0;
+pub spec const SPEC_NotifyProtocolId_NotifyAH: u8 = 2;
+pub spec const SPEC_NotifyProtocolId_NotifyESP: u8 = 3;
+pub exec static EXEC_NotifyProtocolId_NotifyNoSpi: u8 ensures EXEC_NotifyProtocolId_NotifyNoSpi == SPEC_NotifyProtocolId_NotifyNoSpi { 0 }
+pub exec static EXEC_NotifyProtocolId_NotifyAH: u8 ensures EXEC_NotifyProtocolId_NotifyAH == SPEC_NotifyProtocolId_NotifyAH { 2 }
+pub exec static EXEC_NotifyProtocolId_NotifyESP: u8 ensures EXEC_NotifyProtocolId_NotifyESP == SPEC_NotifyProtocolId_NotifyESP { 3 }
+
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum NotifyProtocolId {
+    NotifyNoSpi = 0,
+NotifyAH = 2,
+NotifyESP = 3
+}
+pub type SpecNotifyProtocolId = NotifyProtocolId;
+
+pub type NotifyProtocolIdInner = u8;
+
+pub type NotifyProtocolIdInnerRef<'a> = &'a u8;
+
+impl View for NotifyProtocolId {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecTryFrom<NotifyProtocolIdInner> for NotifyProtocolId {
+    type Error = ();
+
+    open spec fn spec_try_from(v: NotifyProtocolIdInner) -> Result<NotifyProtocolId, ()> {
+        match v {
+            0u8 => Ok(NotifyProtocolId::NotifyNoSpi),
+            2u8 => Ok(NotifyProtocolId::NotifyAH),
+            3u8 => Ok(NotifyProtocolId::NotifyESP),
+            _ => Err(()),
+        }
+    }
+}
+
+impl SpecTryFrom<NotifyProtocolId> for NotifyProtocolIdInner {
+    type Error = ();
+
+    open spec fn spec_try_from(v: NotifyProtocolId) -> Result<NotifyProtocolIdInner, ()> {
+        match v {
+            NotifyProtocolId::NotifyNoSpi => Ok(SPEC_NotifyProtocolId_NotifyNoSpi),
+            NotifyProtocolId::NotifyAH => Ok(SPEC_NotifyProtocolId_NotifyAH),
+            NotifyProtocolId::NotifyESP => Ok(SPEC_NotifyProtocolId_NotifyESP),
+        }
+    }
+}
+
+impl TryFrom<NotifyProtocolIdInner> for NotifyProtocolId {
+    type Error = ();
+
+    fn ex_try_from(v: NotifyProtocolIdInner) -> Result<NotifyProtocolId, ()> {
+        match v {
+            0u8 => Ok(NotifyProtocolId::NotifyNoSpi),
+            2u8 => Ok(NotifyProtocolId::NotifyAH),
+            3u8 => Ok(NotifyProtocolId::NotifyESP),
+            _ => Err(()),
+        }
+    }
+}
+
+impl<'a> TryFrom<&'a NotifyProtocolId> for NotifyProtocolIdInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a NotifyProtocolId) -> Result<NotifyProtocolIdInnerRef<'a>, ()> {
+        match v {
+            NotifyProtocolId::NotifyNoSpi => Ok(&EXEC_NotifyProtocolId_NotifyNoSpi),
+            NotifyProtocolId::NotifyAH => Ok(&EXEC_NotifyProtocolId_NotifyAH),
+            NotifyProtocolId::NotifyESP => Ok(&EXEC_NotifyProtocolId_NotifyESP),
+        }
+    }
+}
+
+pub struct NotifyProtocolIdMapper;
+
+impl View for NotifyProtocolIdMapper {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecPartialIso for NotifyProtocolIdMapper {
+    type Src = NotifyProtocolIdInner;
+    type Dst = NotifyProtocolId;
+}
+
+impl SpecPartialIsoProof for NotifyProtocolIdMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+}
+
+impl<'a> PartialIso<'a> for NotifyProtocolIdMapper {
+    type Src = NotifyProtocolIdInner;
+    type Dst = NotifyProtocolId;
+    type RefSrc = NotifyProtocolIdInnerRef<'a>;
+}
+
+
+pub struct SpecNotifyProtocolIdCombinator(pub SpecNotifyProtocolIdCombinatorAlias);
+
+impl SpecCombinator for SpecNotifyProtocolIdCombinator {
+    type Type = SpecNotifyProtocolId;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNotifyProtocolIdCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNotifyProtocolIdCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNotifyProtocolIdCombinatorAlias = TryMap<U8, NotifyProtocolIdMapper>;
+
+pub struct NotifyProtocolIdCombinator(pub NotifyProtocolIdCombinatorAlias);
+
+impl View for NotifyProtocolIdCombinator {
+    type V = SpecNotifyProtocolIdCombinator;
+    open spec fn view(&self) -> Self::V { SpecNotifyProtocolIdCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyProtocolIdCombinator {
+    type Type = NotifyProtocolId;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NotifyProtocolIdCombinatorAlias = TryMap<U8, NotifyProtocolIdMapper>;
+
+
+pub open spec fn spec_notify_protocol_id() -> SpecNotifyProtocolIdCombinator {
+    SpecNotifyProtocolIdCombinator(TryMap { inner: U8, mapper: NotifyProtocolIdMapper })
+}
+
+                
+pub fn notify_protocol_id<'a>() -> (o: NotifyProtocolIdCombinator)
+    ensures o@ == spec_notify_protocol_id(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NotifyProtocolIdCombinator(TryMap { inner: U8, mapper: NotifyProtocolIdMapper });
+    // assert({
+    //     &&& combinator@ == spec_notify_protocol_id()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_notify_protocol_id<'a>(input: &'a [u8]) -> (res: PResult<<NotifyProtocolIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_notify_protocol_id().spec_parse(input@) == Some((n as int, v@)),
+        spec_notify_protocol_id().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_notify_protocol_id().spec_parse(input@) is None,
+        spec_notify_protocol_id().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = notify_protocol_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_notify_protocol_id<'a>(v: <NotifyProtocolIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_notify_protocol_id().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_notify_protocol_id().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_notify_protocol_id().spec_serialize(v@).len(),
+{
+    let combinator = notify_protocol_id();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecIkev2NotifyPayloadInner {
+    pub protocol_id: SpecNotifyProtocolId,
+    pub spi_size: SpecIpsecSpiSizeOrNone,
+    pub notify_msg_type: u16,
+    pub spi: Seq<u8>,
+    pub notification_data: Seq<u8>,
+}
+
+pub type SpecIkev2NotifyPayloadInnerInner = ((SpecNotifyProtocolId, SpecIpsecSpiSizeOrNone), (u16, (Seq<u8>, Seq<u8>)));
+
+
+impl SpecFrom<SpecIkev2NotifyPayloadInner> for SpecIkev2NotifyPayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2NotifyPayloadInner) -> SpecIkev2NotifyPayloadInnerInner {
+        ((m.protocol_id, m.spi_size), (m.notify_msg_type, (m.spi, m.notification_data)))
+    }
+}
+
+impl SpecFrom<SpecIkev2NotifyPayloadInnerInner> for SpecIkev2NotifyPayloadInner {
+    open spec fn spec_from(m: SpecIkev2NotifyPayloadInnerInner) -> SpecIkev2NotifyPayloadInner {
+        let ((protocol_id, spi_size), (notify_msg_type, (spi, notification_data))) = m;
+        SpecIkev2NotifyPayloadInner { protocol_id, spi_size, notify_msg_type, spi, notification_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2NotifyPayloadInner<'a> {
+    pub protocol_id: NotifyProtocolId,
+    pub spi_size: IpsecSpiSizeOrNone,
+    pub notify_msg_type: u16,
+    pub spi: &'a [u8],
+    pub notification_data: &'a [u8],
+}
+
+impl View for Ikev2NotifyPayloadInner<'_> {
+    type V = SpecIkev2NotifyPayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2NotifyPayloadInner {
+            protocol_id: self.protocol_id@,
+            spi_size: self.spi_size@,
+            notify_msg_type: self.notify_msg_type@,
+            spi: self.spi@,
+            notification_data: self.notification_data@,
+        }
+    }
+}
+pub type Ikev2NotifyPayloadInnerInner<'a> = ((NotifyProtocolId, IpsecSpiSizeOrNone), (u16, (&'a [u8], &'a [u8])));
+
+pub type Ikev2NotifyPayloadInnerInnerRef<'a> = ((&'a NotifyProtocolId, &'a IpsecSpiSizeOrNone), (&'a u16, (&'a &'a [u8], &'a &'a [u8])));
+impl<'a> From<&'a Ikev2NotifyPayloadInner<'a>> for Ikev2NotifyPayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2NotifyPayloadInner) -> Ikev2NotifyPayloadInnerInnerRef<'a> {
+        ((&m.protocol_id, &m.spi_size), (&m.notify_msg_type, (&m.spi, &m.notification_data)))
+    }
+}
+
+impl<'a> From<Ikev2NotifyPayloadInnerInner<'a>> for Ikev2NotifyPayloadInner<'a> {
+    fn ex_from(m: Ikev2NotifyPayloadInnerInner) -> Ikev2NotifyPayloadInner {
+        let ((protocol_id, spi_size), (notify_msg_type, (spi, notification_data))) = m;
+        Ikev2NotifyPayloadInner { protocol_id, spi_size, notify_msg_type, spi, notification_data }
+    }
+}
+
+pub struct Ikev2NotifyPayloadInnerMapper;
+impl View for Ikev2NotifyPayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2NotifyPayloadInnerMapper {
+    type Src = SpecIkev2NotifyPayloadInnerInner;
+    type Dst = SpecIkev2NotifyPayloadInner;
+}
+impl SpecIsoProof for Ikev2NotifyPayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2NotifyPayloadInnerMapper {
+    type Src = Ikev2NotifyPayloadInnerInner<'a>;
+    type Dst = Ikev2NotifyPayloadInner<'a>;
+    type RefSrc = Ikev2NotifyPayloadInnerInnerRef<'a>;
+}
+
+pub struct SpecIkev2NotifyPayloadInnerCombinator(pub SpecIkev2NotifyPayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2NotifyPayloadInnerCombinator {
+    type Type = SpecIkev2NotifyPayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2NotifyPayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2NotifyPayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2NotifyPayloadInnerCombinatorAlias = Mapped<SpecPair<SpecPair<SpecNotifyProtocolIdCombinator, SpecIpsecSpiSizeOrNoneCombinator>, (SpecNotifyMsgTypeCombinator, (bytes::Variable, bytes::Tail))>, Ikev2NotifyPayloadInnerMapper>;
+
+pub struct Ikev2NotifyPayloadInnerCombinator(pub Ikev2NotifyPayloadInnerCombinatorAlias);
+
+impl View for Ikev2NotifyPayloadInnerCombinator {
+    type V = SpecIkev2NotifyPayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2NotifyPayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2NotifyPayloadInnerCombinator {
+    type Type = Ikev2NotifyPayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2NotifyPayloadInnerCombinatorAlias = Mapped<Pair<Pair<NotifyProtocolIdCombinator, IpsecSpiSizeOrNoneCombinator, Ikev2NotifyPayloadInnerCont1>, (NotifyMsgTypeCombinator, (bytes::Variable, bytes::Tail)), Ikev2NotifyPayloadInnerCont0>, Ikev2NotifyPayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_notify_payload_inner() -> SpecIkev2NotifyPayloadInnerCombinator {
+    SpecIkev2NotifyPayloadInnerCombinator(
+    Mapped {
+        inner: Pair::spec_new(Pair::spec_new(spec_notify_protocol_id(), |deps| spec_ikev2_notify_payload_inner_cont1(deps)), |deps| spec_ikev2_notify_payload_inner_cont0(deps)),
+        mapper: Ikev2NotifyPayloadInnerMapper,
+    })
+}
+
+pub open spec fn spec_ikev2_notify_payload_inner_cont1(deps: SpecNotifyProtocolId) -> SpecIpsecSpiSizeOrNoneCombinator {
+    let protocol_id = deps;
+    spec_ipsec_spi_size_or_none()
+}
+
+impl View for Ikev2NotifyPayloadInnerCont1 {
+    type V = spec_fn(SpecNotifyProtocolId) -> SpecIpsecSpiSizeOrNoneCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: SpecNotifyProtocolId| {
+            spec_ikev2_notify_payload_inner_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_ikev2_notify_payload_inner_cont0(deps: (SpecNotifyProtocolId, SpecIpsecSpiSizeOrNone)) -> (SpecNotifyMsgTypeCombinator, (bytes::Variable, bytes::Tail)) {
+    let (protocol_id, spi_size) = deps;
+    (spec_notify_msg_type(), (bytes::Variable((usize::spec_from(spi_size)) as usize), bytes::Tail))
+}
+
+impl View for Ikev2NotifyPayloadInnerCont0 {
+    type V = spec_fn((SpecNotifyProtocolId, SpecIpsecSpiSizeOrNone)) -> (SpecNotifyMsgTypeCombinator, (bytes::Variable, bytes::Tail));
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (SpecNotifyProtocolId, SpecIpsecSpiSizeOrNone)| {
+            spec_ikev2_notify_payload_inner_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn ikev2_notify_payload_inner<'a>() -> (o: Ikev2NotifyPayloadInnerCombinator)
+    ensures o@ == spec_ikev2_notify_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2NotifyPayloadInnerCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(notify_protocol_id(), Ikev2NotifyPayloadInnerCont1), Ikev2NotifyPayloadInnerCont0),
+        mapper: Ikev2NotifyPayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_notify_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_notify_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2NotifyPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_notify_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_notify_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_notify_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_notify_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_notify_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_notify_payload_inner<'a>(v: <Ikev2NotifyPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_notify_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_notify_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_notify_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_notify_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct Ikev2NotifyPayloadInnerCont1;
+type Ikev2NotifyPayloadInnerCont1Type<'a, 'b> = &'b NotifyProtocolId;
+type Ikev2NotifyPayloadInnerCont1SType<'a, 'x> = &'x NotifyProtocolId;
+type Ikev2NotifyPayloadInnerCont1Input<'a, 'b, 'x> = POrSType<Ikev2NotifyPayloadInnerCont1Type<'a, 'b>, Ikev2NotifyPayloadInnerCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Ikev2NotifyPayloadInnerCont1Input<'a, 'b, 'x>> for Ikev2NotifyPayloadInnerCont1 {
+    type Output = IpsecSpiSizeOrNoneCombinator;
+
+    open spec fn requires(&self, deps: Ikev2NotifyPayloadInnerCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_notify_protocol_id()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: Ikev2NotifyPayloadInnerCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_ikev2_notify_payload_inner_cont1(deps@)
+    }
+
+    fn apply(&self, deps: Ikev2NotifyPayloadInnerCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let protocol_id = deps;
+                let protocol_id = *protocol_id;
+                ipsec_spi_size_or_none()
+            }
+            POrSType::S(deps) => {
+                let protocol_id = deps;
+                let protocol_id = *protocol_id;
+                ipsec_spi_size_or_none()
+            }
+        }
+    }
+}
+pub struct Ikev2NotifyPayloadInnerCont0;
+type Ikev2NotifyPayloadInnerCont0Type<'a, 'b> = &'b (NotifyProtocolId, IpsecSpiSizeOrNone);
+type Ikev2NotifyPayloadInnerCont0SType<'a, 'x> = (&'x NotifyProtocolId, &'x IpsecSpiSizeOrNone);
+type Ikev2NotifyPayloadInnerCont0Input<'a, 'b, 'x> = POrSType<Ikev2NotifyPayloadInnerCont0Type<'a, 'b>, Ikev2NotifyPayloadInnerCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Ikev2NotifyPayloadInnerCont0Input<'a, 'b, 'x>> for Ikev2NotifyPayloadInnerCont0 {
+    type Output = (NotifyMsgTypeCombinator, (bytes::Variable, bytes::Tail));
+
+    open spec fn requires(&self, deps: Ikev2NotifyPayloadInnerCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_notify_protocol_id(), |deps| spec_ikev2_notify_payload_inner_cont1(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: Ikev2NotifyPayloadInnerCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_ikev2_notify_payload_inner_cont0(deps@)
+    }
+
+    fn apply(&self, deps: Ikev2NotifyPayloadInnerCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (protocol_id, spi_size) = deps;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                (notify_msg_type(), (bytes::Variable((usize::ex_from(spi_size)) as usize), bytes::Tail))
+            }
+            POrSType::S(deps) => {
+                let (protocol_id, spi_size) = deps;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                (notify_msg_type(), (bytes::Variable((usize::ex_from(spi_size)) as usize), bytes::Tail))
+            }
+        }
+    }
+}
+                
+pub type SpecDeletePayloadSpisIpsec = Seq<u32>;
+pub type DeletePayloadSpisIpsec = RepeatResult<u32>;
+pub type DeletePayloadSpisIpsecRef<'a> = &'a RepeatResult<u32>;
+
+
+pub struct SpecDeletePayloadSpisIpsecCombinator(pub SpecDeletePayloadSpisIpsecCombinatorAlias);
+
+impl SpecCombinator for SpecDeletePayloadSpisIpsecCombinator {
+    type Type = SpecDeletePayloadSpisIpsec;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecDeletePayloadSpisIpsecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDeletePayloadSpisIpsecCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecDeletePayloadSpisIpsecCombinatorAlias = RepeatN<U32Be>;
+
+pub struct DeletePayloadSpisIpsecCombinator(pub DeletePayloadSpisIpsecCombinatorAlias);
+
+impl View for DeletePayloadSpisIpsecCombinator {
+    type V = SpecDeletePayloadSpisIpsecCombinator;
+    open spec fn view(&self) -> Self::V { SpecDeletePayloadSpisIpsecCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadSpisIpsecCombinator {
+    type Type = DeletePayloadSpisIpsec;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type DeletePayloadSpisIpsecCombinatorAlias = RepeatN<U32Be>;
+
+
+pub open spec fn spec_delete_payload_spis_ipsec(num_spis: u16) -> SpecDeletePayloadSpisIpsecCombinator {
+    SpecDeletePayloadSpisIpsecCombinator(RepeatN(U32Be, (usize::spec_from(num_spis)) as usize))
+}
+
+pub fn delete_payload_spis_ipsec<'a>(num_spis: u16) -> (o: DeletePayloadSpisIpsecCombinator)
+
+    ensures o@ == spec_delete_payload_spis_ipsec(num_spis@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = DeletePayloadSpisIpsecCombinator(RepeatN(U32Be, (usize::ex_from(num_spis)) as usize));
+    // assert({
+    //     &&& combinator@ == spec_delete_payload_spis_ipsec(num_spis@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_delete_payload_spis_ipsec<'a>(input: &'a [u8], num_spis: u16) -> (res: PResult<<DeletePayloadSpisIpsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+
+    ensures
+        res matches Ok((n, v)) ==> spec_delete_payload_spis_ipsec(num_spis@).spec_parse(input@) == Some((n as int, v@)),
+        spec_delete_payload_spis_ipsec(num_spis@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_delete_payload_spis_ipsec(num_spis@).spec_parse(input@) is None,
+        spec_delete_payload_spis_ipsec(num_spis@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = delete_payload_spis_ipsec( num_spis );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_delete_payload_spis_ipsec<'a>(v: <DeletePayloadSpisIpsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num_spis: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_delete_payload_spis_ipsec(num_spis@).wf(v@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_delete_payload_spis_ipsec(num_spis@).spec_serialize(v@).len() <= usize::MAX,
+
+    ensures
+        serialize_len == spec_delete_payload_spis_ipsec(num_spis@).spec_serialize(v@).len(),
+{
+    let combinator = delete_payload_spis_ipsec( num_spis );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecEapMessageReqResp {
+    pub code: u8,
+    pub identifier: u8,
+    pub eap_length: u16,
+    pub eap_type: u8,
+    pub type_data: Seq<u8>,
+}
+
+pub type SpecEapMessageReqRespInner = ((u8, (u8, u16)), (u8, Seq<u8>));
+
+
+impl SpecFrom<SpecEapMessageReqResp> for SpecEapMessageReqRespInner {
+    open spec fn spec_from(m: SpecEapMessageReqResp) -> SpecEapMessageReqRespInner {
+        ((m.code, (m.identifier, m.eap_length)), (m.eap_type, m.type_data))
+    }
+}
+
+impl SpecFrom<SpecEapMessageReqRespInner> for SpecEapMessageReqResp {
+    open spec fn spec_from(m: SpecEapMessageReqRespInner) -> SpecEapMessageReqResp {
+        let ((code, (identifier, eap_length)), (eap_type, type_data)) = m;
+        SpecEapMessageReqResp { code, identifier, eap_length, eap_type, type_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct EapMessageReqResp<'a> {
+    pub code: u8,
+    pub identifier: u8,
+    pub eap_length: u16,
+    pub eap_type: u8,
+    pub type_data: &'a [u8],
+}
+
+impl View for EapMessageReqResp<'_> {
+    type V = SpecEapMessageReqResp;
+
+    open spec fn view(&self) -> Self::V {
+        SpecEapMessageReqResp {
+            code: self.code@,
+            identifier: self.identifier@,
+            eap_length: self.eap_length@,
+            eap_type: self.eap_type@,
+            type_data: self.type_data@,
+        }
+    }
+}
+pub type EapMessageReqRespInner<'a> = ((u8, (u8, u16)), (u8, &'a [u8]));
+
+pub type EapMessageReqRespInnerRef<'a> = ((&'a u8, (&'a u8, &'a u16)), (&'a u8, &'a &'a [u8]));
+impl<'a> From<&'a EapMessageReqResp<'a>> for EapMessageReqRespInnerRef<'a> {
+    fn ex_from(m: &'a EapMessageReqResp) -> EapMessageReqRespInnerRef<'a> {
+        ((&m.code, (&m.identifier, &m.eap_length)), (&m.eap_type, &m.type_data))
+    }
+}
+
+impl<'a> From<EapMessageReqRespInner<'a>> for EapMessageReqResp<'a> {
+    fn ex_from(m: EapMessageReqRespInner) -> EapMessageReqResp {
+        let ((code, (identifier, eap_length)), (eap_type, type_data)) = m;
+        EapMessageReqResp { code, identifier, eap_length, eap_type, type_data }
+    }
+}
+
+pub struct EapMessageReqRespMapper;
+impl View for EapMessageReqRespMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for EapMessageReqRespMapper {
+    type Src = SpecEapMessageReqRespInner;
+    type Dst = SpecEapMessageReqResp;
+}
+impl SpecIsoProof for EapMessageReqRespMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for EapMessageReqRespMapper {
+    type Src = EapMessageReqRespInner<'a>;
+    type Dst = EapMessageReqResp<'a>;
+    type RefSrc = EapMessageReqRespInnerRef<'a>;
+}
+
+pub struct SpecEapMessageReqRespCombinator(pub SpecEapMessageReqRespCombinatorAlias);
+
+impl SpecCombinator for SpecEapMessageReqRespCombinator {
+    type Type = SpecEapMessageReqResp;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecEapMessageReqRespCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEapMessageReqRespCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecEapMessageReqRespCombinatorAlias = Mapped<SpecPair<(Refined<SpecEapCodeCombinator, Predicate8053454275691315570>, (U8, Refined<U16Be, Predicate7010197279221949030>)), (U8, bytes::Variable)>, EapMessageReqRespMapper>;
+pub struct Predicate8053454275691315570;
+impl View for Predicate8053454275691315570 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate8053454275691315570 {
+    fn apply(&self, e: &u8) -> bool {
+        (*e) == 1 || (*e) == 2
+    }
+}
+impl SpecPred<u8> for Predicate8053454275691315570 {
+    open spec fn spec_apply(&self, e: &u8) -> bool {
+        (*e) == 1 || (*e) == 2
+    }
+}
+
+pub struct EapMessageReqRespCombinator(pub EapMessageReqRespCombinatorAlias);
+
+impl View for EapMessageReqRespCombinator {
+    type V = SpecEapMessageReqRespCombinator;
+    open spec fn view(&self) -> Self::V { SpecEapMessageReqRespCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EapMessageReqRespCombinator {
+    type Type = EapMessageReqResp<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type EapMessageReqRespCombinatorAlias = Mapped<Pair<(Refined<EapCodeCombinator, Predicate8053454275691315570>, (U8, Refined<U16Be, Predicate7010197279221949030>)), (U8, bytes::Variable), EapMessageReqRespCont0>, EapMessageReqRespMapper>;
+
+
+pub open spec fn spec_eap_message_req_resp() -> SpecEapMessageReqRespCombinator {
+    SpecEapMessageReqRespCombinator(
+    Mapped {
+        inner: Pair::spec_new((Refined { inner: spec_eap_code(), predicate: Predicate8053454275691315570 }, (U8, Refined { inner: U16Be, predicate: Predicate7010197279221949030 })), |deps| spec_eap_message_req_resp_cont0(deps)),
+        mapper: EapMessageReqRespMapper,
+    })
+}
+
+pub open spec fn spec_eap_message_req_resp_cont0(deps: (u8, (u8, u16))) -> (U8, bytes::Variable) {
+    let (_, (_, eap_length)) = deps;
+    (U8, bytes::Variable(((usize::spec_from(eap_length) - 5)) as usize))
+}
+
+impl View for EapMessageReqRespCont0 {
+    type V = spec_fn((u8, (u8, u16))) -> (U8, bytes::Variable);
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u8, (u8, u16))| {
+            spec_eap_message_req_resp_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn eap_message_req_resp<'a>() -> (o: EapMessageReqRespCombinator)
+    ensures o@ == spec_eap_message_req_resp(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = EapMessageReqRespCombinator(
+    Mapped {
+        inner: Pair::new((Refined { inner: eap_code(), predicate: Predicate8053454275691315570 }, (U8, Refined { inner: U16Be, predicate: Predicate7010197279221949030 })), EapMessageReqRespCont0),
+        mapper: EapMessageReqRespMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_eap_message_req_resp()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_eap_message_req_resp<'a>(input: &'a [u8]) -> (res: PResult<<EapMessageReqRespCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_eap_message_req_resp().spec_parse(input@) == Some((n as int, v@)),
+        spec_eap_message_req_resp().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_eap_message_req_resp().spec_parse(input@) is None,
+        spec_eap_message_req_resp().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = eap_message_req_resp();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_eap_message_req_resp<'a>(v: <EapMessageReqRespCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_eap_message_req_resp().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_eap_message_req_resp().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_eap_message_req_resp().spec_serialize(v@).len(),
+{
+    let combinator = eap_message_req_resp();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct EapMessageReqRespCont0;
+type EapMessageReqRespCont0Type<'a, 'b> = &'b (u8, (u8, u16));
+type EapMessageReqRespCont0SType<'a, 'x> = (&'x u8, (&'x u8, &'x u16));
+type EapMessageReqRespCont0Input<'a, 'b, 'x> = POrSType<EapMessageReqRespCont0Type<'a, 'b>, EapMessageReqRespCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<EapMessageReqRespCont0Input<'a, 'b, 'x>> for EapMessageReqRespCont0 {
+    type Output = (U8, bytes::Variable);
+
+    open spec fn requires(&self, deps: EapMessageReqRespCont0Input<'a, 'b, 'x>) -> bool {
+        &&& ((Refined { inner: spec_eap_code(), predicate: Predicate8053454275691315570 }, (U8, Refined { inner: U16Be, predicate: Predicate7010197279221949030 }))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: EapMessageReqRespCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_eap_message_req_resp_cont0(deps@)
+    }
+
+    fn apply(&self, deps: EapMessageReqRespCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (_, (_, eap_length)) = deps;
+                let eap_length = *eap_length;
+                (U8, bytes::Variable(((usize::ex_from(eap_length) - 5)) as usize))
+            }
+            POrSType::S(deps) => {
+                let (_, (_, eap_length)) = deps;
+                let eap_length = *eap_length;
+                (U8, bytes::Variable(((usize::ex_from(eap_length) - 5)) as usize))
+            }
+        }
+    }
+}
+                
+
+pub struct SpecNotifyPayloadBodySpi4 {
+    pub spi: Seq<u8>,
+    pub notification_data: Seq<u8>,
+}
+
+pub type SpecNotifyPayloadBodySpi4Inner = (Seq<u8>, Seq<u8>);
+
+
+impl SpecFrom<SpecNotifyPayloadBodySpi4> for SpecNotifyPayloadBodySpi4Inner {
+    open spec fn spec_from(m: SpecNotifyPayloadBodySpi4) -> SpecNotifyPayloadBodySpi4Inner {
+        (m.spi, m.notification_data)
+    }
+}
+
+impl SpecFrom<SpecNotifyPayloadBodySpi4Inner> for SpecNotifyPayloadBodySpi4 {
+    open spec fn spec_from(m: SpecNotifyPayloadBodySpi4Inner) -> SpecNotifyPayloadBodySpi4 {
+        let (spi, notification_data) = m;
+        SpecNotifyPayloadBodySpi4 { spi, notification_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct NotifyPayloadBodySpi4<'a> {
+    pub spi: &'a [u8],
+    pub notification_data: &'a [u8],
+}
+
+impl View for NotifyPayloadBodySpi4<'_> {
+    type V = SpecNotifyPayloadBodySpi4;
+
+    open spec fn view(&self) -> Self::V {
+        SpecNotifyPayloadBodySpi4 {
+            spi: self.spi@,
+            notification_data: self.notification_data@,
+        }
+    }
+}
+pub type NotifyPayloadBodySpi4Inner<'a> = (&'a [u8], &'a [u8]);
+
+pub type NotifyPayloadBodySpi4InnerRef<'a> = (&'a &'a [u8], &'a &'a [u8]);
+impl<'a> From<&'a NotifyPayloadBodySpi4<'a>> for NotifyPayloadBodySpi4InnerRef<'a> {
+    fn ex_from(m: &'a NotifyPayloadBodySpi4) -> NotifyPayloadBodySpi4InnerRef<'a> {
+        (&m.spi, &m.notification_data)
+    }
+}
+
+impl<'a> From<NotifyPayloadBodySpi4Inner<'a>> for NotifyPayloadBodySpi4<'a> {
+    fn ex_from(m: NotifyPayloadBodySpi4Inner) -> NotifyPayloadBodySpi4 {
+        let (spi, notification_data) = m;
+        NotifyPayloadBodySpi4 { spi, notification_data }
+    }
+}
+
+pub struct NotifyPayloadBodySpi4Mapper;
+impl View for NotifyPayloadBodySpi4Mapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for NotifyPayloadBodySpi4Mapper {
+    type Src = SpecNotifyPayloadBodySpi4Inner;
+    type Dst = SpecNotifyPayloadBodySpi4;
+}
+impl SpecIsoProof for NotifyPayloadBodySpi4Mapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for NotifyPayloadBodySpi4Mapper {
+    type Src = NotifyPayloadBodySpi4Inner<'a>;
+    type Dst = NotifyPayloadBodySpi4<'a>;
+    type RefSrc = NotifyPayloadBodySpi4InnerRef<'a>;
+}
+type SpecNotifyPayloadBodySpi4CombinatorAlias1 = (bytes::Fixed<4>, bytes::Tail);
+pub struct SpecNotifyPayloadBodySpi4Combinator(pub SpecNotifyPayloadBodySpi4CombinatorAlias);
+
+impl SpecCombinator for SpecNotifyPayloadBodySpi4Combinator {
+    type Type = SpecNotifyPayloadBodySpi4;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNotifyPayloadBodySpi4Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNotifyPayloadBodySpi4CombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNotifyPayloadBodySpi4CombinatorAlias = Mapped<SpecNotifyPayloadBodySpi4CombinatorAlias1, NotifyPayloadBodySpi4Mapper>;
+type NotifyPayloadBodySpi4CombinatorAlias1 = (bytes::Fixed<4>, bytes::Tail);
+pub struct NotifyPayloadBodySpi4Combinator1(pub NotifyPayloadBodySpi4CombinatorAlias1);
+impl View for NotifyPayloadBodySpi4Combinator1 {
+    type V = SpecNotifyPayloadBodySpi4CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(NotifyPayloadBodySpi4Combinator1, NotifyPayloadBodySpi4CombinatorAlias1);
+
+pub struct NotifyPayloadBodySpi4Combinator(pub NotifyPayloadBodySpi4CombinatorAlias);
+
+impl View for NotifyPayloadBodySpi4Combinator {
+    type V = SpecNotifyPayloadBodySpi4Combinator;
+    open spec fn view(&self) -> Self::V { SpecNotifyPayloadBodySpi4Combinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodySpi4Combinator {
+    type Type = NotifyPayloadBodySpi4<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NotifyPayloadBodySpi4CombinatorAlias = Mapped<NotifyPayloadBodySpi4Combinator1, NotifyPayloadBodySpi4Mapper>;
+
+
+pub open spec fn spec_notify_payload_body_spi4() -> SpecNotifyPayloadBodySpi4Combinator {
+    SpecNotifyPayloadBodySpi4Combinator(
+    Mapped {
+        inner: (bytes::Fixed::<4>, bytes::Tail),
+        mapper: NotifyPayloadBodySpi4Mapper,
+    })
+}
+
+                
+pub fn notify_payload_body_spi4<'a>() -> (o: NotifyPayloadBodySpi4Combinator)
+    ensures o@ == spec_notify_payload_body_spi4(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NotifyPayloadBodySpi4Combinator(
+    Mapped {
+        inner: NotifyPayloadBodySpi4Combinator1((bytes::Fixed::<4>, bytes::Tail)),
+        mapper: NotifyPayloadBodySpi4Mapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_notify_payload_body_spi4()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_notify_payload_body_spi4<'a>(input: &'a [u8]) -> (res: PResult<<NotifyPayloadBodySpi4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_notify_payload_body_spi4().spec_parse(input@) == Some((n as int, v@)),
+        spec_notify_payload_body_spi4().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_notify_payload_body_spi4().spec_parse(input@) is None,
+        spec_notify_payload_body_spi4().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = notify_payload_body_spi4();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_notify_payload_body_spi4<'a>(v: <NotifyPayloadBodySpi4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_notify_payload_body_spi4().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_notify_payload_body_spi4().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_notify_payload_body_spi4().spec_serialize(v@).len(),
+{
+    let combinator = notify_payload_body_spi4();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub enum SpecNotifyPayloadBodyRest {
+    Variant0(SpecNotifyPayloadBodySpi0),
+    Variant1(SpecNotifyPayloadBodySpi4),
+}
+
+pub type SpecNotifyPayloadBodyRestInner = Either<SpecNotifyPayloadBodySpi0, SpecNotifyPayloadBodySpi4>;
+
+impl SpecFrom<SpecNotifyPayloadBodyRest> for SpecNotifyPayloadBodyRestInner {
+    open spec fn spec_from(m: SpecNotifyPayloadBodyRest) -> SpecNotifyPayloadBodyRestInner {
+        match m {
+            SpecNotifyPayloadBodyRest::Variant0(m) => Either::Left(m),
+            SpecNotifyPayloadBodyRest::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecNotifyPayloadBodyRestInner> for SpecNotifyPayloadBodyRest {
+    open spec fn spec_from(m: SpecNotifyPayloadBodyRestInner) -> SpecNotifyPayloadBodyRest {
+        match m {
+            Either::Left(m) => SpecNotifyPayloadBodyRest::Variant0(m),
+            Either::Right(m) => SpecNotifyPayloadBodyRest::Variant1(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum NotifyPayloadBodyRest<'a> {
+    Variant0(NotifyPayloadBodySpi0<'a>),
+    Variant1(NotifyPayloadBodySpi4<'a>),
+}
+
+pub type NotifyPayloadBodyRestInner<'a> = Either<NotifyPayloadBodySpi0<'a>, NotifyPayloadBodySpi4<'a>>;
+
+pub type NotifyPayloadBodyRestInnerRef<'a> = Either<&'a NotifyPayloadBodySpi0<'a>, &'a NotifyPayloadBodySpi4<'a>>;
+
+
+impl<'a> View for NotifyPayloadBodyRest<'a> {
+    type V = SpecNotifyPayloadBodyRest;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            NotifyPayloadBodyRest::Variant0(m) => SpecNotifyPayloadBodyRest::Variant0(m@),
+            NotifyPayloadBodyRest::Variant1(m) => SpecNotifyPayloadBodyRest::Variant1(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a NotifyPayloadBodyRest<'a>> for NotifyPayloadBodyRestInnerRef<'a> {
+    fn ex_from(m: &'a NotifyPayloadBodyRest<'a>) -> NotifyPayloadBodyRestInnerRef<'a> {
+        match m {
+            NotifyPayloadBodyRest::Variant0(m) => Either::Left(m),
+            NotifyPayloadBodyRest::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+impl<'a> From<NotifyPayloadBodyRestInner<'a>> for NotifyPayloadBodyRest<'a> {
+    fn ex_from(m: NotifyPayloadBodyRestInner<'a>) -> NotifyPayloadBodyRest<'a> {
+        match m {
+            Either::Left(m) => NotifyPayloadBodyRest::Variant0(m),
+            Either::Right(m) => NotifyPayloadBodyRest::Variant1(m),
+        }
+    }
+    
+}
+
+
+pub struct NotifyPayloadBodyRestMapper;
+impl View for NotifyPayloadBodyRestMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for NotifyPayloadBodyRestMapper {
+    type Src = SpecNotifyPayloadBodyRestInner;
+    type Dst = SpecNotifyPayloadBodyRest;
+}
+impl SpecIsoProof for NotifyPayloadBodyRestMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for NotifyPayloadBodyRestMapper {
+    type Src = NotifyPayloadBodyRestInner<'a>;
+    type Dst = NotifyPayloadBodyRest<'a>;
+    type RefSrc = NotifyPayloadBodyRestInnerRef<'a>;
+}
+
+type SpecNotifyPayloadBodyRestCombinatorAlias1 = Choice<Cond<SpecNotifyPayloadBodySpi0Combinator>, Cond<SpecNotifyPayloadBodySpi4Combinator>>;
+pub struct SpecNotifyPayloadBodyRestCombinator(pub SpecNotifyPayloadBodyRestCombinatorAlias);
+
+impl SpecCombinator for SpecNotifyPayloadBodyRestCombinator {
+    type Type = SpecNotifyPayloadBodyRest;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNotifyPayloadBodyRestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNotifyPayloadBodyRestCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNotifyPayloadBodyRestCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecNotifyPayloadBodyRestCombinatorAlias1, NotifyPayloadBodyRestMapper>>;
+type NotifyPayloadBodyRestCombinatorAlias1 = Choice<Cond<NotifyPayloadBodySpi0Combinator>, Cond<NotifyPayloadBodySpi4Combinator>>;
+pub struct NotifyPayloadBodyRestCombinator1(pub NotifyPayloadBodyRestCombinatorAlias1);
+impl View for NotifyPayloadBodyRestCombinator1 {
+    type V = SpecNotifyPayloadBodyRestCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(NotifyPayloadBodyRestCombinator1, NotifyPayloadBodyRestCombinatorAlias1);
+
+pub struct NotifyPayloadBodyRestCombinator(pub NotifyPayloadBodyRestCombinatorAlias);
+
+impl View for NotifyPayloadBodyRestCombinator {
+    type V = SpecNotifyPayloadBodyRestCombinator;
+    open spec fn view(&self) -> Self::V { SpecNotifyPayloadBodyRestCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodyRestCombinator {
+    type Type = NotifyPayloadBodyRest<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NotifyPayloadBodyRestCombinatorAlias = AndThen<bytes::Variable, Mapped<NotifyPayloadBodyRestCombinator1, NotifyPayloadBodyRestMapper>>;
+
+
+pub open spec fn spec_notify_payload_body_rest(payload_length: u16, spi_size: SpecIpsecSpiSizeOrNone) -> SpecNotifyPayloadBodyRestCombinator {
+    SpecNotifyPayloadBodyRestCombinator(AndThen(bytes::Variable(((usize::spec_from(payload_length) - 8)) as usize), Mapped { inner: Choice(Cond { cond: spi_size == 0, inner: spec_notify_payload_body_spi0() }, Cond { cond: spi_size == 4, inner: spec_notify_payload_body_spi4() }), mapper: NotifyPayloadBodyRestMapper }))
+}
+
+pub fn notify_payload_body_rest<'a>(payload_length: u16, spi_size: IpsecSpiSizeOrNone) -> (o: NotifyPayloadBodyRestCombinator)
+    requires
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+        spec_ipsec_spi_size_or_none().wf(spi_size@),
+
+    ensures o@ == spec_notify_payload_body_rest(payload_length@, spi_size@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NotifyPayloadBodyRestCombinator(AndThen(bytes::Variable(((usize::ex_from(payload_length) - 8)) as usize), Mapped { inner: NotifyPayloadBodyRestCombinator1(Choice::new(Cond { cond: spi_size == 0, inner: notify_payload_body_spi0() }, Cond { cond: spi_size == 4, inner: notify_payload_body_spi4() })), mapper: NotifyPayloadBodyRestMapper }));
+    // assert({
+    //     &&& combinator@ == spec_notify_payload_body_rest(payload_length@, spi_size@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_notify_payload_body_rest<'a>(input: &'a [u8], payload_length: u16, spi_size: IpsecSpiSizeOrNone) -> (res: PResult<<NotifyPayloadBodyRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+        spec_ipsec_spi_size_or_none().wf(spi_size@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_notify_payload_body_rest(payload_length@, spi_size@).spec_parse(input@) == Some((n as int, v@)),
+        spec_notify_payload_body_rest(payload_length@, spi_size@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_notify_payload_body_rest(payload_length@, spi_size@).spec_parse(input@) is None,
+        spec_notify_payload_body_rest(payload_length@, spi_size@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = notify_payload_body_rest( payload_length, spi_size );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_notify_payload_body_rest<'a>(v: <NotifyPayloadBodyRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16, spi_size: IpsecSpiSizeOrNone) -> (o: SResult<usize, SerializeError>)
+    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@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_notify_payload_body_rest(payload_length@, spi_size@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+        spec_ipsec_spi_size_or_none().wf(spi_size@),
+
+    ensures
+        serialize_len == spec_notify_payload_body_rest(payload_length@, spi_size@).spec_serialize(v@).len(),
+{
+    let combinator = notify_payload_body_rest( payload_length, spi_size );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecNotifyPayloadBody {
+    pub protocol_id: SpecNotifyProtocolId,
+    pub spi_size: SpecIpsecSpiSizeOrNone,
+    pub notify_msg_type: u16,
+    pub rest: SpecNotifyPayloadBodyRest,
+}
+
+pub type SpecNotifyPayloadBodyInner = ((SpecNotifyProtocolId, SpecIpsecSpiSizeOrNone), (u16, SpecNotifyPayloadBodyRest));
+
+
+impl SpecFrom<SpecNotifyPayloadBody> for SpecNotifyPayloadBodyInner {
+    open spec fn spec_from(m: SpecNotifyPayloadBody) -> SpecNotifyPayloadBodyInner {
+        ((m.protocol_id, m.spi_size), (m.notify_msg_type, m.rest))
+    }
+}
+
+impl SpecFrom<SpecNotifyPayloadBodyInner> for SpecNotifyPayloadBody {
+    open spec fn spec_from(m: SpecNotifyPayloadBodyInner) -> SpecNotifyPayloadBody {
+        let ((protocol_id, spi_size), (notify_msg_type, rest)) = m;
+        SpecNotifyPayloadBody { protocol_id, spi_size, notify_msg_type, rest }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct NotifyPayloadBody<'a> {
+    pub protocol_id: NotifyProtocolId,
+    pub spi_size: IpsecSpiSizeOrNone,
+    pub notify_msg_type: u16,
+    pub rest: NotifyPayloadBodyRest<'a>,
+}
+
+impl View for NotifyPayloadBody<'_> {
+    type V = SpecNotifyPayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecNotifyPayloadBody {
+            protocol_id: self.protocol_id@,
+            spi_size: self.spi_size@,
+            notify_msg_type: self.notify_msg_type@,
+            rest: self.rest@,
+        }
+    }
+}
+pub type NotifyPayloadBodyInner<'a> = ((NotifyProtocolId, IpsecSpiSizeOrNone), (u16, NotifyPayloadBodyRest<'a>));
+
+pub type NotifyPayloadBodyInnerRef<'a> = ((&'a NotifyProtocolId, &'a IpsecSpiSizeOrNone), (&'a u16, &'a NotifyPayloadBodyRest<'a>));
+impl<'a> From<&'a NotifyPayloadBody<'a>> for NotifyPayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a NotifyPayloadBody) -> NotifyPayloadBodyInnerRef<'a> {
+        ((&m.protocol_id, &m.spi_size), (&m.notify_msg_type, &m.rest))
+    }
+}
+
+impl<'a> From<NotifyPayloadBodyInner<'a>> for NotifyPayloadBody<'a> {
+    fn ex_from(m: NotifyPayloadBodyInner) -> NotifyPayloadBody {
+        let ((protocol_id, spi_size), (notify_msg_type, rest)) = m;
+        NotifyPayloadBody { protocol_id, spi_size, notify_msg_type, rest }
+    }
+}
+
+pub struct NotifyPayloadBodyMapper;
+impl View for NotifyPayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for NotifyPayloadBodyMapper {
+    type Src = SpecNotifyPayloadBodyInner;
+    type Dst = SpecNotifyPayloadBody;
+}
+impl SpecIsoProof for NotifyPayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for NotifyPayloadBodyMapper {
+    type Src = NotifyPayloadBodyInner<'a>;
+    type Dst = NotifyPayloadBody<'a>;
+    type RefSrc = NotifyPayloadBodyInnerRef<'a>;
+}
+
+pub struct SpecNotifyPayloadBodyCombinator(pub SpecNotifyPayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecNotifyPayloadBodyCombinator {
+    type Type = SpecNotifyPayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNotifyPayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNotifyPayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNotifyPayloadBodyCombinatorAlias = Mapped<SpecPair<SpecPair<SpecNotifyProtocolIdCombinator, SpecIpsecSpiSizeOrNoneCombinator>, (SpecNotifyMsgTypeCombinator, SpecNotifyPayloadBodyRestCombinator)>, NotifyPayloadBodyMapper>;
+
+pub struct NotifyPayloadBodyCombinator(pub NotifyPayloadBodyCombinatorAlias);
+
+impl View for NotifyPayloadBodyCombinator {
+    type V = SpecNotifyPayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecNotifyPayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NotifyPayloadBodyCombinator {
+    type Type = NotifyPayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NotifyPayloadBodyCombinatorAlias = Mapped<Pair<Pair<NotifyProtocolIdCombinator, IpsecSpiSizeOrNoneCombinator, NotifyPayloadBodyCont1>, (NotifyMsgTypeCombinator, NotifyPayloadBodyRestCombinator), NotifyPayloadBodyCont0>, NotifyPayloadBodyMapper>;
+
+
+pub open spec fn spec_notify_payload_body(payload_length: u16) -> SpecNotifyPayloadBodyCombinator {
+    SpecNotifyPayloadBodyCombinator(
+    Mapped {
+        inner: Pair::spec_new(Pair::spec_new(spec_notify_protocol_id(), |deps| spec_notify_payload_body_cont1(payload_length, deps)), |deps| spec_notify_payload_body_cont0(payload_length, deps)),
+        mapper: NotifyPayloadBodyMapper,
+    })
+}
+
+pub open spec fn spec_notify_payload_body_cont1(payload_length: u16, deps: SpecNotifyProtocolId) -> SpecIpsecSpiSizeOrNoneCombinator {
+    let protocol_id = deps;
+    spec_ipsec_spi_size_or_none()
+}
+
+impl View for NotifyPayloadBodyCont1 {
+    type V = spec_fn(SpecNotifyProtocolId) -> SpecIpsecSpiSizeOrNoneCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: SpecNotifyProtocolId| {
+            spec_notify_payload_body_cont1(self.payload_length@, deps)
+        }
+    }
+}
+
+pub open spec fn spec_notify_payload_body_cont0(payload_length: u16, deps: (SpecNotifyProtocolId, SpecIpsecSpiSizeOrNone)) -> (SpecNotifyMsgTypeCombinator, SpecNotifyPayloadBodyRestCombinator) {
+    let (protocol_id, spi_size) = deps;
+    (spec_notify_msg_type(), spec_notify_payload_body_rest(payload_length, spi_size))
+}
+
+impl View for NotifyPayloadBodyCont0 {
+    type V = spec_fn((SpecNotifyProtocolId, SpecIpsecSpiSizeOrNone)) -> (SpecNotifyMsgTypeCombinator, SpecNotifyPayloadBodyRestCombinator);
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (SpecNotifyProtocolId, SpecIpsecSpiSizeOrNone)| {
+            spec_notify_payload_body_cont0(self.payload_length@, deps)
+        }
+    }
+}
+
+pub fn notify_payload_body<'a>(payload_length: u16) -> (o: NotifyPayloadBodyCombinator)
+    requires
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures o@ == spec_notify_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NotifyPayloadBodyCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(notify_protocol_id(), NotifyPayloadBodyCont1 { payload_length }), NotifyPayloadBodyCont0 { payload_length }),
+        mapper: NotifyPayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_notify_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_notify_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<NotifyPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_notify_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_notify_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_notify_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_notify_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = notify_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_notify_payload_body<'a>(v: <NotifyPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_notify_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_notify_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_notify_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = notify_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct NotifyPayloadBodyCont1 {
+    pub payload_length: u16,
+}
+type NotifyPayloadBodyCont1Type<'a, 'b> = &'b NotifyProtocolId;
+type NotifyPayloadBodyCont1SType<'a, 'x> = &'x NotifyProtocolId;
+type NotifyPayloadBodyCont1Input<'a, 'b, 'x> = POrSType<NotifyPayloadBodyCont1Type<'a, 'b>, NotifyPayloadBodyCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<NotifyPayloadBodyCont1Input<'a, 'b, 'x>> for NotifyPayloadBodyCont1 {
+    type Output = IpsecSpiSizeOrNoneCombinator;
+
+    open spec fn requires(&self, deps: NotifyPayloadBodyCont1Input<'a, 'b, 'x>) -> bool {        let payload_length = self.payload_length@;
+
+        &&& ((self.payload_length@) >= 8 && (self.payload_length@) <= 65535)
+        &&& (spec_notify_protocol_id()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: NotifyPayloadBodyCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_notify_payload_body_cont1(self.payload_length@, deps@)
+    }
+
+    fn apply(&self, deps: NotifyPayloadBodyCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let protocol_id = deps;
+                let payload_length = self.payload_length;
+                let protocol_id = *protocol_id;
+                ipsec_spi_size_or_none()
+            }
+            POrSType::S(deps) => {
+                let protocol_id = deps;
+                let payload_length = self.payload_length;
+                let protocol_id = *protocol_id;
+                ipsec_spi_size_or_none()
+            }
+        }
+    }
+}
+pub struct NotifyPayloadBodyCont0 {
+    pub payload_length: u16,
+}
+type NotifyPayloadBodyCont0Type<'a, 'b> = &'b (NotifyProtocolId, IpsecSpiSizeOrNone);
+type NotifyPayloadBodyCont0SType<'a, 'x> = (&'x NotifyProtocolId, &'x IpsecSpiSizeOrNone);
+type NotifyPayloadBodyCont0Input<'a, 'b, 'x> = POrSType<NotifyPayloadBodyCont0Type<'a, 'b>, NotifyPayloadBodyCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<NotifyPayloadBodyCont0Input<'a, 'b, 'x>> for NotifyPayloadBodyCont0 {
+    type Output = (NotifyMsgTypeCombinator, NotifyPayloadBodyRestCombinator);
+
+    open spec fn requires(&self, deps: NotifyPayloadBodyCont0Input<'a, 'b, 'x>) -> bool {        let payload_length = self.payload_length@;
+
+        &&& ((self.payload_length@) >= 8 && (self.payload_length@) <= 65535)
+        &&& (Pair::spec_new(spec_notify_protocol_id(), |deps| spec_notify_payload_body_cont1(payload_length, deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: NotifyPayloadBodyCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_notify_payload_body_cont0(self.payload_length@, deps@)
+    }
+
+    fn apply(&self, deps: NotifyPayloadBodyCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (protocol_id, spi_size) = deps;
+                let payload_length = self.payload_length;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                (notify_msg_type(), notify_payload_body_rest(payload_length, spi_size))
+            }
+            POrSType::S(deps) => {
+                let (protocol_id, spi_size) = deps;
+                let payload_length = self.payload_length;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                (notify_msg_type(), notify_payload_body_rest(payload_length, spi_size))
+            }
+        }
+    }
+}
+
+pub struct SpecCertPayloadBody {
+    pub cert_encoding: u8,
+    pub cert_data: Seq<u8>,
+}
+
+pub type SpecCertPayloadBodyInner = (u8, Seq<u8>);
+
+
+impl SpecFrom<SpecCertPayloadBody> for SpecCertPayloadBodyInner {
+    open spec fn spec_from(m: SpecCertPayloadBody) -> SpecCertPayloadBodyInner {
+        (m.cert_encoding, m.cert_data)
+    }
+}
+
+impl SpecFrom<SpecCertPayloadBodyInner> for SpecCertPayloadBody {
+    open spec fn spec_from(m: SpecCertPayloadBodyInner) -> SpecCertPayloadBody {
+        let (cert_encoding, cert_data) = m;
+        SpecCertPayloadBody { cert_encoding, cert_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CertPayloadBody<'a> {
+    pub cert_encoding: u8,
+    pub cert_data: &'a [u8],
+}
+
+impl View for CertPayloadBody<'_> {
+    type V = SpecCertPayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCertPayloadBody {
+            cert_encoding: self.cert_encoding@,
+            cert_data: self.cert_data@,
+        }
+    }
+}
+pub type CertPayloadBodyInner<'a> = (u8, &'a [u8]);
+
+pub type CertPayloadBodyInnerRef<'a> = (&'a u8, &'a &'a [u8]);
+impl<'a> From<&'a CertPayloadBody<'a>> for CertPayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a CertPayloadBody) -> CertPayloadBodyInnerRef<'a> {
+        (&m.cert_encoding, &m.cert_data)
+    }
+}
+
+impl<'a> From<CertPayloadBodyInner<'a>> for CertPayloadBody<'a> {
+    fn ex_from(m: CertPayloadBodyInner) -> CertPayloadBody {
+        let (cert_encoding, cert_data) = m;
+        CertPayloadBody { cert_encoding, cert_data }
+    }
+}
+
+pub struct CertPayloadBodyMapper;
+impl View for CertPayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CertPayloadBodyMapper {
+    type Src = SpecCertPayloadBodyInner;
+    type Dst = SpecCertPayloadBody;
+}
+impl SpecIsoProof for CertPayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CertPayloadBodyMapper {
+    type Src = CertPayloadBodyInner<'a>;
+    type Dst = CertPayloadBody<'a>;
+    type RefSrc = CertPayloadBodyInnerRef<'a>;
+}
+type SpecCertPayloadBodyCombinatorAlias1 = (SpecCertEncodingCombinator, bytes::Variable);
+pub struct SpecCertPayloadBodyCombinator(pub SpecCertPayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecCertPayloadBodyCombinator {
+    type Type = SpecCertPayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCertPayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertPayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCertPayloadBodyCombinatorAlias = Mapped<SpecCertPayloadBodyCombinatorAlias1, CertPayloadBodyMapper>;
+type CertPayloadBodyCombinatorAlias1 = (CertEncodingCombinator, bytes::Variable);
+pub struct CertPayloadBodyCombinator1(pub CertPayloadBodyCombinatorAlias1);
+impl View for CertPayloadBodyCombinator1 {
+    type V = SpecCertPayloadBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertPayloadBodyCombinator1, CertPayloadBodyCombinatorAlias1);
+
+pub struct CertPayloadBodyCombinator(pub CertPayloadBodyCombinatorAlias);
+
+impl View for CertPayloadBodyCombinator {
+    type V = SpecCertPayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertPayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertPayloadBodyCombinator {
+    type Type = CertPayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CertPayloadBodyCombinatorAlias = Mapped<CertPayloadBodyCombinator1, CertPayloadBodyMapper>;
+
+
+pub open spec fn spec_cert_payload_body(payload_length: u16) -> SpecCertPayloadBodyCombinator {
+    SpecCertPayloadBodyCombinator(
+    Mapped {
+        inner: (spec_cert_encoding(), bytes::Variable(((usize::spec_from(payload_length) - 5)) as usize)),
+        mapper: CertPayloadBodyMapper,
+    })
+}
+
+pub fn cert_payload_body<'a>(payload_length: u16) -> (o: CertPayloadBodyCombinator)
+    requires
+        ((payload_length) >= 5 && (payload_length) <= 65535),
+
+    ensures o@ == spec_cert_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CertPayloadBodyCombinator(
+    Mapped {
+        inner: CertPayloadBodyCombinator1((cert_encoding(), bytes::Variable(((usize::ex_from(payload_length) - 5)) as usize))),
+        mapper: CertPayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_cert_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_cert_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<CertPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 5 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_cert_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_cert_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_cert_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_cert_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = cert_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_cert_payload_body<'a>(v: <CertPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_cert_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 5 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_cert_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 5 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_cert_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = cert_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecTsPayloadBody {
+    pub num_ts: u8,
+    pub reserved: Seq<u8>,
+    pub selectors: Seq<SpecTrafficSelector>,
+}
+
+pub type SpecTsPayloadBodyInner = (u8, (Seq<u8>, Seq<SpecTrafficSelector>));
+
+
+impl SpecFrom<SpecTsPayloadBody> for SpecTsPayloadBodyInner {
+    open spec fn spec_from(m: SpecTsPayloadBody) -> SpecTsPayloadBodyInner {
+        (m.num_ts, (m.reserved, m.selectors))
+    }
+}
+
+impl SpecFrom<SpecTsPayloadBodyInner> for SpecTsPayloadBody {
+    open spec fn spec_from(m: SpecTsPayloadBodyInner) -> SpecTsPayloadBody {
+        let (num_ts, (reserved, selectors)) = m;
+        SpecTsPayloadBody { num_ts, reserved, selectors }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct TsPayloadBody<'a> {
+    pub num_ts: u8,
+    pub reserved: &'a [u8],
+    pub selectors: RepeatResult<TrafficSelector<'a>>,
+}
+
+impl View for TsPayloadBody<'_> {
+    type V = SpecTsPayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTsPayloadBody {
+            num_ts: self.num_ts@,
+            reserved: self.reserved@,
+            selectors: self.selectors@,
+        }
+    }
+}
+pub type TsPayloadBodyInner<'a> = (u8, (&'a [u8], RepeatResult<TrafficSelector<'a>>));
+
+pub type TsPayloadBodyInnerRef<'a> = (&'a u8, (&'a &'a [u8], &'a RepeatResult<TrafficSelector<'a>>));
+impl<'a> From<&'a TsPayloadBody<'a>> for TsPayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a TsPayloadBody) -> TsPayloadBodyInnerRef<'a> {
+        (&m.num_ts, (&m.reserved, &m.selectors))
+    }
+}
+
+impl<'a> From<TsPayloadBodyInner<'a>> for TsPayloadBody<'a> {
+    fn ex_from(m: TsPayloadBodyInner) -> TsPayloadBody {
+        let (num_ts, (reserved, selectors)) = m;
+        TsPayloadBody { num_ts, reserved, selectors }
+    }
+}
+
+pub struct TsPayloadBodyMapper;
+impl View for TsPayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TsPayloadBodyMapper {
+    type Src = SpecTsPayloadBodyInner;
+    type Dst = SpecTsPayloadBody;
+}
+impl SpecIsoProof for TsPayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TsPayloadBodyMapper {
+    type Src = TsPayloadBodyInner<'a>;
+    type Dst = TsPayloadBody<'a>;
+    type RefSrc = TsPayloadBodyInnerRef<'a>;
+}
+pub spec const SPEC_TSPAYLOADBODYRESERVED_CONST: Seq<u8> = seq![0; 3];
+pub struct SpecTsPayloadBodyCombinator(pub SpecTsPayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecTsPayloadBodyCombinator {
+    type Type = SpecTsPayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTsPayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTsPayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTsPayloadBodyCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate3651688686135228051>, (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, AndThen<bytes::Variable, RepeatN<SpecTrafficSelectorCombinator>>)>, TsPayloadBodyMapper>;
+pub exec static TSPAYLOADBODYRESERVED_CONST: [u8; 3]
+    ensures TSPAYLOADBODYRESERVED_CONST@ == SPEC_TSPAYLOADBODYRESERVED_CONST,
+{
+    let arr: [u8; 3] = [0; 3];
+    assert(arr@ == SPEC_TSPAYLOADBODYRESERVED_CONST);
+    arr
+}
+
+pub struct TsPayloadBodyCombinator(pub TsPayloadBodyCombinatorAlias);
+
+impl View for TsPayloadBodyCombinator {
+    type V = SpecTsPayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecTsPayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsPayloadBodyCombinator {
+    type Type = TsPayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::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>;
+
+
+pub open spec fn spec_ts_payload_body(payload_length: u16) -> SpecTsPayloadBodyCombinator {
+    SpecTsPayloadBodyCombinator(
+    Mapped {
+        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate3651688686135228051 }, |deps| spec_ts_payload_body_cont0(payload_length, deps)),
+        mapper: TsPayloadBodyMapper,
+    })
+}
+
+pub open spec fn spec_ts_payload_body_cont0(payload_length: u16, deps: u8) -> (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, AndThen<bytes::Variable, RepeatN<SpecTrafficSelectorCombinator>>) {
+    let num_ts = deps;
+    (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(SPEC_TSPAYLOADBODYRESERVED_CONST) }, AndThen(bytes::Variable(((usize::spec_from(payload_length) - 8)) as usize), RepeatN(spec_traffic_selector(), (usize::spec_from(num_ts)) as usize)))
+}
+
+impl View for TsPayloadBodyCont0 {
+    type V = spec_fn(u8) -> (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, AndThen<bytes::Variable, RepeatN<SpecTrafficSelectorCombinator>>);
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_ts_payload_body_cont0(self.payload_length@, deps)
+        }
+    }
+}
+
+pub fn ts_payload_body<'a>(payload_length: u16) -> (o: TsPayloadBodyCombinator)
+    requires
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures o@ == spec_ts_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TsPayloadBodyCombinator(
+    Mapped {
+        inner: Pair::new(Refined { inner: U8, predicate: Predicate3651688686135228051 }, TsPayloadBodyCont0 { payload_length }),
+        mapper: TsPayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ts_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ts_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<TsPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_ts_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_ts_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ts_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_ts_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ts_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ts_payload_body<'a>(v: <TsPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_ts_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_ts_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = ts_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct TsPayloadBodyCont0 {
+    pub payload_length: u16,
+}
+type TsPayloadBodyCont0Type<'a, 'b> = &'b u8;
+type TsPayloadBodyCont0SType<'a, 'x> = &'x u8;
+type TsPayloadBodyCont0Input<'a, 'b, 'x> = POrSType<TsPayloadBodyCont0Type<'a, 'b>, TsPayloadBodyCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TsPayloadBodyCont0Input<'a, 'b, 'x>> for TsPayloadBodyCont0 {
+    type Output = (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, AndThen<bytes::Variable, RepeatN<TrafficSelectorCombinator>>);
+
+    open spec fn requires(&self, deps: TsPayloadBodyCont0Input<'a, 'b, 'x>) -> bool {        let payload_length = self.payload_length@;
+
+        &&& ((self.payload_length@) >= 8 && (self.payload_length@) <= 65535)
+        &&& (Refined { inner: U8, predicate: Predicate3651688686135228051 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: TsPayloadBodyCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_ts_payload_body_cont0(self.payload_length@, deps@)
+    }
+
+    fn apply(&self, deps: TsPayloadBodyCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let num_ts = deps;
+                let payload_length = self.payload_length;
+                let num_ts = *num_ts;
+                (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(TSPAYLOADBODYRESERVED_CONST) }, AndThen(bytes::Variable(((usize::ex_from(payload_length) - 8)) as usize), RepeatN(traffic_selector(), (usize::ex_from(num_ts)) as usize)))
+            }
+            POrSType::S(deps) => {
+                let num_ts = deps;
+                let payload_length = self.payload_length;
+                let num_ts = *num_ts;
+                (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(TSPAYLOADBODYRESERVED_CONST) }, AndThen(bytes::Variable(((usize::ex_from(payload_length) - 8)) as usize), RepeatN(traffic_selector(), (usize::ex_from(num_ts)) as usize)))
+            }
+        }
+    }
+}
+
+pub struct SpecVendorIdPayloadBody {
+    pub vendor_id: Seq<u8>,
+}
+
+pub type SpecVendorIdPayloadBodyInner = Seq<u8>;
+
+
+impl SpecFrom<SpecVendorIdPayloadBody> for SpecVendorIdPayloadBodyInner {
+    open spec fn spec_from(m: SpecVendorIdPayloadBody) -> SpecVendorIdPayloadBodyInner {
+        m.vendor_id
+    }
+}
+
+impl SpecFrom<SpecVendorIdPayloadBodyInner> for SpecVendorIdPayloadBody {
+    open spec fn spec_from(m: SpecVendorIdPayloadBodyInner) -> SpecVendorIdPayloadBody {
+        let vendor_id = m;
+        SpecVendorIdPayloadBody { vendor_id }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct VendorIdPayloadBody<'a> {
+    pub vendor_id: &'a [u8],
+}
+
+impl View for VendorIdPayloadBody<'_> {
+    type V = SpecVendorIdPayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecVendorIdPayloadBody {
+            vendor_id: self.vendor_id@,
+        }
+    }
+}
+pub type VendorIdPayloadBodyInner<'a> = &'a [u8];
+
+pub type VendorIdPayloadBodyInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a VendorIdPayloadBody<'a>> for VendorIdPayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a VendorIdPayloadBody) -> VendorIdPayloadBodyInnerRef<'a> {
+        &m.vendor_id
+    }
+}
+
+impl<'a> From<VendorIdPayloadBodyInner<'a>> for VendorIdPayloadBody<'a> {
+    fn ex_from(m: VendorIdPayloadBodyInner) -> VendorIdPayloadBody {
+        let vendor_id = m;
+        VendorIdPayloadBody { vendor_id }
+    }
+}
+
+pub struct VendorIdPayloadBodyMapper;
+impl View for VendorIdPayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for VendorIdPayloadBodyMapper {
+    type Src = SpecVendorIdPayloadBodyInner;
+    type Dst = SpecVendorIdPayloadBody;
+}
+impl SpecIsoProof for VendorIdPayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for VendorIdPayloadBodyMapper {
+    type Src = VendorIdPayloadBodyInner<'a>;
+    type Dst = VendorIdPayloadBody<'a>;
+    type RefSrc = VendorIdPayloadBodyInnerRef<'a>;
+}
+
+pub struct SpecVendorIdPayloadBodyCombinator(pub SpecVendorIdPayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecVendorIdPayloadBodyCombinator {
+    type Type = SpecVendorIdPayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecVendorIdPayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecVendorIdPayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecVendorIdPayloadBodyCombinatorAlias = Mapped<bytes::Variable, VendorIdPayloadBodyMapper>;
+
+pub struct VendorIdPayloadBodyCombinator(pub VendorIdPayloadBodyCombinatorAlias);
+
+impl View for VendorIdPayloadBodyCombinator {
+    type V = SpecVendorIdPayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecVendorIdPayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for VendorIdPayloadBodyCombinator {
+    type Type = VendorIdPayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type VendorIdPayloadBodyCombinatorAlias = Mapped<bytes::Variable, VendorIdPayloadBodyMapper>;
+
+
+pub open spec fn spec_vendor_id_payload_body(payload_length: u16) -> SpecVendorIdPayloadBodyCombinator {
+    SpecVendorIdPayloadBodyCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::spec_from(payload_length) - 4)) as usize),
+        mapper: VendorIdPayloadBodyMapper,
+    })
+}
+
+pub fn vendor_id_payload_body<'a>(payload_length: u16) -> (o: VendorIdPayloadBodyCombinator)
+    requires
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures o@ == spec_vendor_id_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = VendorIdPayloadBodyCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::ex_from(payload_length) - 4)) as usize),
+        mapper: VendorIdPayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_vendor_id_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_vendor_id_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<VendorIdPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_vendor_id_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_vendor_id_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_vendor_id_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_vendor_id_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = vendor_id_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_vendor_id_payload_body<'a>(v: <VendorIdPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_vendor_id_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_vendor_id_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 4 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_vendor_id_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = vendor_id_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub spec const SPEC_PayloadCritical_NonCritical: u8 = 0;
+pub spec const SPEC_PayloadCritical_Critical: u8 = 128;
+pub exec static EXEC_PayloadCritical_NonCritical: u8 ensures EXEC_PayloadCritical_NonCritical == SPEC_PayloadCritical_NonCritical { 0 }
+pub exec static EXEC_PayloadCritical_Critical: u8 ensures EXEC_PayloadCritical_Critical == SPEC_PayloadCritical_Critical { 128 }
+
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum PayloadCritical {
+    NonCritical = 0,
+Critical = 128
+}
+pub type SpecPayloadCritical = PayloadCritical;
+
+pub type PayloadCriticalInner = u8;
+
+pub type PayloadCriticalInnerRef<'a> = &'a u8;
+
+impl View for PayloadCritical {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecTryFrom<PayloadCriticalInner> for PayloadCritical {
+    type Error = ();
+
+    open spec fn spec_try_from(v: PayloadCriticalInner) -> Result<PayloadCritical, ()> {
+        match v {
+            0u8 => Ok(PayloadCritical::NonCritical),
+            128u8 => Ok(PayloadCritical::Critical),
+            _ => Err(()),
+        }
+    }
+}
+
+impl SpecTryFrom<PayloadCritical> for PayloadCriticalInner {
+    type Error = ();
+
+    open spec fn spec_try_from(v: PayloadCritical) -> Result<PayloadCriticalInner, ()> {
+        match v {
+            PayloadCritical::NonCritical => Ok(SPEC_PayloadCritical_NonCritical),
+            PayloadCritical::Critical => Ok(SPEC_PayloadCritical_Critical),
+        }
+    }
+}
+
+impl TryFrom<PayloadCriticalInner> for PayloadCritical {
+    type Error = ();
+
+    fn ex_try_from(v: PayloadCriticalInner) -> Result<PayloadCritical, ()> {
+        match v {
+            0u8 => Ok(PayloadCritical::NonCritical),
+            128u8 => Ok(PayloadCritical::Critical),
+            _ => Err(()),
+        }
+    }
+}
+
+impl<'a> TryFrom<&'a PayloadCritical> for PayloadCriticalInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a PayloadCritical) -> Result<PayloadCriticalInnerRef<'a>, ()> {
+        match v {
+            PayloadCritical::NonCritical => Ok(&EXEC_PayloadCritical_NonCritical),
+            PayloadCritical::Critical => Ok(&EXEC_PayloadCritical_Critical),
+        }
+    }
+}
+
+pub struct PayloadCriticalMapper;
+
+impl View for PayloadCriticalMapper {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecPartialIso for PayloadCriticalMapper {
+    type Src = PayloadCriticalInner;
+    type Dst = PayloadCritical;
+}
+
+impl SpecPartialIsoProof for PayloadCriticalMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+}
+
+impl<'a> PartialIso<'a> for PayloadCriticalMapper {
+    type Src = PayloadCriticalInner;
+    type Dst = PayloadCritical;
+    type RefSrc = PayloadCriticalInnerRef<'a>;
+}
+
+
+pub struct SpecPayloadCriticalCombinator(pub SpecPayloadCriticalCombinatorAlias);
+
+impl SpecCombinator for SpecPayloadCriticalCombinator {
+    type Type = SpecPayloadCritical;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecPayloadCriticalCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPayloadCriticalCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecPayloadCriticalCombinatorAlias = TryMap<U8, PayloadCriticalMapper>;
+
+pub struct PayloadCriticalCombinator(pub PayloadCriticalCombinatorAlias);
+
+impl View for PayloadCriticalCombinator {
+    type V = SpecPayloadCriticalCombinator;
+    open spec fn view(&self) -> Self::V { SpecPayloadCriticalCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PayloadCriticalCombinator {
+    type Type = PayloadCritical;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type PayloadCriticalCombinatorAlias = TryMap<U8, PayloadCriticalMapper>;
+
+
+pub open spec fn spec_payload_critical() -> SpecPayloadCriticalCombinator {
+    SpecPayloadCriticalCombinator(TryMap { inner: U8, mapper: PayloadCriticalMapper })
+}
+
+                
+pub fn payload_critical<'a>() -> (o: PayloadCriticalCombinator)
+    ensures o@ == spec_payload_critical(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = PayloadCriticalCombinator(TryMap { inner: U8, mapper: PayloadCriticalMapper });
+    // assert({
+    //     &&& combinator@ == spec_payload_critical()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_payload_critical<'a>(input: &'a [u8]) -> (res: PResult<<PayloadCriticalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_payload_critical().spec_parse(input@) == Some((n as int, v@)),
+        spec_payload_critical().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_payload_critical().spec_parse(input@) is None,
+        spec_payload_critical().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = payload_critical();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_payload_critical<'a>(v: <PayloadCriticalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_payload_critical().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_payload_critical().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_payload_critical().spec_serialize(v@).len(),
+{
+    let combinator = payload_critical();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub enum SpecDeletePayloadBodySpis {
+    Variant0(SpecDeletePayloadSpisNone),
+    Variant1(SpecDeletePayloadSpisIpsec),
+}
+
+pub type SpecDeletePayloadBodySpisInner = Either<SpecDeletePayloadSpisNone, SpecDeletePayloadSpisIpsec>;
+
+impl SpecFrom<SpecDeletePayloadBodySpis> for SpecDeletePayloadBodySpisInner {
+    open spec fn spec_from(m: SpecDeletePayloadBodySpis) -> SpecDeletePayloadBodySpisInner {
+        match m {
+            SpecDeletePayloadBodySpis::Variant0(m) => Either::Left(m),
+            SpecDeletePayloadBodySpis::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecDeletePayloadBodySpisInner> for SpecDeletePayloadBodySpis {
+    open spec fn spec_from(m: SpecDeletePayloadBodySpisInner) -> SpecDeletePayloadBodySpis {
+        match m {
+            Either::Left(m) => SpecDeletePayloadBodySpis::Variant0(m),
+            Either::Right(m) => SpecDeletePayloadBodySpis::Variant1(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DeletePayloadBodySpis<'a> {
+    Variant0(DeletePayloadSpisNone<'a>),
+    Variant1(DeletePayloadSpisIpsec),
+}
+
+pub type DeletePayloadBodySpisInner<'a> = Either<DeletePayloadSpisNone<'a>, DeletePayloadSpisIpsec>;
+
+pub type DeletePayloadBodySpisInnerRef<'a> = Either<&'a DeletePayloadSpisNone<'a>, &'a DeletePayloadSpisIpsec>;
+
+
+impl<'a> View for DeletePayloadBodySpis<'a> {
+    type V = SpecDeletePayloadBodySpis;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            DeletePayloadBodySpis::Variant0(m) => SpecDeletePayloadBodySpis::Variant0(m@),
+            DeletePayloadBodySpis::Variant1(m) => SpecDeletePayloadBodySpis::Variant1(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a DeletePayloadBodySpis<'a>> for DeletePayloadBodySpisInnerRef<'a> {
+    fn ex_from(m: &'a DeletePayloadBodySpis<'a>) -> DeletePayloadBodySpisInnerRef<'a> {
+        match m {
+            DeletePayloadBodySpis::Variant0(m) => Either::Left(m),
+            DeletePayloadBodySpis::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+impl<'a> From<DeletePayloadBodySpisInner<'a>> for DeletePayloadBodySpis<'a> {
+    fn ex_from(m: DeletePayloadBodySpisInner<'a>) -> DeletePayloadBodySpis<'a> {
+        match m {
+            Either::Left(m) => DeletePayloadBodySpis::Variant0(m),
+            Either::Right(m) => DeletePayloadBodySpis::Variant1(m),
+        }
+    }
+    
+}
+
+
+pub struct DeletePayloadBodySpisMapper;
+impl View for DeletePayloadBodySpisMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for DeletePayloadBodySpisMapper {
+    type Src = SpecDeletePayloadBodySpisInner;
+    type Dst = SpecDeletePayloadBodySpis;
+}
+impl SpecIsoProof for DeletePayloadBodySpisMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for DeletePayloadBodySpisMapper {
+    type Src = DeletePayloadBodySpisInner<'a>;
+    type Dst = DeletePayloadBodySpis<'a>;
+    type RefSrc = DeletePayloadBodySpisInnerRef<'a>;
+}
+
+type SpecDeletePayloadBodySpisCombinatorAlias1 = Choice<Cond<SpecDeletePayloadSpisNoneCombinator>, Cond<SpecDeletePayloadSpisIpsecCombinator>>;
+pub struct SpecDeletePayloadBodySpisCombinator(pub SpecDeletePayloadBodySpisCombinatorAlias);
+
+impl SpecCombinator for SpecDeletePayloadBodySpisCombinator {
+    type Type = SpecDeletePayloadBodySpis;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecDeletePayloadBodySpisCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDeletePayloadBodySpisCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecDeletePayloadBodySpisCombinatorAlias = Mapped<SpecDeletePayloadBodySpisCombinatorAlias1, DeletePayloadBodySpisMapper>;
+type DeletePayloadBodySpisCombinatorAlias1 = Choice<Cond<DeletePayloadSpisNoneCombinator>, Cond<DeletePayloadSpisIpsecCombinator>>;
+pub struct DeletePayloadBodySpisCombinator1(pub DeletePayloadBodySpisCombinatorAlias1);
+impl View for DeletePayloadBodySpisCombinator1 {
+    type V = SpecDeletePayloadBodySpisCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(DeletePayloadBodySpisCombinator1, DeletePayloadBodySpisCombinatorAlias1);
+
+pub struct DeletePayloadBodySpisCombinator(pub DeletePayloadBodySpisCombinatorAlias);
+
+impl View for DeletePayloadBodySpisCombinator {
+    type V = SpecDeletePayloadBodySpisCombinator;
+    open spec fn view(&self) -> Self::V { SpecDeletePayloadBodySpisCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadBodySpisCombinator {
+    type Type = DeletePayloadBodySpis<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type DeletePayloadBodySpisCombinatorAlias = Mapped<DeletePayloadBodySpisCombinator1, DeletePayloadBodySpisMapper>;
+
+
+pub open spec fn spec_delete_payload_body_spis(num_spis: u16, spi_size: SpecIpsecSpiSizeOrNone) -> SpecDeletePayloadBodySpisCombinator {
+    SpecDeletePayloadBodySpisCombinator(Mapped { inner: Choice(Cond { cond: spi_size == 0, inner: spec_delete_payload_spis_none() }, Cond { cond: spi_size == 4, inner: spec_delete_payload_spis_ipsec(num_spis) }), mapper: DeletePayloadBodySpisMapper })
+}
+
+pub fn delete_payload_body_spis<'a>(num_spis: u16, spi_size: IpsecSpiSizeOrNone) -> (o: DeletePayloadBodySpisCombinator)
+    requires
+        spec_ipsec_spi_size_or_none().wf(spi_size@),
+
+    ensures o@ == spec_delete_payload_body_spis(num_spis@, spi_size@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = DeletePayloadBodySpisCombinator(Mapped { inner: DeletePayloadBodySpisCombinator1(Choice::new(Cond { cond: spi_size == 0, inner: delete_payload_spis_none() }, Cond { cond: spi_size == 4, inner: delete_payload_spis_ipsec(num_spis) })), mapper: DeletePayloadBodySpisMapper });
+    // assert({
+    //     &&& combinator@ == spec_delete_payload_body_spis(num_spis@, spi_size@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_delete_payload_body_spis<'a>(input: &'a [u8], num_spis: u16, spi_size: IpsecSpiSizeOrNone) -> (res: PResult<<DeletePayloadBodySpisCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_ipsec_spi_size_or_none().wf(spi_size@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_delete_payload_body_spis(num_spis@, spi_size@).spec_parse(input@) == Some((n as int, v@)),
+        spec_delete_payload_body_spis(num_spis@, spi_size@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_delete_payload_body_spis(num_spis@, spi_size@).spec_parse(input@) is None,
+        spec_delete_payload_body_spis(num_spis@, spi_size@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = delete_payload_body_spis( num_spis, spi_size );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_delete_payload_body_spis<'a>(v: <DeletePayloadBodySpisCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, num_spis: u16, spi_size: IpsecSpiSizeOrNone) -> (o: SResult<usize, SerializeError>)
+    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@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_delete_payload_body_spis(num_spis@, spi_size@).spec_serialize(v@).len() <= usize::MAX,
+        spec_ipsec_spi_size_or_none().wf(spi_size@),
+
+    ensures
+        serialize_len == spec_delete_payload_body_spis(num_spis@, spi_size@).spec_serialize(v@).len(),
+{
+    let combinator = delete_payload_body_spis( num_spis, spi_size );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecDeletePayloadBody {
+    pub protocol_id: u8,
+    pub spi_size: SpecIpsecSpiSizeOrNone,
+    pub num_spis: u16,
+    pub spis: SpecDeletePayloadBodySpis,
+}
+
+pub type SpecDeletePayloadBodyInner = (((u8, SpecIpsecSpiSizeOrNone), u16), SpecDeletePayloadBodySpis);
+
+
+impl SpecFrom<SpecDeletePayloadBody> for SpecDeletePayloadBodyInner {
+    open spec fn spec_from(m: SpecDeletePayloadBody) -> SpecDeletePayloadBodyInner {
+        (((m.protocol_id, m.spi_size), m.num_spis), m.spis)
+    }
+}
+
+impl SpecFrom<SpecDeletePayloadBodyInner> for SpecDeletePayloadBody {
+    open spec fn spec_from(m: SpecDeletePayloadBodyInner) -> SpecDeletePayloadBody {
+        let (((protocol_id, spi_size), num_spis), spis) = m;
+        SpecDeletePayloadBody { protocol_id, spi_size, num_spis, spis }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct DeletePayloadBody<'a> {
+    pub protocol_id: u8,
+    pub spi_size: IpsecSpiSizeOrNone,
+    pub num_spis: u16,
+    pub spis: DeletePayloadBodySpis<'a>,
+}
+
+impl View for DeletePayloadBody<'_> {
+    type V = SpecDeletePayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecDeletePayloadBody {
+            protocol_id: self.protocol_id@,
+            spi_size: self.spi_size@,
+            num_spis: self.num_spis@,
+            spis: self.spis@,
+        }
+    }
+}
+pub type DeletePayloadBodyInner<'a> = (((u8, IpsecSpiSizeOrNone), u16), DeletePayloadBodySpis<'a>);
+
+pub type DeletePayloadBodyInnerRef<'a> = (((&'a u8, &'a IpsecSpiSizeOrNone), &'a u16), &'a DeletePayloadBodySpis<'a>);
+impl<'a> From<&'a DeletePayloadBody<'a>> for DeletePayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a DeletePayloadBody) -> DeletePayloadBodyInnerRef<'a> {
+        (((&m.protocol_id, &m.spi_size), &m.num_spis), &m.spis)
+    }
+}
+
+impl<'a> From<DeletePayloadBodyInner<'a>> for DeletePayloadBody<'a> {
+    fn ex_from(m: DeletePayloadBodyInner) -> DeletePayloadBody {
+        let (((protocol_id, spi_size), num_spis), spis) = m;
+        DeletePayloadBody { protocol_id, spi_size, num_spis, spis }
+    }
+}
+
+pub struct DeletePayloadBodyMapper;
+impl View for DeletePayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for DeletePayloadBodyMapper {
+    type Src = SpecDeletePayloadBodyInner;
+    type Dst = SpecDeletePayloadBody;
+}
+impl SpecIsoProof for DeletePayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for DeletePayloadBodyMapper {
+    type Src = DeletePayloadBodyInner<'a>;
+    type Dst = DeletePayloadBody<'a>;
+    type RefSrc = DeletePayloadBodyInnerRef<'a>;
+}
+
+pub struct SpecDeletePayloadBodyCombinator(pub SpecDeletePayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecDeletePayloadBodyCombinator {
+    type Type = SpecDeletePayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecDeletePayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDeletePayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecDeletePayloadBodyCombinatorAlias = Mapped<SpecPair<SpecPair<SpecPair<SpecIkeProtocolIdCombinator, SpecIpsecSpiSizeOrNoneCombinator>, U16Be>, SpecDeletePayloadBodySpisCombinator>, DeletePayloadBodyMapper>;
+
+pub struct DeletePayloadBodyCombinator(pub DeletePayloadBodyCombinatorAlias);
+
+impl View for DeletePayloadBodyCombinator {
+    type V = SpecDeletePayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecDeletePayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeletePayloadBodyCombinator {
+    type Type = DeletePayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type DeletePayloadBodyCombinatorAlias = Mapped<Pair<Pair<Pair<IkeProtocolIdCombinator, IpsecSpiSizeOrNoneCombinator, DeletePayloadBodyCont2>, U16Be, DeletePayloadBodyCont1>, DeletePayloadBodySpisCombinator, DeletePayloadBodyCont0>, DeletePayloadBodyMapper>;
+
+
+pub open spec fn spec_delete_payload_body() -> SpecDeletePayloadBodyCombinator {
+    SpecDeletePayloadBodyCombinator(
+    Mapped {
+        inner: Pair::spec_new(Pair::spec_new(Pair::spec_new(spec_ike_protocol_id(), |deps| spec_delete_payload_body_cont2(deps)), |deps| spec_delete_payload_body_cont1(deps)), |deps| spec_delete_payload_body_cont0(deps)),
+        mapper: DeletePayloadBodyMapper,
+    })
+}
+
+pub open spec fn spec_delete_payload_body_cont2(deps: u8) -> SpecIpsecSpiSizeOrNoneCombinator {
+    let protocol_id = deps;
+    spec_ipsec_spi_size_or_none()
+}
+
+impl View for DeletePayloadBodyCont2 {
+    type V = spec_fn(u8) -> SpecIpsecSpiSizeOrNoneCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_delete_payload_body_cont2(deps)
+        }
+    }
+}
+
+pub open spec fn spec_delete_payload_body_cont1(deps: (u8, SpecIpsecSpiSizeOrNone)) -> U16Be {
+    let (protocol_id, spi_size) = deps;
+    U16Be
+}
+
+impl View for DeletePayloadBodyCont1 {
+    type V = spec_fn((u8, SpecIpsecSpiSizeOrNone)) -> U16Be;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u8, SpecIpsecSpiSizeOrNone)| {
+            spec_delete_payload_body_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_delete_payload_body_cont0(deps: ((u8, SpecIpsecSpiSizeOrNone), u16)) -> SpecDeletePayloadBodySpisCombinator {
+    let ((protocol_id, spi_size), num_spis) = deps;
+    spec_delete_payload_body_spis(num_spis, spi_size)
+}
+
+impl View for DeletePayloadBodyCont0 {
+    type V = spec_fn(((u8, SpecIpsecSpiSizeOrNone), u16)) -> SpecDeletePayloadBodySpisCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: ((u8, SpecIpsecSpiSizeOrNone), u16)| {
+            spec_delete_payload_body_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn delete_payload_body<'a>() -> (o: DeletePayloadBodyCombinator)
+    ensures o@ == spec_delete_payload_body(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = DeletePayloadBodyCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(Pair::new(ike_protocol_id(), DeletePayloadBodyCont2), DeletePayloadBodyCont1), DeletePayloadBodyCont0),
+        mapper: DeletePayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_delete_payload_body()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_delete_payload_body<'a>(input: &'a [u8]) -> (res: PResult<<DeletePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_delete_payload_body().spec_parse(input@) == Some((n as int, v@)),
+        spec_delete_payload_body().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_delete_payload_body().spec_parse(input@) is None,
+        spec_delete_payload_body().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = delete_payload_body();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_delete_payload_body<'a>(v: <DeletePayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_delete_payload_body().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_delete_payload_body().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_delete_payload_body().spec_serialize(v@).len(),
+{
+    let combinator = delete_payload_body();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct DeletePayloadBodyCont2;
+type DeletePayloadBodyCont2Type<'a, 'b> = &'b u8;
+type DeletePayloadBodyCont2SType<'a, 'x> = &'x u8;
+type DeletePayloadBodyCont2Input<'a, 'b, 'x> = POrSType<DeletePayloadBodyCont2Type<'a, 'b>, DeletePayloadBodyCont2SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<DeletePayloadBodyCont2Input<'a, 'b, 'x>> for DeletePayloadBodyCont2 {
+    type Output = IpsecSpiSizeOrNoneCombinator;
+
+    open spec fn requires(&self, deps: DeletePayloadBodyCont2Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_ike_protocol_id()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: DeletePayloadBodyCont2Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_delete_payload_body_cont2(deps@)
+    }
+
+    fn apply(&self, deps: DeletePayloadBodyCont2Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let protocol_id = deps;
+                let protocol_id = *protocol_id;
+                ipsec_spi_size_or_none()
+            }
+            POrSType::S(deps) => {
+                let protocol_id = deps;
+                let protocol_id = *protocol_id;
+                ipsec_spi_size_or_none()
+            }
+        }
+    }
+}
+pub struct DeletePayloadBodyCont1;
+type DeletePayloadBodyCont1Type<'a, 'b> = &'b (u8, IpsecSpiSizeOrNone);
+type DeletePayloadBodyCont1SType<'a, 'x> = (&'x u8, &'x IpsecSpiSizeOrNone);
+type DeletePayloadBodyCont1Input<'a, 'b, 'x> = POrSType<DeletePayloadBodyCont1Type<'a, 'b>, DeletePayloadBodyCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<DeletePayloadBodyCont1Input<'a, 'b, 'x>> for DeletePayloadBodyCont1 {
+    type Output = U16Be;
+
+    open spec fn requires(&self, deps: DeletePayloadBodyCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_ike_protocol_id(), |deps| spec_delete_payload_body_cont2(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: DeletePayloadBodyCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_delete_payload_body_cont1(deps@)
+    }
+
+    fn apply(&self, deps: DeletePayloadBodyCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (protocol_id, spi_size) = deps;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                U16Be
+            }
+            POrSType::S(deps) => {
+                let (protocol_id, spi_size) = deps;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                U16Be
+            }
+        }
+    }
+}
+pub struct DeletePayloadBodyCont0;
+type DeletePayloadBodyCont0Type<'a, 'b> = &'b ((u8, IpsecSpiSizeOrNone), u16);
+type DeletePayloadBodyCont0SType<'a, 'x> = ((&'x u8, &'x IpsecSpiSizeOrNone), &'x u16);
+type DeletePayloadBodyCont0Input<'a, 'b, 'x> = POrSType<DeletePayloadBodyCont0Type<'a, 'b>, DeletePayloadBodyCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<DeletePayloadBodyCont0Input<'a, 'b, 'x>> for DeletePayloadBodyCont0 {
+    type Output = DeletePayloadBodySpisCombinator;
+
+    open spec fn requires(&self, deps: DeletePayloadBodyCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(Pair::spec_new(spec_ike_protocol_id(), |deps| spec_delete_payload_body_cont2(deps)), |deps| spec_delete_payload_body_cont1(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: DeletePayloadBodyCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_delete_payload_body_cont0(deps@)
+    }
+
+    fn apply(&self, deps: DeletePayloadBodyCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let ((protocol_id, spi_size), num_spis) = deps;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                let num_spis = *num_spis;
+                delete_payload_body_spis(num_spis, spi_size)
+            }
+            POrSType::S(deps) => {
+                let ((protocol_id, spi_size), num_spis) = deps;
+                let protocol_id = *protocol_id;
+                let spi_size = *spi_size;
+                let num_spis = *num_spis;
+                delete_payload_body_spis(num_spis, spi_size)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecIkeMessage {
+    pub header: SpecIkeHeader,
+    pub payloads: Seq<u8>,
+}
+
+pub type SpecIkeMessageInner = (SpecIkeHeader, Seq<u8>);
+
+
+impl SpecFrom<SpecIkeMessage> for SpecIkeMessageInner {
+    open spec fn spec_from(m: SpecIkeMessage) -> SpecIkeMessageInner {
+        (m.header, m.payloads)
+    }
+}
+
+impl SpecFrom<SpecIkeMessageInner> for SpecIkeMessage {
+    open spec fn spec_from(m: SpecIkeMessageInner) -> SpecIkeMessage {
+        let (header, payloads) = m;
+        SpecIkeMessage { header, payloads }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct IkeMessage<'a> {
+    pub header: IkeHeader<'a>,
+    pub payloads: &'a [u8],
+}
+
+impl View for IkeMessage<'_> {
+    type V = SpecIkeMessage;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkeMessage {
+            header: self.header@,
+            payloads: self.payloads@,
+        }
+    }
+}
+pub type IkeMessageInner<'a> = (IkeHeader<'a>, &'a [u8]);
+
+pub type IkeMessageInnerRef<'a> = (&'a IkeHeader<'a>, &'a &'a [u8]);
+impl<'a> From<&'a IkeMessage<'a>> for IkeMessageInnerRef<'a> {
+    fn ex_from(m: &'a IkeMessage) -> IkeMessageInnerRef<'a> {
+        (&m.header, &m.payloads)
+    }
+}
+
+impl<'a> From<IkeMessageInner<'a>> for IkeMessage<'a> {
+    fn ex_from(m: IkeMessageInner) -> IkeMessage {
+        let (header, payloads) = m;
+        IkeMessage { header, payloads }
+    }
+}
+
+pub struct IkeMessageMapper;
+impl View for IkeMessageMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for IkeMessageMapper {
+    type Src = SpecIkeMessageInner;
+    type Dst = SpecIkeMessage;
+}
+impl SpecIsoProof for IkeMessageMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for IkeMessageMapper {
+    type Src = IkeMessageInner<'a>;
+    type Dst = IkeMessage<'a>;
+    type RefSrc = IkeMessageInnerRef<'a>;
+}
+
+pub struct SpecIkeMessageCombinator(pub SpecIkeMessageCombinatorAlias);
+
+impl SpecCombinator for SpecIkeMessageCombinator {
+    type Type = SpecIkeMessage;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkeMessageCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkeMessageCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkeMessageCombinatorAlias = Mapped<SpecPair<SpecIkeHeaderCombinator, bytes::Variable>, IkeMessageMapper>;
+
+pub struct IkeMessageCombinator(pub IkeMessageCombinatorAlias);
+
+impl View for IkeMessageCombinator {
+    type V = SpecIkeMessageCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkeMessageCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IkeMessageCombinator {
+    type Type = IkeMessage<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type IkeMessageCombinatorAlias = Mapped<Pair<IkeHeaderCombinator, bytes::Variable, IkeMessageCont0>, IkeMessageMapper>;
+
+
+pub open spec fn spec_ike_message() -> SpecIkeMessageCombinator {
+    SpecIkeMessageCombinator(
+    Mapped {
+        inner: Pair::spec_new(spec_ike_header(), |deps| spec_ike_message_cont0(deps)),
+        mapper: IkeMessageMapper,
+    })
+}
+
+pub open spec fn spec_ike_message_cont0(deps: SpecIkeHeader) -> bytes::Variable {
+    let header = deps;
+    bytes::Variable(((usize::spec_from(header.length) - 28)) as usize)
+}
+
+impl View for IkeMessageCont0 {
+    type V = spec_fn(SpecIkeHeader) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: SpecIkeHeader| {
+            spec_ike_message_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn ike_message<'a>() -> (o: IkeMessageCombinator)
+    ensures o@ == spec_ike_message(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = IkeMessageCombinator(
+    Mapped {
+        inner: Pair::new(ike_header(), IkeMessageCont0),
+        mapper: IkeMessageMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ike_message()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ike_message<'a>(input: &'a [u8]) -> (res: PResult<<IkeMessageCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ike_message().spec_parse(input@) == Some((n as int, v@)),
+        spec_ike_message().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ike_message().spec_parse(input@) is None,
+        spec_ike_message().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ike_message();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ike_message<'a>(v: <IkeMessageCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ike_message().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ike_message().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ike_message().spec_serialize(v@).len(),
+{
+    let combinator = ike_message();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct IkeMessageCont0;
+type IkeMessageCont0Type<'a, 'b> = &'b IkeHeader<'a>;
+type IkeMessageCont0SType<'a, 'x> = &'x IkeHeader<'a>;
+type IkeMessageCont0Input<'a, 'b, 'x> = POrSType<IkeMessageCont0Type<'a, 'b>, IkeMessageCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<IkeMessageCont0Input<'a, 'b, 'x>> for IkeMessageCont0 {
+    type Output = bytes::Variable;
+
+    open spec fn requires(&self, deps: IkeMessageCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_ike_header()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: IkeMessageCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_ike_message_cont0(deps@)
+    }
+
+    fn apply(&self, deps: IkeMessageCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let header = deps;
+                bytes::Variable(((usize::ex_from(header.length) - 28)) as usize)
+            }
+            POrSType::S(deps) => {
+                let header = deps;
+                bytes::Variable(((usize::ex_from(header.length) - 28)) as usize)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecGenericPayloadHeader {
+    pub next_payload: u8,
+    pub critical_reserved: SpecPayloadCritical,
+    pub payload_length: u16,
+}
+
+pub type SpecGenericPayloadHeaderInner = (u8, (SpecPayloadCritical, u16));
+
+
+impl SpecFrom<SpecGenericPayloadHeader> for SpecGenericPayloadHeaderInner {
+    open spec fn spec_from(m: SpecGenericPayloadHeader) -> SpecGenericPayloadHeaderInner {
+        (m.next_payload, (m.critical_reserved, m.payload_length))
+    }
+}
+
+impl SpecFrom<SpecGenericPayloadHeaderInner> for SpecGenericPayloadHeader {
+    open spec fn spec_from(m: SpecGenericPayloadHeaderInner) -> SpecGenericPayloadHeader {
+        let (next_payload, (critical_reserved, payload_length)) = m;
+        SpecGenericPayloadHeader { next_payload, critical_reserved, payload_length }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct GenericPayloadHeader {
+    pub next_payload: u8,
+    pub critical_reserved: PayloadCritical,
+    pub payload_length: u16,
+}
+
+impl View for GenericPayloadHeader {
+    type V = SpecGenericPayloadHeader;
+
+    open spec fn view(&self) -> Self::V {
+        SpecGenericPayloadHeader {
+            next_payload: self.next_payload@,
+            critical_reserved: self.critical_reserved@,
+            payload_length: self.payload_length@,
+        }
+    }
+}
+pub type GenericPayloadHeaderInner = (u8, (PayloadCritical, u16));
+
+pub type GenericPayloadHeaderInnerRef<'a> = (&'a u8, (&'a PayloadCritical, &'a u16));
+impl<'a> From<&'a GenericPayloadHeader> for GenericPayloadHeaderInnerRef<'a> {
+    fn ex_from(m: &'a GenericPayloadHeader) -> GenericPayloadHeaderInnerRef<'a> {
+        (&m.next_payload, (&m.critical_reserved, &m.payload_length))
+    }
+}
+
+impl From<GenericPayloadHeaderInner> for GenericPayloadHeader {
+    fn ex_from(m: GenericPayloadHeaderInner) -> GenericPayloadHeader {
+        let (next_payload, (critical_reserved, payload_length)) = m;
+        GenericPayloadHeader { next_payload, critical_reserved, payload_length }
+    }
+}
+
+pub struct GenericPayloadHeaderMapper;
+impl View for GenericPayloadHeaderMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for GenericPayloadHeaderMapper {
+    type Src = SpecGenericPayloadHeaderInner;
+    type Dst = SpecGenericPayloadHeader;
+}
+impl SpecIsoProof for GenericPayloadHeaderMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for GenericPayloadHeaderMapper {
+    type Src = GenericPayloadHeaderInner;
+    type Dst = GenericPayloadHeader;
+    type RefSrc = GenericPayloadHeaderInnerRef<'a>;
+}
+type SpecGenericPayloadHeaderCombinatorAlias1 = (SpecPayloadCriticalCombinator, Refined<U16Be, Predicate17149271707383182075>);
+type SpecGenericPayloadHeaderCombinatorAlias2 = (SpecNextPayloadTypeCombinator, SpecGenericPayloadHeaderCombinatorAlias1);
+pub struct SpecGenericPayloadHeaderCombinator(pub SpecGenericPayloadHeaderCombinatorAlias);
+
+impl SpecCombinator for SpecGenericPayloadHeaderCombinator {
+    type Type = SpecGenericPayloadHeader;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecGenericPayloadHeaderCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecGenericPayloadHeaderCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecGenericPayloadHeaderCombinatorAlias = Mapped<SpecGenericPayloadHeaderCombinatorAlias2, GenericPayloadHeaderMapper>;
+type GenericPayloadHeaderCombinatorAlias1 = (PayloadCriticalCombinator, Refined<U16Be, Predicate17149271707383182075>);
+type GenericPayloadHeaderCombinatorAlias2 = (NextPayloadTypeCombinator, GenericPayloadHeaderCombinator1);
+pub struct GenericPayloadHeaderCombinator1(pub GenericPayloadHeaderCombinatorAlias1);
+impl View for GenericPayloadHeaderCombinator1 {
+    type V = SpecGenericPayloadHeaderCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(GenericPayloadHeaderCombinator1, GenericPayloadHeaderCombinatorAlias1);
+
+pub struct GenericPayloadHeaderCombinator2(pub GenericPayloadHeaderCombinatorAlias2);
+impl View for GenericPayloadHeaderCombinator2 {
+    type V = SpecGenericPayloadHeaderCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(GenericPayloadHeaderCombinator2, GenericPayloadHeaderCombinatorAlias2);
+
+pub struct GenericPayloadHeaderCombinator(pub GenericPayloadHeaderCombinatorAlias);
+
+impl View for GenericPayloadHeaderCombinator {
+    type V = SpecGenericPayloadHeaderCombinator;
+    open spec fn view(&self) -> Self::V { SpecGenericPayloadHeaderCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GenericPayloadHeaderCombinator {
+    type Type = GenericPayloadHeader;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type GenericPayloadHeaderCombinatorAlias = Mapped<GenericPayloadHeaderCombinator2, GenericPayloadHeaderMapper>;
+
+
+pub open spec fn spec_generic_payload_header() -> SpecGenericPayloadHeaderCombinator {
+    SpecGenericPayloadHeaderCombinator(
+    Mapped {
+        inner: (spec_next_payload_type(), (spec_payload_critical(), Refined { inner: U16Be, predicate: Predicate17149271707383182075 })),
+        mapper: GenericPayloadHeaderMapper,
+    })
+}
+
+                
+pub fn generic_payload_header<'a>() -> (o: GenericPayloadHeaderCombinator)
+    ensures o@ == spec_generic_payload_header(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = GenericPayloadHeaderCombinator(
+    Mapped {
+        inner: GenericPayloadHeaderCombinator2((next_payload_type(), GenericPayloadHeaderCombinator1((payload_critical(), Refined { inner: U16Be, predicate: Predicate17149271707383182075 })))),
+        mapper: GenericPayloadHeaderMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_generic_payload_header()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_generic_payload_header<'a>(input: &'a [u8]) -> (res: PResult<<GenericPayloadHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_generic_payload_header().spec_parse(input@) == Some((n as int, v@)),
+        spec_generic_payload_header().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_generic_payload_header().spec_parse(input@) is None,
+        spec_generic_payload_header().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = generic_payload_header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_generic_payload_header<'a>(v: <GenericPayloadHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_generic_payload_header().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_generic_payload_header().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_generic_payload_header().spec_serialize(v@).len(),
+{
+    let combinator = generic_payload_header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecIkev2SkPayloadInner {
+    pub encrypted_body: Seq<u8>,
+}
+
+pub type SpecIkev2SkPayloadInnerInner = Seq<u8>;
+
+
+impl SpecFrom<SpecIkev2SkPayloadInner> for SpecIkev2SkPayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2SkPayloadInner) -> SpecIkev2SkPayloadInnerInner {
+        m.encrypted_body
+    }
+}
+
+impl SpecFrom<SpecIkev2SkPayloadInnerInner> for SpecIkev2SkPayloadInner {
+    open spec fn spec_from(m: SpecIkev2SkPayloadInnerInner) -> SpecIkev2SkPayloadInner {
+        let encrypted_body = m;
+        SpecIkev2SkPayloadInner { encrypted_body }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2SkPayloadInner<'a> {
+    pub encrypted_body: &'a [u8],
+}
+
+impl View for Ikev2SkPayloadInner<'_> {
+    type V = SpecIkev2SkPayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2SkPayloadInner {
+            encrypted_body: self.encrypted_body@,
+        }
+    }
+}
+pub type Ikev2SkPayloadInnerInner<'a> = &'a [u8];
+
+pub type Ikev2SkPayloadInnerInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a Ikev2SkPayloadInner<'a>> for Ikev2SkPayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2SkPayloadInner) -> Ikev2SkPayloadInnerInnerRef<'a> {
+        &m.encrypted_body
+    }
+}
+
+impl<'a> From<Ikev2SkPayloadInnerInner<'a>> for Ikev2SkPayloadInner<'a> {
+    fn ex_from(m: Ikev2SkPayloadInnerInner) -> Ikev2SkPayloadInner {
+        let encrypted_body = m;
+        Ikev2SkPayloadInner { encrypted_body }
+    }
+}
+
+pub struct Ikev2SkPayloadInnerMapper;
+impl View for Ikev2SkPayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2SkPayloadInnerMapper {
+    type Src = SpecIkev2SkPayloadInnerInner;
+    type Dst = SpecIkev2SkPayloadInner;
+}
+impl SpecIsoProof for Ikev2SkPayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2SkPayloadInnerMapper {
+    type Src = Ikev2SkPayloadInnerInner<'a>;
+    type Dst = Ikev2SkPayloadInner<'a>;
+    type RefSrc = Ikev2SkPayloadInnerInnerRef<'a>;
+}
+
+pub struct SpecIkev2SkPayloadInnerCombinator(pub SpecIkev2SkPayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2SkPayloadInnerCombinator {
+    type Type = SpecIkev2SkPayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2SkPayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2SkPayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2SkPayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2SkPayloadInnerMapper>;
+
+pub struct Ikev2SkPayloadInnerCombinator(pub Ikev2SkPayloadInnerCombinatorAlias);
+
+impl View for Ikev2SkPayloadInnerCombinator {
+    type V = SpecIkev2SkPayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2SkPayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2SkPayloadInnerCombinator {
+    type Type = Ikev2SkPayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2SkPayloadInnerCombinatorAlias = Mapped<bytes::Tail, Ikev2SkPayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_sk_payload_inner() -> SpecIkev2SkPayloadInnerCombinator {
+    SpecIkev2SkPayloadInnerCombinator(
+    Mapped {
+        inner: bytes::Tail,
+        mapper: Ikev2SkPayloadInnerMapper,
+    })
+}
+
+                
+pub fn ikev2_sk_payload_inner<'a>() -> (o: Ikev2SkPayloadInnerCombinator)
+    ensures o@ == spec_ikev2_sk_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2SkPayloadInnerCombinator(
+    Mapped {
+        inner: bytes::Tail,
+        mapper: Ikev2SkPayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_sk_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_sk_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2SkPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_sk_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_sk_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_sk_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_sk_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_sk_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_sk_payload_inner<'a>(v: <Ikev2SkPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_sk_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_sk_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_sk_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_sk_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecTsIpv4 {
+    pub ts_type: u8,
+    pub ip_protocol_id: u8,
+    pub selector_length: u16,
+    pub start_port: u16,
+    pub end_port: u16,
+    pub start_address: Seq<u8>,
+    pub end_address: Seq<u8>,
+}
+
+pub type SpecTsIpv4Inner = (u8, (u8, (u16, (u16, (u16, (Seq<u8>, Seq<u8>))))));
+
+
+impl SpecFrom<SpecTsIpv4> for SpecTsIpv4Inner {
+    open spec fn spec_from(m: SpecTsIpv4) -> SpecTsIpv4Inner {
+        (m.ts_type, (m.ip_protocol_id, (m.selector_length, (m.start_port, (m.end_port, (m.start_address, m.end_address))))))
+    }
+}
+
+impl SpecFrom<SpecTsIpv4Inner> for SpecTsIpv4 {
+    open spec fn spec_from(m: SpecTsIpv4Inner) -> SpecTsIpv4 {
+        let (ts_type, (ip_protocol_id, (selector_length, (start_port, (end_port, (start_address, end_address)))))) = m;
+        SpecTsIpv4 { ts_type, ip_protocol_id, selector_length, start_port, end_port, start_address, end_address }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct TsIpv4<'a> {
+    pub ts_type: u8,
+    pub ip_protocol_id: u8,
+    pub selector_length: u16,
+    pub start_port: u16,
+    pub end_port: u16,
+    pub start_address: &'a [u8],
+    pub end_address: &'a [u8],
+}
+
+impl View for TsIpv4<'_> {
+    type V = SpecTsIpv4;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTsIpv4 {
+            ts_type: self.ts_type@,
+            ip_protocol_id: self.ip_protocol_id@,
+            selector_length: self.selector_length@,
+            start_port: self.start_port@,
+            end_port: self.end_port@,
+            start_address: self.start_address@,
+            end_address: self.end_address@,
+        }
+    }
+}
+pub type TsIpv4Inner<'a> = (u8, (u8, (u16, (u16, (u16, (&'a [u8], &'a [u8]))))));
+
+pub type TsIpv4InnerRef<'a> = (&'a u8, (&'a u8, (&'a u16, (&'a u16, (&'a u16, (&'a &'a [u8], &'a &'a [u8]))))));
+impl<'a> From<&'a TsIpv4<'a>> for TsIpv4InnerRef<'a> {
+    fn ex_from(m: &'a TsIpv4) -> TsIpv4InnerRef<'a> {
+        (&m.ts_type, (&m.ip_protocol_id, (&m.selector_length, (&m.start_port, (&m.end_port, (&m.start_address, &m.end_address))))))
+    }
+}
+
+impl<'a> From<TsIpv4Inner<'a>> for TsIpv4<'a> {
+    fn ex_from(m: TsIpv4Inner) -> TsIpv4 {
+        let (ts_type, (ip_protocol_id, (selector_length, (start_port, (end_port, (start_address, end_address)))))) = m;
+        TsIpv4 { ts_type, ip_protocol_id, selector_length, start_port, end_port, start_address, end_address }
+    }
+}
+
+pub struct TsIpv4Mapper;
+impl View for TsIpv4Mapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TsIpv4Mapper {
+    type Src = SpecTsIpv4Inner;
+    type Dst = SpecTsIpv4;
+}
+impl SpecIsoProof for TsIpv4Mapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TsIpv4Mapper {
+    type Src = TsIpv4Inner<'a>;
+    type Dst = TsIpv4<'a>;
+    type RefSrc = TsIpv4InnerRef<'a>;
+}
+pub const TSIPV4TS_TYPE_CONST: u8 = 7;
+pub const TSIPV4SELECTOR_LENGTH_CONST: u16 = 16;
+type SpecTsIpv4CombinatorAlias1 = (bytes::Fixed<4>, bytes::Fixed<4>);
+type SpecTsIpv4CombinatorAlias2 = (U16Be, SpecTsIpv4CombinatorAlias1);
+type SpecTsIpv4CombinatorAlias3 = (U16Be, SpecTsIpv4CombinatorAlias2);
+type SpecTsIpv4CombinatorAlias4 = (Refined<U16Be, TagPred<u16>>, SpecTsIpv4CombinatorAlias3);
+type SpecTsIpv4CombinatorAlias5 = (U8, SpecTsIpv4CombinatorAlias4);
+type SpecTsIpv4CombinatorAlias6 = (Refined<U8, TagPred<u8>>, SpecTsIpv4CombinatorAlias5);
+pub struct SpecTsIpv4Combinator(pub SpecTsIpv4CombinatorAlias);
+
+impl SpecCombinator for SpecTsIpv4Combinator {
+    type Type = SpecTsIpv4;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTsIpv4Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTsIpv4CombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTsIpv4CombinatorAlias = Mapped<SpecTsIpv4CombinatorAlias6, TsIpv4Mapper>;
+type TsIpv4CombinatorAlias1 = (bytes::Fixed<4>, bytes::Fixed<4>);
+type TsIpv4CombinatorAlias2 = (U16Be, TsIpv4Combinator1);
+type TsIpv4CombinatorAlias3 = (U16Be, TsIpv4Combinator2);
+type TsIpv4CombinatorAlias4 = (Refined<U16Be, TagPred<u16>>, TsIpv4Combinator3);
+type TsIpv4CombinatorAlias5 = (U8, TsIpv4Combinator4);
+type TsIpv4CombinatorAlias6 = (Refined<U8, TagPred<u8>>, TsIpv4Combinator5);
+pub struct TsIpv4Combinator1(pub TsIpv4CombinatorAlias1);
+impl View for TsIpv4Combinator1 {
+    type V = SpecTsIpv4CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv4Combinator1, TsIpv4CombinatorAlias1);
+
+pub struct TsIpv4Combinator2(pub TsIpv4CombinatorAlias2);
+impl View for TsIpv4Combinator2 {
+    type V = SpecTsIpv4CombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv4Combinator2, TsIpv4CombinatorAlias2);
+
+pub struct TsIpv4Combinator3(pub TsIpv4CombinatorAlias3);
+impl View for TsIpv4Combinator3 {
+    type V = SpecTsIpv4CombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv4Combinator3, TsIpv4CombinatorAlias3);
+
+pub struct TsIpv4Combinator4(pub TsIpv4CombinatorAlias4);
+impl View for TsIpv4Combinator4 {
+    type V = SpecTsIpv4CombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv4Combinator4, TsIpv4CombinatorAlias4);
+
+pub struct TsIpv4Combinator5(pub TsIpv4CombinatorAlias5);
+impl View for TsIpv4Combinator5 {
+    type V = SpecTsIpv4CombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv4Combinator5, TsIpv4CombinatorAlias5);
+
+pub struct TsIpv4Combinator6(pub TsIpv4CombinatorAlias6);
+impl View for TsIpv4Combinator6 {
+    type V = SpecTsIpv4CombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TsIpv4Combinator6, TsIpv4CombinatorAlias6);
+
+pub struct TsIpv4Combinator(pub TsIpv4CombinatorAlias);
+
+impl View for TsIpv4Combinator {
+    type V = SpecTsIpv4Combinator;
+    open spec fn view(&self) -> Self::V { SpecTsIpv4Combinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TsIpv4Combinator {
+    type Type = TsIpv4<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TsIpv4CombinatorAlias = Mapped<TsIpv4Combinator6, TsIpv4Mapper>;
+
+
+pub open spec fn spec_ts_ipv4() -> SpecTsIpv4Combinator {
+    SpecTsIpv4Combinator(
+    Mapped {
+        inner: (Refined { inner: U8, predicate: TagPred(TSIPV4TS_TYPE_CONST) }, (U8, (Refined { inner: U16Be, predicate: TagPred(TSIPV4SELECTOR_LENGTH_CONST) }, (U16Be, (U16Be, (bytes::Fixed::<4>, bytes::Fixed::<4>)))))),
+        mapper: TsIpv4Mapper,
+    })
+}
+
+                
+pub fn ts_ipv4<'a>() -> (o: TsIpv4Combinator)
+    ensures o@ == spec_ts_ipv4(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TsIpv4Combinator(
+    Mapped {
+        inner: TsIpv4Combinator6((Refined { inner: U8, predicate: TagPred(TSIPV4TS_TYPE_CONST) }, TsIpv4Combinator5((U8, TsIpv4Combinator4((Refined { inner: U16Be, predicate: TagPred(TSIPV4SELECTOR_LENGTH_CONST) }, TsIpv4Combinator3((U16Be, TsIpv4Combinator2((U16Be, TsIpv4Combinator1((bytes::Fixed::<4>, bytes::Fixed::<4>)))))))))))),
+        mapper: TsIpv4Mapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ts_ipv4()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ts_ipv4<'a>(input: &'a [u8]) -> (res: PResult<<TsIpv4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ts_ipv4().spec_parse(input@) == Some((n as int, v@)),
+        spec_ts_ipv4().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ts_ipv4().spec_parse(input@) is None,
+        spec_ts_ipv4().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ts_ipv4();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ts_ipv4<'a>(v: <TsIpv4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ts_ipv4().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ts_ipv4().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ts_ipv4().spec_serialize(v@).len(),
+{
+    let combinator = ts_ipv4();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecIkev2CpPayloadInner {
+    pub cfg_type: u8,
+    pub reserved: Seq<u8>,
+    pub attributes: Seq<SpecCfgAttribute>,
+}
+
+pub type SpecIkev2CpPayloadInnerInner = (u8, (Seq<u8>, Seq<SpecCfgAttribute>));
+
+
+impl SpecFrom<SpecIkev2CpPayloadInner> for SpecIkev2CpPayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2CpPayloadInner) -> SpecIkev2CpPayloadInnerInner {
+        (m.cfg_type, (m.reserved, m.attributes))
+    }
+}
+
+impl SpecFrom<SpecIkev2CpPayloadInnerInner> for SpecIkev2CpPayloadInner {
+    open spec fn spec_from(m: SpecIkev2CpPayloadInnerInner) -> SpecIkev2CpPayloadInner {
+        let (cfg_type, (reserved, attributes)) = m;
+        SpecIkev2CpPayloadInner { cfg_type, reserved, attributes }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2CpPayloadInner<'a> {
+    pub cfg_type: u8,
+    pub reserved: &'a [u8],
+    pub attributes: RepeatResult<CfgAttribute<'a>>,
+}
+
+impl View for Ikev2CpPayloadInner<'_> {
+    type V = SpecIkev2CpPayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2CpPayloadInner {
+            cfg_type: self.cfg_type@,
+            reserved: self.reserved@,
+            attributes: self.attributes@,
+        }
+    }
+}
+pub type Ikev2CpPayloadInnerInner<'a> = (u8, (&'a [u8], RepeatResult<CfgAttribute<'a>>));
+
+pub type Ikev2CpPayloadInnerInnerRef<'a> = (&'a u8, (&'a &'a [u8], &'a RepeatResult<CfgAttribute<'a>>));
+impl<'a> From<&'a Ikev2CpPayloadInner<'a>> for Ikev2CpPayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2CpPayloadInner) -> Ikev2CpPayloadInnerInnerRef<'a> {
+        (&m.cfg_type, (&m.reserved, &m.attributes))
+    }
+}
+
+impl<'a> From<Ikev2CpPayloadInnerInner<'a>> for Ikev2CpPayloadInner<'a> {
+    fn ex_from(m: Ikev2CpPayloadInnerInner) -> Ikev2CpPayloadInner {
+        let (cfg_type, (reserved, attributes)) = m;
+        Ikev2CpPayloadInner { cfg_type, reserved, attributes }
+    }
+}
+
+pub struct Ikev2CpPayloadInnerMapper;
+impl View for Ikev2CpPayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2CpPayloadInnerMapper {
+    type Src = SpecIkev2CpPayloadInnerInner;
+    type Dst = SpecIkev2CpPayloadInner;
+}
+impl SpecIsoProof for Ikev2CpPayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2CpPayloadInnerMapper {
+    type Src = Ikev2CpPayloadInnerInner<'a>;
+    type Dst = Ikev2CpPayloadInner<'a>;
+    type RefSrc = Ikev2CpPayloadInnerInnerRef<'a>;
+}
+pub spec const SPEC_IKEV2CPPAYLOADINNERRESERVED_CONST: Seq<u8> = seq![0; 3];type SpecIkev2CpPayloadInnerCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, AndThen<bytes::Tail, Repeat<SpecCfgAttributeCombinator>>);
+type SpecIkev2CpPayloadInnerCombinatorAlias2 = (SpecCfgTypeCombinator, SpecIkev2CpPayloadInnerCombinatorAlias1);
+pub struct SpecIkev2CpPayloadInnerCombinator(pub SpecIkev2CpPayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2CpPayloadInnerCombinator {
+    type Type = SpecIkev2CpPayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2CpPayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2CpPayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2CpPayloadInnerCombinatorAlias = Mapped<SpecIkev2CpPayloadInnerCombinatorAlias2, Ikev2CpPayloadInnerMapper>;
+pub exec static IKEV2CPPAYLOADINNERRESERVED_CONST: [u8; 3]
+    ensures IKEV2CPPAYLOADINNERRESERVED_CONST@ == SPEC_IKEV2CPPAYLOADINNERRESERVED_CONST,
+{
+    let arr: [u8; 3] = [0; 3];
+    assert(arr@ == SPEC_IKEV2CPPAYLOADINNERRESERVED_CONST);
+    arr
+}
+type Ikev2CpPayloadInnerCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, AndThen<bytes::Tail, Repeat<CfgAttributeCombinator>>);
+type Ikev2CpPayloadInnerCombinatorAlias2 = (CfgTypeCombinator, Ikev2CpPayloadInnerCombinator1);
+pub struct Ikev2CpPayloadInnerCombinator1(pub Ikev2CpPayloadInnerCombinatorAlias1);
+impl View for Ikev2CpPayloadInnerCombinator1 {
+    type V = SpecIkev2CpPayloadInnerCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2CpPayloadInnerCombinator1, Ikev2CpPayloadInnerCombinatorAlias1);
+
+pub struct Ikev2CpPayloadInnerCombinator2(pub Ikev2CpPayloadInnerCombinatorAlias2);
+impl View for Ikev2CpPayloadInnerCombinator2 {
+    type V = SpecIkev2CpPayloadInnerCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2CpPayloadInnerCombinator2, Ikev2CpPayloadInnerCombinatorAlias2);
+
+pub struct Ikev2CpPayloadInnerCombinator(pub Ikev2CpPayloadInnerCombinatorAlias);
+
+impl View for Ikev2CpPayloadInnerCombinator {
+    type V = SpecIkev2CpPayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2CpPayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2CpPayloadInnerCombinator {
+    type Type = Ikev2CpPayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2CpPayloadInnerCombinatorAlias = Mapped<Ikev2CpPayloadInnerCombinator2, Ikev2CpPayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_cp_payload_inner() -> SpecIkev2CpPayloadInnerCombinator {
+    SpecIkev2CpPayloadInnerCombinator(
+    Mapped {
+        inner: (spec_cfg_type(), (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(SPEC_IKEV2CPPAYLOADINNERRESERVED_CONST) }, AndThen(bytes::Tail, Repeat(spec_cfg_attribute())))),
+        mapper: Ikev2CpPayloadInnerMapper,
+    })
+}
+
+                
+pub fn ikev2_cp_payload_inner<'a>() -> (o: Ikev2CpPayloadInnerCombinator)
+    ensures o@ == spec_ikev2_cp_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2CpPayloadInnerCombinator(
+    Mapped {
+        inner: Ikev2CpPayloadInnerCombinator2((cfg_type(), Ikev2CpPayloadInnerCombinator1((Refined { inner: bytes::Fixed::<3>, predicate: TagPred(IKEV2CPPAYLOADINNERRESERVED_CONST) }, AndThen(bytes::Tail, Repeat::new(cfg_attribute())))))),
+        mapper: Ikev2CpPayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_cp_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_cp_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2CpPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_cp_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_cp_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_cp_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_cp_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_cp_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_cp_payload_inner<'a>(v: <Ikev2CpPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_cp_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_cp_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_cp_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_cp_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecIkev2KePayloadInner {
+    pub dh_group_num: u16,
+    pub reserved: u16,
+    pub ke_data: Seq<u8>,
+}
+
+pub type SpecIkev2KePayloadInnerInner = (u16, (u16, Seq<u8>));
+
+
+impl SpecFrom<SpecIkev2KePayloadInner> for SpecIkev2KePayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2KePayloadInner) -> SpecIkev2KePayloadInnerInner {
+        (m.dh_group_num, (m.reserved, m.ke_data))
+    }
+}
+
+impl SpecFrom<SpecIkev2KePayloadInnerInner> for SpecIkev2KePayloadInner {
+    open spec fn spec_from(m: SpecIkev2KePayloadInnerInner) -> SpecIkev2KePayloadInner {
+        let (dh_group_num, (reserved, ke_data)) = m;
+        SpecIkev2KePayloadInner { dh_group_num, reserved, ke_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2KePayloadInner<'a> {
+    pub dh_group_num: u16,
+    pub reserved: u16,
+    pub ke_data: &'a [u8],
+}
+
+impl View for Ikev2KePayloadInner<'_> {
+    type V = SpecIkev2KePayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2KePayloadInner {
+            dh_group_num: self.dh_group_num@,
+            reserved: self.reserved@,
+            ke_data: self.ke_data@,
+        }
+    }
+}
+pub type Ikev2KePayloadInnerInner<'a> = (u16, (u16, &'a [u8]));
+
+pub type Ikev2KePayloadInnerInnerRef<'a> = (&'a u16, (&'a u16, &'a &'a [u8]));
+impl<'a> From<&'a Ikev2KePayloadInner<'a>> for Ikev2KePayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2KePayloadInner) -> Ikev2KePayloadInnerInnerRef<'a> {
+        (&m.dh_group_num, (&m.reserved, &m.ke_data))
+    }
+}
+
+impl<'a> From<Ikev2KePayloadInnerInner<'a>> for Ikev2KePayloadInner<'a> {
+    fn ex_from(m: Ikev2KePayloadInnerInner) -> Ikev2KePayloadInner {
+        let (dh_group_num, (reserved, ke_data)) = m;
+        Ikev2KePayloadInner { dh_group_num, reserved, ke_data }
+    }
+}
+
+pub struct Ikev2KePayloadInnerMapper;
+impl View for Ikev2KePayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2KePayloadInnerMapper {
+    type Src = SpecIkev2KePayloadInnerInner;
+    type Dst = SpecIkev2KePayloadInner;
+}
+impl SpecIsoProof for Ikev2KePayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2KePayloadInnerMapper {
+    type Src = Ikev2KePayloadInnerInner<'a>;
+    type Dst = Ikev2KePayloadInner<'a>;
+    type RefSrc = Ikev2KePayloadInnerInnerRef<'a>;
+}
+pub const IKEV2KEPAYLOADINNERRESERVED_CONST: u16 = 0;
+type SpecIkev2KePayloadInnerCombinatorAlias1 = (Refined<U16Be, TagPred<u16>>, bytes::Tail);
+type SpecIkev2KePayloadInnerCombinatorAlias2 = (SpecDhIdCombinator, SpecIkev2KePayloadInnerCombinatorAlias1);
+pub struct SpecIkev2KePayloadInnerCombinator(pub SpecIkev2KePayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2KePayloadInnerCombinator {
+    type Type = SpecIkev2KePayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2KePayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2KePayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2KePayloadInnerCombinatorAlias = Mapped<SpecIkev2KePayloadInnerCombinatorAlias2, Ikev2KePayloadInnerMapper>;
+type Ikev2KePayloadInnerCombinatorAlias1 = (Refined<U16Be, TagPred<u16>>, bytes::Tail);
+type Ikev2KePayloadInnerCombinatorAlias2 = (DhIdCombinator, Ikev2KePayloadInnerCombinator1);
+pub struct Ikev2KePayloadInnerCombinator1(pub Ikev2KePayloadInnerCombinatorAlias1);
+impl View for Ikev2KePayloadInnerCombinator1 {
+    type V = SpecIkev2KePayloadInnerCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2KePayloadInnerCombinator1, Ikev2KePayloadInnerCombinatorAlias1);
+
+pub struct Ikev2KePayloadInnerCombinator2(pub Ikev2KePayloadInnerCombinatorAlias2);
+impl View for Ikev2KePayloadInnerCombinator2 {
+    type V = SpecIkev2KePayloadInnerCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2KePayloadInnerCombinator2, Ikev2KePayloadInnerCombinatorAlias2);
+
+pub struct Ikev2KePayloadInnerCombinator(pub Ikev2KePayloadInnerCombinatorAlias);
+
+impl View for Ikev2KePayloadInnerCombinator {
+    type V = SpecIkev2KePayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2KePayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2KePayloadInnerCombinator {
+    type Type = Ikev2KePayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2KePayloadInnerCombinatorAlias = Mapped<Ikev2KePayloadInnerCombinator2, Ikev2KePayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_ke_payload_inner() -> SpecIkev2KePayloadInnerCombinator {
+    SpecIkev2KePayloadInnerCombinator(
+    Mapped {
+        inner: (spec_dh_id(), (Refined { inner: U16Be, predicate: TagPred(IKEV2KEPAYLOADINNERRESERVED_CONST) }, bytes::Tail)),
+        mapper: Ikev2KePayloadInnerMapper,
+    })
+}
+
+                
+pub fn ikev2_ke_payload_inner<'a>() -> (o: Ikev2KePayloadInnerCombinator)
+    ensures o@ == spec_ikev2_ke_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2KePayloadInnerCombinator(
+    Mapped {
+        inner: Ikev2KePayloadInnerCombinator2((dh_id(), Ikev2KePayloadInnerCombinator1((Refined { inner: U16Be, predicate: TagPred(IKEV2KEPAYLOADINNERRESERVED_CONST) }, bytes::Tail)))),
+        mapper: Ikev2KePayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_ke_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_ke_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2KePayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_ke_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_ke_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_ke_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_ke_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_ke_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_ke_payload_inner<'a>(v: <Ikev2KePayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_ke_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_ke_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_ke_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_ke_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecAuthPayloadBody {
+    pub auth_method: u8,
+    pub reserved: Seq<u8>,
+    pub auth_data: Seq<u8>,
+}
+
+pub type SpecAuthPayloadBodyInner = (u8, (Seq<u8>, Seq<u8>));
+
+
+impl SpecFrom<SpecAuthPayloadBody> for SpecAuthPayloadBodyInner {
+    open spec fn spec_from(m: SpecAuthPayloadBody) -> SpecAuthPayloadBodyInner {
+        (m.auth_method, (m.reserved, m.auth_data))
+    }
+}
+
+impl SpecFrom<SpecAuthPayloadBodyInner> for SpecAuthPayloadBody {
+    open spec fn spec_from(m: SpecAuthPayloadBodyInner) -> SpecAuthPayloadBody {
+        let (auth_method, (reserved, auth_data)) = m;
+        SpecAuthPayloadBody { auth_method, reserved, auth_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct AuthPayloadBody<'a> {
+    pub auth_method: u8,
+    pub reserved: &'a [u8],
+    pub auth_data: &'a [u8],
+}
+
+impl View for AuthPayloadBody<'_> {
+    type V = SpecAuthPayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecAuthPayloadBody {
+            auth_method: self.auth_method@,
+            reserved: self.reserved@,
+            auth_data: self.auth_data@,
+        }
+    }
+}
+pub type AuthPayloadBodyInner<'a> = (u8, (&'a [u8], &'a [u8]));
+
+pub type AuthPayloadBodyInnerRef<'a> = (&'a u8, (&'a &'a [u8], &'a &'a [u8]));
+impl<'a> From<&'a AuthPayloadBody<'a>> for AuthPayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a AuthPayloadBody) -> AuthPayloadBodyInnerRef<'a> {
+        (&m.auth_method, (&m.reserved, &m.auth_data))
+    }
+}
+
+impl<'a> From<AuthPayloadBodyInner<'a>> for AuthPayloadBody<'a> {
+    fn ex_from(m: AuthPayloadBodyInner) -> AuthPayloadBody {
+        let (auth_method, (reserved, auth_data)) = m;
+        AuthPayloadBody { auth_method, reserved, auth_data }
+    }
+}
+
+pub struct AuthPayloadBodyMapper;
+impl View for AuthPayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for AuthPayloadBodyMapper {
+    type Src = SpecAuthPayloadBodyInner;
+    type Dst = SpecAuthPayloadBody;
+}
+impl SpecIsoProof for AuthPayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for AuthPayloadBodyMapper {
+    type Src = AuthPayloadBodyInner<'a>;
+    type Dst = AuthPayloadBody<'a>;
+    type RefSrc = AuthPayloadBodyInnerRef<'a>;
+}
+pub spec const SPEC_AUTHPAYLOADBODYRESERVED_CONST: Seq<u8> = seq![0; 3];type SpecAuthPayloadBodyCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, bytes::Variable);
+type SpecAuthPayloadBodyCombinatorAlias2 = (SpecAuthMethodCombinator, SpecAuthPayloadBodyCombinatorAlias1);
+pub struct SpecAuthPayloadBodyCombinator(pub SpecAuthPayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecAuthPayloadBodyCombinator {
+    type Type = SpecAuthPayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecAuthPayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecAuthPayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecAuthPayloadBodyCombinatorAlias = Mapped<SpecAuthPayloadBodyCombinatorAlias2, AuthPayloadBodyMapper>;
+pub exec static AUTHPAYLOADBODYRESERVED_CONST: [u8; 3]
+    ensures AUTHPAYLOADBODYRESERVED_CONST@ == SPEC_AUTHPAYLOADBODYRESERVED_CONST,
+{
+    let arr: [u8; 3] = [0; 3];
+    assert(arr@ == SPEC_AUTHPAYLOADBODYRESERVED_CONST);
+    arr
+}
+type AuthPayloadBodyCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, bytes::Variable);
+type AuthPayloadBodyCombinatorAlias2 = (AuthMethodCombinator, AuthPayloadBodyCombinator1);
+pub struct AuthPayloadBodyCombinator1(pub AuthPayloadBodyCombinatorAlias1);
+impl View for AuthPayloadBodyCombinator1 {
+    type V = SpecAuthPayloadBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(AuthPayloadBodyCombinator1, AuthPayloadBodyCombinatorAlias1);
+
+pub struct AuthPayloadBodyCombinator2(pub AuthPayloadBodyCombinatorAlias2);
+impl View for AuthPayloadBodyCombinator2 {
+    type V = SpecAuthPayloadBodyCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(AuthPayloadBodyCombinator2, AuthPayloadBodyCombinatorAlias2);
+
+pub struct AuthPayloadBodyCombinator(pub AuthPayloadBodyCombinatorAlias);
+
+impl View for AuthPayloadBodyCombinator {
+    type V = SpecAuthPayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecAuthPayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AuthPayloadBodyCombinator {
+    type Type = AuthPayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type AuthPayloadBodyCombinatorAlias = Mapped<AuthPayloadBodyCombinator2, AuthPayloadBodyMapper>;
+
+
+pub open spec fn spec_auth_payload_body(payload_length: u16) -> SpecAuthPayloadBodyCombinator {
+    SpecAuthPayloadBodyCombinator(
+    Mapped {
+        inner: (spec_auth_method(), (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(SPEC_AUTHPAYLOADBODYRESERVED_CONST) }, bytes::Variable(((usize::spec_from(payload_length) - 8)) as usize))),
+        mapper: AuthPayloadBodyMapper,
+    })
+}
+
+pub fn auth_payload_body<'a>(payload_length: u16) -> (o: AuthPayloadBodyCombinator)
+    requires
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures o@ == spec_auth_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = AuthPayloadBodyCombinator(
+    Mapped {
+        inner: AuthPayloadBodyCombinator2((auth_method(), AuthPayloadBodyCombinator1((Refined { inner: bytes::Fixed::<3>, predicate: TagPred(AUTHPAYLOADBODYRESERVED_CONST) }, bytes::Variable(((usize::ex_from(payload_length) - 8)) as usize))))),
+        mapper: AuthPayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_auth_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_auth_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<AuthPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_auth_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_auth_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_auth_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_auth_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = auth_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_auth_payload_body<'a>(v: <AuthPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_auth_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_auth_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_auth_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = auth_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecIdPayloadBody {
+    pub id_type: u8,
+    pub reserved: Seq<u8>,
+    pub id_data: Seq<u8>,
+}
+
+pub type SpecIdPayloadBodyInner = (u8, (Seq<u8>, Seq<u8>));
+
+
+impl SpecFrom<SpecIdPayloadBody> for SpecIdPayloadBodyInner {
+    open spec fn spec_from(m: SpecIdPayloadBody) -> SpecIdPayloadBodyInner {
+        (m.id_type, (m.reserved, m.id_data))
+    }
+}
+
+impl SpecFrom<SpecIdPayloadBodyInner> for SpecIdPayloadBody {
+    open spec fn spec_from(m: SpecIdPayloadBodyInner) -> SpecIdPayloadBody {
+        let (id_type, (reserved, id_data)) = m;
+        SpecIdPayloadBody { id_type, reserved, id_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct IdPayloadBody<'a> {
+    pub id_type: u8,
+    pub reserved: &'a [u8],
+    pub id_data: &'a [u8],
+}
+
+impl View for IdPayloadBody<'_> {
+    type V = SpecIdPayloadBody;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIdPayloadBody {
+            id_type: self.id_type@,
+            reserved: self.reserved@,
+            id_data: self.id_data@,
+        }
+    }
+}
+pub type IdPayloadBodyInner<'a> = (u8, (&'a [u8], &'a [u8]));
+
+pub type IdPayloadBodyInnerRef<'a> = (&'a u8, (&'a &'a [u8], &'a &'a [u8]));
+impl<'a> From<&'a IdPayloadBody<'a>> for IdPayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a IdPayloadBody) -> IdPayloadBodyInnerRef<'a> {
+        (&m.id_type, (&m.reserved, &m.id_data))
+    }
+}
+
+impl<'a> From<IdPayloadBodyInner<'a>> for IdPayloadBody<'a> {
+    fn ex_from(m: IdPayloadBodyInner) -> IdPayloadBody {
+        let (id_type, (reserved, id_data)) = m;
+        IdPayloadBody { id_type, reserved, id_data }
+    }
+}
+
+pub struct IdPayloadBodyMapper;
+impl View for IdPayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for IdPayloadBodyMapper {
+    type Src = SpecIdPayloadBodyInner;
+    type Dst = SpecIdPayloadBody;
+}
+impl SpecIsoProof for IdPayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for IdPayloadBodyMapper {
+    type Src = IdPayloadBodyInner<'a>;
+    type Dst = IdPayloadBody<'a>;
+    type RefSrc = IdPayloadBodyInnerRef<'a>;
+}
+pub spec const SPEC_IDPAYLOADBODYRESERVED_CONST: Seq<u8> = seq![0; 3];type SpecIdPayloadBodyCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<Seq<u8>>>, bytes::Variable);
+type SpecIdPayloadBodyCombinatorAlias2 = (SpecIdTypeCombinator, SpecIdPayloadBodyCombinatorAlias1);
+pub struct SpecIdPayloadBodyCombinator(pub SpecIdPayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecIdPayloadBodyCombinator {
+    type Type = SpecIdPayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIdPayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIdPayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIdPayloadBodyCombinatorAlias = Mapped<SpecIdPayloadBodyCombinatorAlias2, IdPayloadBodyMapper>;
+pub exec static IDPAYLOADBODYRESERVED_CONST: [u8; 3]
+    ensures IDPAYLOADBODYRESERVED_CONST@ == SPEC_IDPAYLOADBODYRESERVED_CONST,
+{
+    let arr: [u8; 3] = [0; 3];
+    assert(arr@ == SPEC_IDPAYLOADBODYRESERVED_CONST);
+    arr
+}
+type IdPayloadBodyCombinatorAlias1 = (Refined<bytes::Fixed<3>, TagPred<[u8; 3]>>, bytes::Variable);
+type IdPayloadBodyCombinatorAlias2 = (IdTypeCombinator, IdPayloadBodyCombinator1);
+pub struct IdPayloadBodyCombinator1(pub IdPayloadBodyCombinatorAlias1);
+impl View for IdPayloadBodyCombinator1 {
+    type V = SpecIdPayloadBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(IdPayloadBodyCombinator1, IdPayloadBodyCombinatorAlias1);
+
+pub struct IdPayloadBodyCombinator2(pub IdPayloadBodyCombinatorAlias2);
+impl View for IdPayloadBodyCombinator2 {
+    type V = SpecIdPayloadBodyCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(IdPayloadBodyCombinator2, IdPayloadBodyCombinatorAlias2);
+
+pub struct IdPayloadBodyCombinator(pub IdPayloadBodyCombinatorAlias);
+
+impl View for IdPayloadBodyCombinator {
+    type V = SpecIdPayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecIdPayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for IdPayloadBodyCombinator {
+    type Type = IdPayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type IdPayloadBodyCombinatorAlias = Mapped<IdPayloadBodyCombinator2, IdPayloadBodyMapper>;
+
+
+pub open spec fn spec_id_payload_body(payload_length: u16) -> SpecIdPayloadBodyCombinator {
+    SpecIdPayloadBodyCombinator(
+    Mapped {
+        inner: (spec_id_type(), (Refined { inner: bytes::Fixed::<3>, predicate: TagPred(SPEC_IDPAYLOADBODYRESERVED_CONST) }, bytes::Variable(((usize::spec_from(payload_length) - 8)) as usize))),
+        mapper: IdPayloadBodyMapper,
+    })
+}
+
+pub fn id_payload_body<'a>(payload_length: u16) -> (o: IdPayloadBodyCombinator)
+    requires
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures o@ == spec_id_payload_body(payload_length@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = IdPayloadBodyCombinator(
+    Mapped {
+        inner: IdPayloadBodyCombinator2((id_type(), IdPayloadBodyCombinator1((Refined { inner: bytes::Fixed::<3>, predicate: TagPred(IDPAYLOADBODYRESERVED_CONST) }, bytes::Variable(((usize::ex_from(payload_length) - 8)) as usize))))),
+        mapper: IdPayloadBodyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_id_payload_body(payload_length@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_id_payload_body<'a>(input: &'a [u8], payload_length: u16) -> (res: PResult<<IdPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_id_payload_body(payload_length@).spec_parse(input@) == Some((n as int, v@)),
+        spec_id_payload_body(payload_length@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_id_payload_body(payload_length@).spec_parse(input@) is None,
+        spec_id_payload_body(payload_length@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = id_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_id_payload_body<'a>(v: <IdPayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, payload_length: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_id_payload_body(payload_length@).wf(v@),
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_id_payload_body(payload_length@).spec_serialize(v@).len() <= usize::MAX,
+        ((payload_length) >= 8 && (payload_length) <= 65535),
+
+    ensures
+        serialize_len == spec_id_payload_body(payload_length@).spec_serialize(v@).len(),
+{
+    let combinator = id_payload_body( payload_length );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecIkev2CertreqPayloadInner {
+    pub cert_encoding: u8,
+    pub ca_data: Seq<u8>,
+}
+
+pub type SpecIkev2CertreqPayloadInnerInner = (u8, Seq<u8>);
+
+
+impl SpecFrom<SpecIkev2CertreqPayloadInner> for SpecIkev2CertreqPayloadInnerInner {
+    open spec fn spec_from(m: SpecIkev2CertreqPayloadInner) -> SpecIkev2CertreqPayloadInnerInner {
+        (m.cert_encoding, m.ca_data)
+    }
+}
+
+impl SpecFrom<SpecIkev2CertreqPayloadInnerInner> for SpecIkev2CertreqPayloadInner {
+    open spec fn spec_from(m: SpecIkev2CertreqPayloadInnerInner) -> SpecIkev2CertreqPayloadInner {
+        let (cert_encoding, ca_data) = m;
+        SpecIkev2CertreqPayloadInner { cert_encoding, ca_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2CertreqPayloadInner<'a> {
+    pub cert_encoding: u8,
+    pub ca_data: &'a [u8],
+}
+
+impl View for Ikev2CertreqPayloadInner<'_> {
+    type V = SpecIkev2CertreqPayloadInner;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2CertreqPayloadInner {
+            cert_encoding: self.cert_encoding@,
+            ca_data: self.ca_data@,
+        }
+    }
+}
+pub type Ikev2CertreqPayloadInnerInner<'a> = (u8, &'a [u8]);
+
+pub type Ikev2CertreqPayloadInnerInnerRef<'a> = (&'a u8, &'a &'a [u8]);
+impl<'a> From<&'a Ikev2CertreqPayloadInner<'a>> for Ikev2CertreqPayloadInnerInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2CertreqPayloadInner) -> Ikev2CertreqPayloadInnerInnerRef<'a> {
+        (&m.cert_encoding, &m.ca_data)
+    }
+}
+
+impl<'a> From<Ikev2CertreqPayloadInnerInner<'a>> for Ikev2CertreqPayloadInner<'a> {
+    fn ex_from(m: Ikev2CertreqPayloadInnerInner) -> Ikev2CertreqPayloadInner {
+        let (cert_encoding, ca_data) = m;
+        Ikev2CertreqPayloadInner { cert_encoding, ca_data }
+    }
+}
+
+pub struct Ikev2CertreqPayloadInnerMapper;
+impl View for Ikev2CertreqPayloadInnerMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2CertreqPayloadInnerMapper {
+    type Src = SpecIkev2CertreqPayloadInnerInner;
+    type Dst = SpecIkev2CertreqPayloadInner;
+}
+impl SpecIsoProof for Ikev2CertreqPayloadInnerMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2CertreqPayloadInnerMapper {
+    type Src = Ikev2CertreqPayloadInnerInner<'a>;
+    type Dst = Ikev2CertreqPayloadInner<'a>;
+    type RefSrc = Ikev2CertreqPayloadInnerInnerRef<'a>;
+}
+type SpecIkev2CertreqPayloadInnerCombinatorAlias1 = (SpecCertEncodingCombinator, bytes::Tail);
+pub struct SpecIkev2CertreqPayloadInnerCombinator(pub SpecIkev2CertreqPayloadInnerCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2CertreqPayloadInnerCombinator {
+    type Type = SpecIkev2CertreqPayloadInner;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2CertreqPayloadInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2CertreqPayloadInnerCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2CertreqPayloadInnerCombinatorAlias = Mapped<SpecIkev2CertreqPayloadInnerCombinatorAlias1, Ikev2CertreqPayloadInnerMapper>;
+type Ikev2CertreqPayloadInnerCombinatorAlias1 = (CertEncodingCombinator, bytes::Tail);
+pub struct Ikev2CertreqPayloadInnerCombinator1(pub Ikev2CertreqPayloadInnerCombinatorAlias1);
+impl View for Ikev2CertreqPayloadInnerCombinator1 {
+    type V = SpecIkev2CertreqPayloadInnerCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2CertreqPayloadInnerCombinator1, Ikev2CertreqPayloadInnerCombinatorAlias1);
+
+pub struct Ikev2CertreqPayloadInnerCombinator(pub Ikev2CertreqPayloadInnerCombinatorAlias);
+
+impl View for Ikev2CertreqPayloadInnerCombinator {
+    type V = SpecIkev2CertreqPayloadInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2CertreqPayloadInnerCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2CertreqPayloadInnerCombinator {
+    type Type = Ikev2CertreqPayloadInner<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2CertreqPayloadInnerCombinatorAlias = Mapped<Ikev2CertreqPayloadInnerCombinator1, Ikev2CertreqPayloadInnerMapper>;
+
+
+pub open spec fn spec_ikev2_certreq_payload_inner() -> SpecIkev2CertreqPayloadInnerCombinator {
+    SpecIkev2CertreqPayloadInnerCombinator(
+    Mapped {
+        inner: (spec_cert_encoding(), bytes::Tail),
+        mapper: Ikev2CertreqPayloadInnerMapper,
+    })
+}
+
+                
+pub fn ikev2_certreq_payload_inner<'a>() -> (o: Ikev2CertreqPayloadInnerCombinator)
+    ensures o@ == spec_ikev2_certreq_payload_inner(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2CertreqPayloadInnerCombinator(
+    Mapped {
+        inner: Ikev2CertreqPayloadInnerCombinator1((cert_encoding(), bytes::Tail)),
+        mapper: Ikev2CertreqPayloadInnerMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_certreq_payload_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_certreq_payload_inner<'a>(input: &'a [u8]) -> (res: PResult<<Ikev2CertreqPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_certreq_payload_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_certreq_payload_inner().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_certreq_payload_inner().spec_parse(input@) is None,
+        spec_ikev2_certreq_payload_inner().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_certreq_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_certreq_payload_inner<'a>(v: <Ikev2CertreqPayloadInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_certreq_payload_inner().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_ikev2_certreq_payload_inner().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ikev2_certreq_payload_inner().spec_serialize(v@).len(),
+{
+    let combinator = ikev2_certreq_payload_inner();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub enum SpecIkev2PayloadBody {
+    SA(SpecIkev2SaPayloadInner),
+    KE(SpecIkev2KePayloadInner),
+    IDi(SpecIkev2IdPayloadInner),
+    IDr(SpecIkev2IdPayloadInner),
+    CERT(SpecIkev2CertPayloadInner),
+    CERTREQ(SpecIkev2CertreqPayloadInner),
+    AUTH(SpecIkev2AuthPayloadInner),
+    Nonce(SpecIkev2NoncePayloadInner),
+    Notify(SpecIkev2NotifyPayloadInner),
+    Delete(SpecDeletePayloadBody),
+    VendorID(SpecIkev2VendorIdPayloadInner),
+    TSi(SpecIkev2TsPayloadInner),
+    TSr(SpecIkev2TsPayloadInner),
+    SK(SpecIkev2SkPayloadInner),
+    CP(SpecIkev2CpPayloadInner),
+    EAP(SpecIkev2EapPayloadInner),
+    Unrecognized(Seq<u8>),
+}
+
+pub type SpecIkev2PayloadBodyInner = Either<SpecIkev2SaPayloadInner, Either<SpecIkev2KePayloadInner, Either<SpecIkev2IdPayloadInner, Either<SpecIkev2IdPayloadInner, Either<SpecIkev2CertPayloadInner, Either<SpecIkev2CertreqPayloadInner, Either<SpecIkev2AuthPayloadInner, Either<SpecIkev2NoncePayloadInner, Either<SpecIkev2NotifyPayloadInner, Either<SpecDeletePayloadBody, Either<SpecIkev2VendorIdPayloadInner, Either<SpecIkev2TsPayloadInner, Either<SpecIkev2TsPayloadInner, Either<SpecIkev2SkPayloadInner, Either<SpecIkev2CpPayloadInner, Either<SpecIkev2EapPayloadInner, Seq<u8>>>>>>>>>>>>>>>>>;
+
+impl SpecFrom<SpecIkev2PayloadBody> for SpecIkev2PayloadBodyInner {
+    open spec fn spec_from(m: SpecIkev2PayloadBody) -> SpecIkev2PayloadBodyInner {
+        match m {
+            SpecIkev2PayloadBody::SA(m) => Either::Left(m),
+            SpecIkev2PayloadBody::KE(m) => Either::Right(Either::Left(m)),
+            SpecIkev2PayloadBody::IDi(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecIkev2PayloadBody::IDr(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecIkev2PayloadBody::CERT(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecIkev2PayloadBody::CERTREQ(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            SpecIkev2PayloadBody::AUTH(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            SpecIkev2PayloadBody::Nonce(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
+            SpecIkev2PayloadBody::Notify(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
+            SpecIkev2PayloadBody::Delete(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))),
+            SpecIkev2PayloadBody::VendorID(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))),
+            SpecIkev2PayloadBody::TSi(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))),
+            SpecIkev2PayloadBody::TSr(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))))),
+            SpecIkev2PayloadBody::SK(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))))),
+            SpecIkev2PayloadBody::CP(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))))))),
+            SpecIkev2PayloadBody::EAP(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))))))),
+            SpecIkev2PayloadBody::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))))))))),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecIkev2PayloadBodyInner> for SpecIkev2PayloadBody {
+    open spec fn spec_from(m: SpecIkev2PayloadBodyInner) -> SpecIkev2PayloadBody {
+        match m {
+            Either::Left(m) => SpecIkev2PayloadBody::SA(m),
+            Either::Right(Either::Left(m)) => SpecIkev2PayloadBody::KE(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecIkev2PayloadBody::IDi(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecIkev2PayloadBody::IDr(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecIkev2PayloadBody::CERT(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecIkev2PayloadBody::CERTREQ(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => SpecIkev2PayloadBody::AUTH(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => SpecIkev2PayloadBody::Nonce(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => SpecIkev2PayloadBody::Notify(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))) => SpecIkev2PayloadBody::Delete(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))) => SpecIkev2PayloadBody::VendorID(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))) => SpecIkev2PayloadBody::TSi(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))))) => SpecIkev2PayloadBody::TSr(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))))) => SpecIkev2PayloadBody::SK(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))))))) => SpecIkev2PayloadBody::CP(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))))))) => SpecIkev2PayloadBody::EAP(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))))))))) => SpecIkev2PayloadBody::Unrecognized(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Ikev2PayloadBody<'a> {
+    SA(Ikev2SaPayloadInner<'a>),
+    KE(Ikev2KePayloadInner<'a>),
+    IDi(Ikev2IdPayloadInner<'a>),
+    IDr(Ikev2IdPayloadInner<'a>),
+    CERT(Ikev2CertPayloadInner<'a>),
+    CERTREQ(Ikev2CertreqPayloadInner<'a>),
+    AUTH(Ikev2AuthPayloadInner<'a>),
+    Nonce(Ikev2NoncePayloadInner<'a>),
+    Notify(Ikev2NotifyPayloadInner<'a>),
+    Delete(DeletePayloadBody<'a>),
+    VendorID(Ikev2VendorIdPayloadInner<'a>),
+    TSi(Ikev2TsPayloadInner<'a>),
+    TSr(Ikev2TsPayloadInner<'a>),
+    SK(Ikev2SkPayloadInner<'a>),
+    CP(Ikev2CpPayloadInner<'a>),
+    EAP(Ikev2EapPayloadInner<'a>),
+    Unrecognized(&'a [u8]),
+}
+
+pub type Ikev2PayloadBodyInner<'a> = Either<Ikev2SaPayloadInner<'a>, Either<Ikev2KePayloadInner<'a>, Either<Ikev2IdPayloadInner<'a>, Either<Ikev2IdPayloadInner<'a>, Either<Ikev2CertPayloadInner<'a>, Either<Ikev2CertreqPayloadInner<'a>, Either<Ikev2AuthPayloadInner<'a>, Either<Ikev2NoncePayloadInner<'a>, Either<Ikev2NotifyPayloadInner<'a>, Either<DeletePayloadBody<'a>, Either<Ikev2VendorIdPayloadInner<'a>, Either<Ikev2TsPayloadInner<'a>, Either<Ikev2TsPayloadInner<'a>, Either<Ikev2SkPayloadInner<'a>, Either<Ikev2CpPayloadInner<'a>, Either<Ikev2EapPayloadInner<'a>, &'a [u8]>>>>>>>>>>>>>>>>;
+
+pub type Ikev2PayloadBodyInnerRef<'a> = Either<&'a Ikev2SaPayloadInner<'a>, Either<&'a Ikev2KePayloadInner<'a>, Either<&'a Ikev2IdPayloadInner<'a>, Either<&'a Ikev2IdPayloadInner<'a>, Either<&'a Ikev2CertPayloadInner<'a>, Either<&'a Ikev2CertreqPayloadInner<'a>, Either<&'a Ikev2AuthPayloadInner<'a>, Either<&'a Ikev2NoncePayloadInner<'a>, Either<&'a Ikev2NotifyPayloadInner<'a>, Either<&'a DeletePayloadBody<'a>, Either<&'a Ikev2VendorIdPayloadInner<'a>, Either<&'a Ikev2TsPayloadInner<'a>, Either<&'a Ikev2TsPayloadInner<'a>, Either<&'a Ikev2SkPayloadInner<'a>, Either<&'a Ikev2CpPayloadInner<'a>, Either<&'a Ikev2EapPayloadInner<'a>, &'a &'a [u8]>>>>>>>>>>>>>>>>;
+
+
+impl<'a> View for Ikev2PayloadBody<'a> {
+    type V = SpecIkev2PayloadBody;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            Ikev2PayloadBody::SA(m) => SpecIkev2PayloadBody::SA(m@),
+            Ikev2PayloadBody::KE(m) => SpecIkev2PayloadBody::KE(m@),
+            Ikev2PayloadBody::IDi(m) => SpecIkev2PayloadBody::IDi(m@),
+            Ikev2PayloadBody::IDr(m) => SpecIkev2PayloadBody::IDr(m@),
+            Ikev2PayloadBody::CERT(m) => SpecIkev2PayloadBody::CERT(m@),
+            Ikev2PayloadBody::CERTREQ(m) => SpecIkev2PayloadBody::CERTREQ(m@),
+            Ikev2PayloadBody::AUTH(m) => SpecIkev2PayloadBody::AUTH(m@),
+            Ikev2PayloadBody::Nonce(m) => SpecIkev2PayloadBody::Nonce(m@),
+            Ikev2PayloadBody::Notify(m) => SpecIkev2PayloadBody::Notify(m@),
+            Ikev2PayloadBody::Delete(m) => SpecIkev2PayloadBody::Delete(m@),
+            Ikev2PayloadBody::VendorID(m) => SpecIkev2PayloadBody::VendorID(m@),
+            Ikev2PayloadBody::TSi(m) => SpecIkev2PayloadBody::TSi(m@),
+            Ikev2PayloadBody::TSr(m) => SpecIkev2PayloadBody::TSr(m@),
+            Ikev2PayloadBody::SK(m) => SpecIkev2PayloadBody::SK(m@),
+            Ikev2PayloadBody::CP(m) => SpecIkev2PayloadBody::CP(m@),
+            Ikev2PayloadBody::EAP(m) => SpecIkev2PayloadBody::EAP(m@),
+            Ikev2PayloadBody::Unrecognized(m) => SpecIkev2PayloadBody::Unrecognized(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a Ikev2PayloadBody<'a>> for Ikev2PayloadBodyInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2PayloadBody<'a>) -> Ikev2PayloadBodyInnerRef<'a> {
+        match m {
+            Ikev2PayloadBody::SA(m) => Either::Left(m),
+            Ikev2PayloadBody::KE(m) => Either::Right(Either::Left(m)),
+            Ikev2PayloadBody::IDi(m) => Either::Right(Either::Right(Either::Left(m))),
+            Ikev2PayloadBody::IDr(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            Ikev2PayloadBody::CERT(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            Ikev2PayloadBody::CERTREQ(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            Ikev2PayloadBody::AUTH(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            Ikev2PayloadBody::Nonce(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
+            Ikev2PayloadBody::Notify(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
+            Ikev2PayloadBody::Delete(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))),
+            Ikev2PayloadBody::VendorID(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))),
+            Ikev2PayloadBody::TSi(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))),
+            Ikev2PayloadBody::TSr(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))))),
+            Ikev2PayloadBody::SK(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))))),
+            Ikev2PayloadBody::CP(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))))))),
+            Ikev2PayloadBody::EAP(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))))))),
+            Ikev2PayloadBody::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))))))))),
+        }
+    }
+
+}
+
+impl<'a> From<Ikev2PayloadBodyInner<'a>> for Ikev2PayloadBody<'a> {
+    fn ex_from(m: Ikev2PayloadBodyInner<'a>) -> Ikev2PayloadBody<'a> {
+        match m {
+            Either::Left(m) => Ikev2PayloadBody::SA(m),
+            Either::Right(Either::Left(m)) => Ikev2PayloadBody::KE(m),
+            Either::Right(Either::Right(Either::Left(m))) => Ikev2PayloadBody::IDi(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => Ikev2PayloadBody::IDr(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => Ikev2PayloadBody::CERT(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => Ikev2PayloadBody::CERTREQ(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => Ikev2PayloadBody::AUTH(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => Ikev2PayloadBody::Nonce(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => Ikev2PayloadBody::Notify(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))) => Ikev2PayloadBody::Delete(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))) => Ikev2PayloadBody::VendorID(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))) => Ikev2PayloadBody::TSi(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))))) => Ikev2PayloadBody::TSr(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))))) => Ikev2PayloadBody::SK(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))))))))) => Ikev2PayloadBody::CP(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))))))))) => Ikev2PayloadBody::EAP(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))))))))) => Ikev2PayloadBody::Unrecognized(m),
+        }
+    }
+    
+}
+
+
+pub struct Ikev2PayloadBodyMapper;
+impl View for Ikev2PayloadBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2PayloadBodyMapper {
+    type Src = SpecIkev2PayloadBodyInner;
+    type Dst = SpecIkev2PayloadBody;
+}
+impl SpecIsoProof for Ikev2PayloadBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2PayloadBodyMapper {
+    type Src = Ikev2PayloadBodyInner<'a>;
+    type Dst = Ikev2PayloadBody<'a>;
+    type RefSrc = Ikev2PayloadBodyInnerRef<'a>;
+}
+
+type SpecIkev2PayloadBodyCombinatorAlias1 = Choice<Cond<SpecIkev2EapPayloadInnerCombinator>, Cond<bytes::Tail>>;
+type SpecIkev2PayloadBodyCombinatorAlias2 = Choice<Cond<SpecIkev2CpPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias1>;
+type SpecIkev2PayloadBodyCombinatorAlias3 = Choice<Cond<SpecIkev2SkPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias2>;
+type SpecIkev2PayloadBodyCombinatorAlias4 = Choice<Cond<SpecIkev2TsPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias3>;
+type SpecIkev2PayloadBodyCombinatorAlias5 = Choice<Cond<SpecIkev2TsPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias4>;
+type SpecIkev2PayloadBodyCombinatorAlias6 = Choice<Cond<SpecIkev2VendorIdPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias5>;
+type SpecIkev2PayloadBodyCombinatorAlias7 = Choice<Cond<SpecDeletePayloadBodyCombinator>, SpecIkev2PayloadBodyCombinatorAlias6>;
+type SpecIkev2PayloadBodyCombinatorAlias8 = Choice<Cond<SpecIkev2NotifyPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias7>;
+type SpecIkev2PayloadBodyCombinatorAlias9 = Choice<Cond<SpecIkev2NoncePayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias8>;
+type SpecIkev2PayloadBodyCombinatorAlias10 = Choice<Cond<SpecIkev2AuthPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias9>;
+type SpecIkev2PayloadBodyCombinatorAlias11 = Choice<Cond<SpecIkev2CertreqPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias10>;
+type SpecIkev2PayloadBodyCombinatorAlias12 = Choice<Cond<SpecIkev2CertPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias11>;
+type SpecIkev2PayloadBodyCombinatorAlias13 = Choice<Cond<SpecIkev2IdPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias12>;
+type SpecIkev2PayloadBodyCombinatorAlias14 = Choice<Cond<SpecIkev2IdPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias13>;
+type SpecIkev2PayloadBodyCombinatorAlias15 = Choice<Cond<SpecIkev2KePayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias14>;
+type SpecIkev2PayloadBodyCombinatorAlias16 = Choice<Cond<SpecIkev2SaPayloadInnerCombinator>, SpecIkev2PayloadBodyCombinatorAlias15>;
+pub struct SpecIkev2PayloadBodyCombinator(pub SpecIkev2PayloadBodyCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2PayloadBodyCombinator {
+    type Type = SpecIkev2PayloadBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2PayloadBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2PayloadBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2PayloadBodyCombinatorAlias = Mapped<SpecIkev2PayloadBodyCombinatorAlias16, Ikev2PayloadBodyMapper>;
+type Ikev2PayloadBodyCombinatorAlias1 = Choice<Cond<Ikev2EapPayloadInnerCombinator>, Cond<bytes::Tail>>;
+type Ikev2PayloadBodyCombinatorAlias2 = Choice<Cond<Ikev2CpPayloadInnerCombinator>, Ikev2PayloadBodyCombinator1>;
+type Ikev2PayloadBodyCombinatorAlias3 = Choice<Cond<Ikev2SkPayloadInnerCombinator>, Ikev2PayloadBodyCombinator2>;
+type Ikev2PayloadBodyCombinatorAlias4 = Choice<Cond<Ikev2TsPayloadInnerCombinator>, Ikev2PayloadBodyCombinator3>;
+type Ikev2PayloadBodyCombinatorAlias5 = Choice<Cond<Ikev2TsPayloadInnerCombinator>, Ikev2PayloadBodyCombinator4>;
+type Ikev2PayloadBodyCombinatorAlias6 = Choice<Cond<Ikev2VendorIdPayloadInnerCombinator>, Ikev2PayloadBodyCombinator5>;
+type Ikev2PayloadBodyCombinatorAlias7 = Choice<Cond<DeletePayloadBodyCombinator>, Ikev2PayloadBodyCombinator6>;
+type Ikev2PayloadBodyCombinatorAlias8 = Choice<Cond<Ikev2NotifyPayloadInnerCombinator>, Ikev2PayloadBodyCombinator7>;
+type Ikev2PayloadBodyCombinatorAlias9 = Choice<Cond<Ikev2NoncePayloadInnerCombinator>, Ikev2PayloadBodyCombinator8>;
+type Ikev2PayloadBodyCombinatorAlias10 = Choice<Cond<Ikev2AuthPayloadInnerCombinator>, Ikev2PayloadBodyCombinator9>;
+type Ikev2PayloadBodyCombinatorAlias11 = Choice<Cond<Ikev2CertreqPayloadInnerCombinator>, Ikev2PayloadBodyCombinator10>;
+type Ikev2PayloadBodyCombinatorAlias12 = Choice<Cond<Ikev2CertPayloadInnerCombinator>, Ikev2PayloadBodyCombinator11>;
+type Ikev2PayloadBodyCombinatorAlias13 = Choice<Cond<Ikev2IdPayloadInnerCombinator>, Ikev2PayloadBodyCombinator12>;
+type Ikev2PayloadBodyCombinatorAlias14 = Choice<Cond<Ikev2IdPayloadInnerCombinator>, Ikev2PayloadBodyCombinator13>;
+type Ikev2PayloadBodyCombinatorAlias15 = Choice<Cond<Ikev2KePayloadInnerCombinator>, Ikev2PayloadBodyCombinator14>;
+type Ikev2PayloadBodyCombinatorAlias16 = Choice<Cond<Ikev2SaPayloadInnerCombinator>, Ikev2PayloadBodyCombinator15>;
+pub struct Ikev2PayloadBodyCombinator1(pub Ikev2PayloadBodyCombinatorAlias1);
+impl View for Ikev2PayloadBodyCombinator1 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator1, Ikev2PayloadBodyCombinatorAlias1);
+
+pub struct Ikev2PayloadBodyCombinator2(pub Ikev2PayloadBodyCombinatorAlias2);
+impl View for Ikev2PayloadBodyCombinator2 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator2, Ikev2PayloadBodyCombinatorAlias2);
+
+pub struct Ikev2PayloadBodyCombinator3(pub Ikev2PayloadBodyCombinatorAlias3);
+impl View for Ikev2PayloadBodyCombinator3 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator3, Ikev2PayloadBodyCombinatorAlias3);
+
+pub struct Ikev2PayloadBodyCombinator4(pub Ikev2PayloadBodyCombinatorAlias4);
+impl View for Ikev2PayloadBodyCombinator4 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator4, Ikev2PayloadBodyCombinatorAlias4);
+
+pub struct Ikev2PayloadBodyCombinator5(pub Ikev2PayloadBodyCombinatorAlias5);
+impl View for Ikev2PayloadBodyCombinator5 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator5, Ikev2PayloadBodyCombinatorAlias5);
+
+pub struct Ikev2PayloadBodyCombinator6(pub Ikev2PayloadBodyCombinatorAlias6);
+impl View for Ikev2PayloadBodyCombinator6 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator6, Ikev2PayloadBodyCombinatorAlias6);
+
+pub struct Ikev2PayloadBodyCombinator7(pub Ikev2PayloadBodyCombinatorAlias7);
+impl View for Ikev2PayloadBodyCombinator7 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias7;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator7, Ikev2PayloadBodyCombinatorAlias7);
+
+pub struct Ikev2PayloadBodyCombinator8(pub Ikev2PayloadBodyCombinatorAlias8);
+impl View for Ikev2PayloadBodyCombinator8 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias8;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator8, Ikev2PayloadBodyCombinatorAlias8);
+
+pub struct Ikev2PayloadBodyCombinator9(pub Ikev2PayloadBodyCombinatorAlias9);
+impl View for Ikev2PayloadBodyCombinator9 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias9;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator9, Ikev2PayloadBodyCombinatorAlias9);
+
+pub struct Ikev2PayloadBodyCombinator10(pub Ikev2PayloadBodyCombinatorAlias10);
+impl View for Ikev2PayloadBodyCombinator10 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias10;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator10, Ikev2PayloadBodyCombinatorAlias10);
+
+pub struct Ikev2PayloadBodyCombinator11(pub Ikev2PayloadBodyCombinatorAlias11);
+impl View for Ikev2PayloadBodyCombinator11 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias11;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator11, Ikev2PayloadBodyCombinatorAlias11);
+
+pub struct Ikev2PayloadBodyCombinator12(pub Ikev2PayloadBodyCombinatorAlias12);
+impl View for Ikev2PayloadBodyCombinator12 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias12;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator12, Ikev2PayloadBodyCombinatorAlias12);
+
+pub struct Ikev2PayloadBodyCombinator13(pub Ikev2PayloadBodyCombinatorAlias13);
+impl View for Ikev2PayloadBodyCombinator13 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias13;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator13, Ikev2PayloadBodyCombinatorAlias13);
+
+pub struct Ikev2PayloadBodyCombinator14(pub Ikev2PayloadBodyCombinatorAlias14);
+impl View for Ikev2PayloadBodyCombinator14 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias14;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator14, Ikev2PayloadBodyCombinatorAlias14);
+
+pub struct Ikev2PayloadBodyCombinator15(pub Ikev2PayloadBodyCombinatorAlias15);
+impl View for Ikev2PayloadBodyCombinator15 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias15;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator15, Ikev2PayloadBodyCombinatorAlias15);
+
+pub struct Ikev2PayloadBodyCombinator16(pub Ikev2PayloadBodyCombinatorAlias16);
+impl View for Ikev2PayloadBodyCombinator16 {
+    type V = SpecIkev2PayloadBodyCombinatorAlias16;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(Ikev2PayloadBodyCombinator16, Ikev2PayloadBodyCombinatorAlias16);
+
+pub struct Ikev2PayloadBodyCombinator(pub Ikev2PayloadBodyCombinatorAlias);
+
+impl View for Ikev2PayloadBodyCombinator {
+    type V = SpecIkev2PayloadBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2PayloadBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2PayloadBodyCombinator {
+    type Type = Ikev2PayloadBody<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2PayloadBodyCombinatorAlias = Mapped<Ikev2PayloadBodyCombinator16, Ikev2PayloadBodyMapper>;
+
+
+pub open spec fn spec_ikev2_payload_body(next_pt: u8) -> SpecIkev2PayloadBodyCombinator {
+    SpecIkev2PayloadBodyCombinator(Mapped { inner: Choice(Cond { cond: next_pt == NextPayloadType::SPEC_SA, inner: spec_ikev2_sa_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_KE, inner: spec_ikev2_ke_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_IDi, inner: spec_ikev2_id_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_IDr, inner: spec_ikev2_id_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_CERT, inner: spec_ikev2_cert_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_CERTREQ, inner: spec_ikev2_certreq_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_AUTH, inner: spec_ikev2_auth_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_Nonce, inner: spec_ikev2_nonce_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_Notify, inner: spec_ikev2_notify_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_Delete, inner: spec_delete_payload_body() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_VendorID, inner: spec_ikev2_vendor_id_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_TSi, inner: spec_ikev2_ts_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_TSr, inner: spec_ikev2_ts_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_SK, inner: spec_ikev2_sk_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_CP, inner: spec_ikev2_cp_payload_inner() }, Choice(Cond { cond: next_pt == NextPayloadType::SPEC_EAP, inner: spec_ikev2_eap_payload_inner() }, Cond { cond: !(next_pt == NextPayloadType::SPEC_SA || next_pt == NextPayloadType::SPEC_KE || next_pt == NextPayloadType::SPEC_IDi || next_pt == NextPayloadType::SPEC_IDr || next_pt == NextPayloadType::SPEC_CERT || next_pt == NextPayloadType::SPEC_CERTREQ || next_pt == NextPayloadType::SPEC_AUTH || next_pt == NextPayloadType::SPEC_Nonce || next_pt == NextPayloadType::SPEC_Notify || next_pt == NextPayloadType::SPEC_Delete || next_pt == NextPayloadType::SPEC_VendorID || next_pt == NextPayloadType::SPEC_TSi || next_pt == NextPayloadType::SPEC_TSr || next_pt == NextPayloadType::SPEC_SK || next_pt == NextPayloadType::SPEC_CP || next_pt == NextPayloadType::SPEC_EAP), inner: bytes::Tail })))))))))))))))), mapper: Ikev2PayloadBodyMapper })
+}
+
+pub fn ikev2_payload_body<'a>(next_pt: u8) -> (o: Ikev2PayloadBodyCombinator)
+    requires
+        spec_next_payload_type().wf(next_pt@),
+
+    ensures o@ == spec_ikev2_payload_body(next_pt@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2PayloadBodyCombinator(Mapped { inner: Ikev2PayloadBodyCombinator16(Choice::new(Cond { cond: next_pt == NextPayloadType::SA, inner: ikev2_sa_payload_inner() }, Ikev2PayloadBodyCombinator15(Choice::new(Cond { cond: next_pt == NextPayloadType::KE, inner: ikev2_ke_payload_inner() }, Ikev2PayloadBodyCombinator14(Choice::new(Cond { cond: next_pt == NextPayloadType::IDi, inner: ikev2_id_payload_inner() }, Ikev2PayloadBodyCombinator13(Choice::new(Cond { cond: next_pt == NextPayloadType::IDr, inner: ikev2_id_payload_inner() }, Ikev2PayloadBodyCombinator12(Choice::new(Cond { cond: next_pt == NextPayloadType::CERT, inner: ikev2_cert_payload_inner() }, Ikev2PayloadBodyCombinator11(Choice::new(Cond { cond: next_pt == NextPayloadType::CERTREQ, inner: ikev2_certreq_payload_inner() }, Ikev2PayloadBodyCombinator10(Choice::new(Cond { cond: next_pt == NextPayloadType::AUTH, inner: ikev2_auth_payload_inner() }, Ikev2PayloadBodyCombinator9(Choice::new(Cond { cond: next_pt == NextPayloadType::Nonce, inner: ikev2_nonce_payload_inner() }, Ikev2PayloadBodyCombinator8(Choice::new(Cond { cond: next_pt == NextPayloadType::Notify, inner: ikev2_notify_payload_inner() }, Ikev2PayloadBodyCombinator7(Choice::new(Cond { cond: next_pt == NextPayloadType::Delete, inner: delete_payload_body() }, Ikev2PayloadBodyCombinator6(Choice::new(Cond { cond: next_pt == NextPayloadType::VendorID, inner: ikev2_vendor_id_payload_inner() }, Ikev2PayloadBodyCombinator5(Choice::new(Cond { cond: next_pt == NextPayloadType::TSi, inner: ikev2_ts_payload_inner() }, Ikev2PayloadBodyCombinator4(Choice::new(Cond { cond: next_pt == NextPayloadType::TSr, inner: ikev2_ts_payload_inner() }, Ikev2PayloadBodyCombinator3(Choice::new(Cond { cond: next_pt == NextPayloadType::SK, inner: ikev2_sk_payload_inner() }, Ikev2PayloadBodyCombinator2(Choice::new(Cond { cond: next_pt == NextPayloadType::CP, inner: ikev2_cp_payload_inner() }, Ikev2PayloadBodyCombinator1(Choice::new(Cond { cond: next_pt == NextPayloadType::EAP, inner: ikev2_eap_payload_inner() }, Cond { cond: !(next_pt == NextPayloadType::SA || next_pt == NextPayloadType::KE || next_pt == NextPayloadType::IDi || next_pt == NextPayloadType::IDr || next_pt == NextPayloadType::CERT || next_pt == NextPayloadType::CERTREQ || next_pt == NextPayloadType::AUTH || next_pt == NextPayloadType::Nonce || next_pt == NextPayloadType::Notify || next_pt == NextPayloadType::Delete || next_pt == NextPayloadType::VendorID || next_pt == NextPayloadType::TSi || next_pt == NextPayloadType::TSr || next_pt == NextPayloadType::SK || next_pt == NextPayloadType::CP || next_pt == NextPayloadType::EAP), inner: bytes::Tail })))))))))))))))))))))))))))))))), mapper: Ikev2PayloadBodyMapper });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_payload_body(next_pt@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_payload_body<'a>(input: &'a [u8], next_pt: u8) -> (res: PResult<<Ikev2PayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_next_payload_type().wf(next_pt@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_payload_body(next_pt@).spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_payload_body(next_pt@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_payload_body(next_pt@).spec_parse(input@) is None,
+        spec_ikev2_payload_body(next_pt@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_payload_body( next_pt );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_payload_body<'a>(v: <Ikev2PayloadBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, next_pt: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_payload_body(next_pt@).wf(v@),
+        spec_next_payload_type().wf(next_pt@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_ikev2_payload_body(next_pt@).spec_serialize(v@).len() <= usize::MAX,
+        spec_next_payload_type().wf(next_pt@),
+
+    ensures
+        serialize_len == spec_ikev2_payload_body(next_pt@).spec_serialize(v@).len(),
+{
+    let combinator = ikev2_payload_body( next_pt );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecIkev2Payload {
+    pub hdr: SpecGenericPayloadHeader,
+    pub body: SpecIkev2PayloadBody,
+}
+
+pub type SpecIkev2PayloadInner = (SpecGenericPayloadHeader, SpecIkev2PayloadBody);
+
+
+impl SpecFrom<SpecIkev2Payload> for SpecIkev2PayloadInner {
+    open spec fn spec_from(m: SpecIkev2Payload) -> SpecIkev2PayloadInner {
+        (m.hdr, m.body)
+    }
+}
+
+impl SpecFrom<SpecIkev2PayloadInner> for SpecIkev2Payload {
+    open spec fn spec_from(m: SpecIkev2PayloadInner) -> SpecIkev2Payload {
+        let (hdr, body) = m;
+        SpecIkev2Payload { hdr, body }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Ikev2Payload<'a> {
+    pub hdr: GenericPayloadHeader,
+    pub body: Ikev2PayloadBody<'a>,
+}
+
+impl View for Ikev2Payload<'_> {
+    type V = SpecIkev2Payload;
+
+    open spec fn view(&self) -> Self::V {
+        SpecIkev2Payload {
+            hdr: self.hdr@,
+            body: self.body@,
+        }
+    }
+}
+pub type Ikev2PayloadInner<'a> = (GenericPayloadHeader, Ikev2PayloadBody<'a>);
+
+pub type Ikev2PayloadInnerRef<'a> = (&'a GenericPayloadHeader, &'a Ikev2PayloadBody<'a>);
+impl<'a> From<&'a Ikev2Payload<'a>> for Ikev2PayloadInnerRef<'a> {
+    fn ex_from(m: &'a Ikev2Payload) -> Ikev2PayloadInnerRef<'a> {
+        (&m.hdr, &m.body)
+    }
+}
+
+impl<'a> From<Ikev2PayloadInner<'a>> for Ikev2Payload<'a> {
+    fn ex_from(m: Ikev2PayloadInner) -> Ikev2Payload {
+        let (hdr, body) = m;
+        Ikev2Payload { hdr, body }
+    }
+}
+
+pub struct Ikev2PayloadMapper;
+impl View for Ikev2PayloadMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for Ikev2PayloadMapper {
+    type Src = SpecIkev2PayloadInner;
+    type Dst = SpecIkev2Payload;
+}
+impl SpecIsoProof for Ikev2PayloadMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for Ikev2PayloadMapper {
+    type Src = Ikev2PayloadInner<'a>;
+    type Dst = Ikev2Payload<'a>;
+    type RefSrc = Ikev2PayloadInnerRef<'a>;
+}
+
+pub struct SpecIkev2PayloadCombinator(pub SpecIkev2PayloadCombinatorAlias);
+
+impl SpecCombinator for SpecIkev2PayloadCombinator {
+    type Type = SpecIkev2Payload;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecIkev2PayloadCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecIkev2PayloadCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecIkev2PayloadCombinatorAlias = Mapped<SpecPair<SpecGenericPayloadHeaderCombinator, AndThen<bytes::Variable, SpecIkev2PayloadBodyCombinator>>, Ikev2PayloadMapper>;
+
+pub struct Ikev2PayloadCombinator(pub Ikev2PayloadCombinatorAlias);
+
+impl View for Ikev2PayloadCombinator {
+    type V = SpecIkev2PayloadCombinator;
+    open spec fn view(&self) -> Self::V { SpecIkev2PayloadCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Ikev2PayloadCombinator {
+    type Type = Ikev2Payload<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type Ikev2PayloadCombinatorAlias = Mapped<Pair<GenericPayloadHeaderCombinator, AndThen<bytes::Variable, Ikev2PayloadBodyCombinator>, Ikev2PayloadCont0>, Ikev2PayloadMapper>;
+
+
+pub open spec fn spec_ikev2_payload(next_pt: u8) -> SpecIkev2PayloadCombinator {
+    SpecIkev2PayloadCombinator(
+    Mapped {
+        inner: Pair::spec_new(spec_generic_payload_header(), |deps| spec_ikev2_payload_cont0(next_pt, deps)),
+        mapper: Ikev2PayloadMapper,
+    })
+}
+
+pub open spec fn spec_ikev2_payload_cont0(next_pt: u8, deps: SpecGenericPayloadHeader) -> AndThen<bytes::Variable, SpecIkev2PayloadBodyCombinator> {
+    let hdr = deps;
+    AndThen(bytes::Variable(((usize::spec_from(hdr.payload_length) - 4)) as usize), spec_ikev2_payload_body(next_pt))
+}
+
+impl View for Ikev2PayloadCont0 {
+    type V = spec_fn(SpecGenericPayloadHeader) -> AndThen<bytes::Variable, SpecIkev2PayloadBodyCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: SpecGenericPayloadHeader| {
+            spec_ikev2_payload_cont0(self.next_pt@, deps)
+        }
+    }
+}
+
+pub fn ikev2_payload<'a>(next_pt: u8) -> (o: Ikev2PayloadCombinator)
+    requires
+        spec_next_payload_type().wf(next_pt@),
+
+    ensures o@ == spec_ikev2_payload(next_pt@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Ikev2PayloadCombinator(
+    Mapped {
+        inner: Pair::new(generic_payload_header(), Ikev2PayloadCont0 { next_pt }),
+        mapper: Ikev2PayloadMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_ikev2_payload(next_pt@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_ikev2_payload<'a>(input: &'a [u8], next_pt: u8) -> (res: PResult<<Ikev2PayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_next_payload_type().wf(next_pt@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_ikev2_payload(next_pt@).spec_parse(input@) == Some((n as int, v@)),
+        spec_ikev2_payload(next_pt@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ikev2_payload(next_pt@).spec_parse(input@) is None,
+        spec_ikev2_payload(next_pt@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ikev2_payload( next_pt );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_ikev2_payload<'a>(v: <Ikev2PayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, next_pt: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ikev2_payload(next_pt@).wf(v@),
+        spec_next_payload_type().wf(next_pt@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_ikev2_payload(next_pt@).spec_serialize(v@).len() <= usize::MAX,
+        spec_next_payload_type().wf(next_pt@),
+
+    ensures
+        serialize_len == spec_ikev2_payload(next_pt@).spec_serialize(v@).len(),
+{
+    let combinator = ikev2_payload( next_pt );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct Ikev2PayloadCont0 {
+    pub next_pt: u8,
+}
+type Ikev2PayloadCont0Type<'a, 'b> = &'b GenericPayloadHeader;
+type Ikev2PayloadCont0SType<'a, 'x> = &'x GenericPayloadHeader;
+type Ikev2PayloadCont0Input<'a, 'b, 'x> = POrSType<Ikev2PayloadCont0Type<'a, 'b>, Ikev2PayloadCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Ikev2PayloadCont0Input<'a, 'b, 'x>> for Ikev2PayloadCont0 {
+    type Output = AndThen<bytes::Variable, Ikev2PayloadBodyCombinator>;
+
+    open spec fn requires(&self, deps: Ikev2PayloadCont0Input<'a, 'b, 'x>) -> bool {        let next_pt = self.next_pt@;
+
+        &&& spec_next_payload_type().wf(self.next_pt@)
+        &&& (spec_generic_payload_header()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: Ikev2PayloadCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_ikev2_payload_cont0(self.next_pt@, deps@)
+    }
+
+    fn apply(&self, deps: Ikev2PayloadCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let hdr = deps;
+                let next_pt = self.next_pt;
+                AndThen(bytes::Variable(((usize::ex_from(hdr.payload_length) - 4)) as usize), ikev2_payload_body(next_pt))
+            }
+            POrSType::S(deps) => {
+                let hdr = deps;
+                let next_pt = self.next_pt;
+                AndThen(bytes::Variable(((usize::ex_from(hdr.payload_length) - 4)) as usize), ikev2_payload_body(next_pt))
+            }
+        }
+    }
+}
+
+}
diff --git a/vest-dsl/test/src/ikev2.vest b/vest-dsl/test/src/ikev2.vest
new file mode 100644
index 00000000..f872b111
--- /dev/null
+++ b/vest-dsl/test/src/ikev2.vest
@@ -0,0 +1,1022 @@
+!BIG_ENDIAN
+
+// =============================================================================
+// IKEv2 Binary Format Specification [RFC 5996](https://datatracker.ietf.org/doc/html/rfc5996)
+//
+// Authored by Claude Sonnet 4.6
+//
+// =============================================================================
+//
+// KNOWN LIMITATIONS / RESOLVED FEATURES:
+//
+// [L1] LENGTH OFFSET ARITHMETIC — RESOLVED
+//      IKEv2 length fields measure the *total* structure size including the
+//      header.  The actual payload body is `total_length - header_size`.
+//      Vest now supports arithmetic on dependent fields:
+//      e.g.  [u8; @payload_length - 4]
+//
+// [L2] BIT-PACKED FIELDS
+//      Vest still does not expose bit-slice access on dependent values, but
+//      RFC-mandated fixed bit patterns can still be expressed either as closed
+//      enums over the whole byte or by integer refinements over the whole word.
+//
+// [L3] REPEATED SUBSTRUCTURES — RESOLVED
+//      Both count-bounded `[item; @count]` and length-bounded
+//      `[u8; @len] >>= Vec<item>` repetitions are available, so IKEv2 proposal
+//      lists, transform lists, traffic selectors, and config attributes can be
+//      modeled directly.
+//
+// [L4] ARITHMETIC ON MULTIPLE DEPENDENT FIELDS — RESOLVED
+//      Some body lengths depend on more than one previously-parsed field,
+//      e.g. notification_data = payload_length - 8 - spi_size.  Vest now
+//      supports multi-variable arithmetic expressions:
+//      e.g.  [u8; @payload_length - 8 - @spi_size]
+//            [u8; @num_spis * @spi_size]
+//
+// [L5] FIELD ACCESS ON NESTED STRUCTS — RESOLVED
+//      When a preceding field is itself a struct (e.g. the generic payload
+//      header), one can use @hdr.payload_length to drive a later length.
+//      Vest now supports dotted-field access on dependent bindings.
+//
+// =============================================================================
+
+
+// =============================================================================
+// §3.1  Exchange-type and payload-type enumerations
+// =============================================================================
+
+exchange_type = enum {
+    IKE_SA_INIT     = 34,
+    IKE_AUTH        = 35,
+    CREATE_CHILD_SA = 36,
+    INFORMATIONAL   = 37,
+    ...
+}
+
+// Next-payload type codes (§3.2 table)
+next_payload_type = enum {
+    NoNextPayload = 0,
+    SA            = 33,
+    KE            = 34,
+    IDi           = 35,
+    IDr           = 36,
+    CERT          = 37,
+    CERTREQ       = 38,
+    AUTH          = 39,
+    Nonce         = 40,
+    Notify        = 41,
+    Delete        = 42,
+    VendorID      = 43,
+    TSi           = 44,
+    TSr           = 45,
+    SK            = 46,
+    CP            = 47,
+    EAP           = 48,
+    ...
+}
+
+// IPsec protocol identifiers used in proposals, notify, and delete payloads
+ike_protocol_id = enum {
+    IKE = 1,
+    AH  = 2,
+    ESP = 3,
+    ...
+}
+
+// Transform types (§3.3.2)
+transform_type = enum {
+    ENCR  = 1,
+    PRF   = 2,
+    INTEG = 3,
+    DH    = 4,
+    ESN   = 5,
+    ...
+}
+
+// Encryption algorithm (Transform Type 1) IDs
+encr_id = enum {
+    ENCR_DES_IV64 = 1u16,
+    ENCR_DES      = 2,
+    ENCR_3DES     = 3,
+    ENCR_RC5      = 4,
+    ENCR_IDEA     = 5,
+    ENCR_CAST     = 6,
+    ENCR_BLOWFISH = 7,
+    ENCR_3IDEA    = 8,
+    ENCR_DES_IV32 = 9,
+    ENCR_NULL     = 11,
+    ENCR_AES_CBC  = 12,
+    ENCR_AES_CTR  = 13,
+    ...
+}
+
+// PRF algorithm (Transform Type 2) IDs
+prf_id = enum {
+    PRF_HMAC_MD5   = 1u16,
+    PRF_HMAC_SHA1  = 2,
+    PRF_HMAC_TIGER = 3,
+    ...
+}
+
+// Integrity algorithm (Transform Type 3) IDs
+integ_id = enum {
+    INTEG_NONE           = 0u16,
+    AUTH_HMAC_MD5_96     = 1,
+    AUTH_HMAC_SHA1_96    = 2,
+    AUTH_DES_MAC         = 3,
+    AUTH_KPDK_MD5        = 4,
+    AUTH_AES_XCBC_96     = 5,
+    ...
+}
+
+// Diffie-Hellman group (Transform Type 4) IDs
+dh_id = enum {
+    DH_NONE      = 0u16,
+    MODP_768     = 1,
+    MODP_1024    = 2,
+    MODP_1536    = 5,
+    MODP_2048    = 14,
+    MODP_3072    = 15,
+    MODP_4096    = 16,
+    MODP_6144    = 17,
+    MODP_8192    = 18,
+    ...
+}
+
+// Extended Sequence Numbers (Transform Type 5) IDs
+esn_id = enum {
+    NoESN = 0u16,
+    ESN   = 1,
+    ...
+}
+
+// Identification payload ID types (§3.5)
+id_type = enum {
+    ID_IPV4_ADDR    = 1,
+    ID_FQDN         = 2,
+    ID_RFC822_ADDR  = 3,
+    ID_IPV6_ADDR    = 5,
+    ID_DER_ASN1_DN  = 9,
+    ID_DER_ASN1_GN  = 10,
+    ID_KEY_ID       = 11,
+    ...
+}
+
+// Certificate encoding types (§3.6)
+cert_encoding = enum {
+    PKCS7WrappedX509  = 1,
+    PGPCert           = 2,
+    DNSSignedKey      = 3,
+    X509CertSig       = 4,
+    KerberosToken     = 6,
+    CRL               = 7,
+    ARL               = 8,
+    SPKICert          = 9,
+    X509CertAttr      = 10,
+    RawRSAKey         = 11,
+    HashAndURLX509    = 12,
+    HashAndURLBundle  = 13,
+    ...
+}
+
+// Authentication methods (§3.8)
+auth_method = enum {
+    RSADigitalSignature  = 1,
+    SharedKeyMIC         = 2,
+    DSSDigitalSignature  = 3,
+    ...
+}
+
+// Notify message types (§3.10.1)
+// Error types: 0–16383; Status types: 16384–
+notify_msg_type = enum {
+    UNSUPPORTED_CRITICAL_PAYLOAD  = 1u16,
+    INVALID_IKE_SPI               = 4,
+    INVALID_MAJOR_VERSION         = 5,
+    INVALID_SYNTAX                = 7,
+    INVALID_MESSAGE_ID            = 9,
+    INVALID_SPI                   = 11,
+    NO_PROPOSAL_CHOSEN            = 14,
+    INVALID_KE_PAYLOAD            = 17,
+    AUTHENTICATION_FAILED         = 24,
+    SINGLE_PAIR_REQUIRED          = 34,
+    NO_ADDITIONAL_SAS             = 35,
+    INTERNAL_ADDRESS_FAILURE      = 36,
+    FAILED_CP_REQUIRED            = 37,
+    TS_UNACCEPTABLE               = 38,
+    INVALID_SELECTORS             = 39,
+    TEMPORARY_FAILURE             = 43,
+    CHILD_SA_NOT_FOUND            = 44,
+    INITIAL_CONTACT               = 16384,
+    SET_WINDOW_SIZE               = 16385,
+    ADDITIONAL_TS_POSSIBLE        = 16386,
+    IPCOMP_SUPPORTED              = 16387,
+    NAT_DETECTION_SOURCE_IP       = 16388,
+    NAT_DETECTION_DESTINATION_IP  = 16389,
+    COOKIE                        = 16390,
+    USE_TRANSPORT_MODE            = 16391,
+    HTTP_CERT_LOOKUP_SUPPORTED    = 16392,
+    REKEY_SA                      = 16393,
+    ESP_TFC_PADDING_NOT_SUPPORTED = 16394,
+    NON_FIRST_FRAGMENTS_ALSO      = 16395,
+    ...
+}
+
+// Configuration payload CFG types (§3.15)
+cfg_type = enum {
+    CFG_REQUEST = 1,
+    CFG_REPLY   = 2,
+    CFG_SET     = 3,
+    CFG_ACK     = 4,
+    ...
+}
+
+// Traffic Selector types (§3.13.1)
+ts_type = enum {
+    TS_IPV4_ADDR_RANGE = 7,
+    TS_IPV6_ADDR_RANGE = 8,
+    ...
+}
+
+// RFC 5996 §3.1: Major version MUST be 2; receivers ignore the minor version.
+ike_version_byte = u8 | {0x20..0x2f}
+
+// RFC 5996 §3.1: V and X bits MUST be clear when sending.
+ike_flags = enum {
+    ResponderRequest = 0x00u8,
+    InitiatorRequest = 0x08,
+    ResponderResponse = 0x20,
+    InitiatorResponse = 0x28,
+}
+
+// RFC 5996 §3.2: bit 7 is Critical, bits 6..0 are RESERVED and must be zero.
+payload_critical = enum {
+    NonCritical = 0x00u8,
+    Critical = 0x80,
+}
+
+// Notify uses Protocol ID 0 when no SPI is present, otherwise AH(2) or ESP(3).
+notify_protocol_id = enum {
+    NotifyNoSpi = 0u8,
+    NotifyAH = 2,
+    NotifyESP = 3,
+}
+
+// RFC 5996 §3.15.1: the high bit is reserved and must be zero.
+cfg_attr_type_word = u16 | {0..0x7fff}
+
+// SPI sizes used in RFC 5996 payloads.
+proposal_spi_size_byte = u8 | {0, 4, 8}
+ipsec_spi_size_or_none = u8 | {0, 4}
+
+transform_id_value(@kind: transform_type) = choose(@kind) {
+    ENCR => encr_id,
+    PRF => prf_id,
+    INTEG => integ_id,
+    DH => dh_id,
+    ESN => esn_id,
+    _ => u16,
+}
+
+// =============================================================================
+// §3.1  IKE Header
+//
+// Wire layout (28 bytes fixed):
+//   0                   1                   2                   3
+//   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//  |                    IKE SA Initiator's SPI                     |
+//  |                                                               |
+//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//  |                    IKE SA Responder's SPI                     |
+//  |                                                               |
+//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//  |  Next Payload | MjVer | MnVer | Exchange Type |     Flags     |
+//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//  |                          Message ID                           |
+//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//  |                            Length                             |
+//  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// [L1] `length` = total bytes of entire IKE message (header + all payloads).
+//      The payload region is therefore `length - |ike_header|` bytes.
+//
+// [L2] `version` packs MajVer (bits 7-4) and MinVer (bits 3-0) into one byte.
+//      `flags` packs R (bit 5), V (bit 4), I (bit 3) plus three reserved bits.
+//      We constrain the full octet to the RFC-allowed sender-side values.
+// =============================================================================
+
+ike_header = {
+    initiator_spi: [u8; 8],
+    responder_spi: [u8; 8],
+    next_payload:  next_payload_type,
+    version:       ike_version_byte,
+    exchange_type: exchange_type,
+    flags:         ike_flags,
+    message_id:    u32,
+    @length:       u32 | {28..0xffffffff},
+}
+
+// Full IKE message: fixed header followed by all payload bytes.
+// Now using nested field access and arithmetic!
+ike_message = {
+    @header:  ike_header,
+    payloads: [u8; @header.length - |ike_header|],
+}
+
+
+// =============================================================================
+// §3.2  Generic Payload Header
+//
+// Every IKE payload begins with this 4-byte header.
+//
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   | Next Payload  |C|  RESERVED   |         Payload Length        |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// `payload_length` includes these 4 header bytes.
+// Body length = payload_length - |generic_payload_header|.
+//
+// [L1] Body slicing requires arithmetic on @payload_length.
+// [L2] Bit 7 of `critical_reserved` is the Critical flag; bits 6-0 are
+//      RESERVED and therefore constrained to zero.
+// =============================================================================
+
+generic_payload_header = {
+    next_payload:        next_payload_type,
+    critical_reserved:   payload_critical,
+    @payload_length:     u16 | {4..0xffff},
+}
+
+
+// =============================================================================
+// §3.3.5  Transform Attribute
+//
+// The AF (Attribute Format) bit governs whether the TLV or TV encoding is
+// used.  AF=1 → TV (2-byte value follows immediately); AF=0 → TLV (2-byte
+// length then variable value).
+//
+//   TV:  | 1 | Attr-Type (15 bits) | Value (2 bytes) |
+//   TLV: | 0 | Attr-Type (15 bits) | Length (2 bytes) | Value (var) |
+//
+// [L2] The AF bit is bit 15 of the first 16-bit word.  We branch on the whole
+//      word/range rather than on the individual bit, which is enough to
+//      distinguish TV vs TLV encodings.
+//
+// Fully-specified TV form for the only currently-defined attribute
+// (Key Length, type = 14):
+// =============================================================================
+
+// Key Length attribute in TV format (AF=1, type=14, value=key-length-in-bits)
+transform_attr_key_length = {
+    // Wire: 0x800E (AF=1, type=14)
+    const attr_type_and_af: u16 = 0x800e,
+    key_length_bits: u16,
+}
+
+transform_attr_tv = {
+    @type_and_af: u16 | {0x8000..0x800d, 0x800f..0xffff},
+    value:        u16,
+}
+
+transform_attr_tlv = {
+    @type_and_af: u16 | {0..0x7fff},
+    @length:      u16,
+    value:        [u8; @length],
+}
+
+transform_attr = choose {
+    KeyLength(transform_attr_key_length),
+    TV(transform_attr_tv),
+    TLV(transform_attr_tlv),
+}
+
+
+// =============================================================================
+// §3.3.2  Transform Substructure
+//
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   | 0 (last) or 3 |   RESERVED    |        Transform Length       |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   |Transform Type |   RESERVED    |          Transform ID         |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                      Transform Attributes                     ~
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// `transform_length` includes the 8-byte fixed header.
+// Attributes region = transform_length - 8.
+//
+// The remaining attribute region is exactly @transform_length - 8 bytes.
+// =============================================================================
+
+// `last_or_more` = 0 if this is the last transform, 3 if more follow.
+transform = {
+    last_or_more:       u8 | {0, 3},
+    const reserved:     u8 = 0,
+    @transform_length:  u16 | {8..0xffff},
+    @transform_type:    transform_type,
+    const reserved2:    u8 = 0,
+    transform_id:       transform_id_value(@transform_type),
+    attrs:              [u8; @transform_length - 8] >>= Vec<transform_attr>,
+}
+
+
+// =============================================================================
+// §3.3.1  Proposal Substructure
+//
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   | 0 (last) or 2 |   RESERVED    |         Proposal Length       |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   | Proposal Num  |  Protocol ID  |    SPI Size   |Num Transforms |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                        SPI (variable)                         ~
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                        <Transforms>                           ~
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// `proposal_length` = 8 (fixed header) + spi_size + sum(transform lengths).
+// We first slice the entire variable part (`proposal_length - 8`) and then
+// dispatch on `spi_size` inside that framed region. This keeps the spec exact
+// without generating arithmetic over dependent SPI lengths in exec code.
+//
+// The transform sequence is both count-bounded and length-bounded.
+// =============================================================================
+
+proposal_body_spi0(@num_transforms: u8 | {1..0xff}) = {
+    spi:        [u8; 0],
+    transforms: Tail >>= [transform; @num_transforms],
+}
+
+proposal_body_spi4(@num_transforms: u8 | {1..0xff}) = {
+    spi:        [u8; 4],
+    transforms: Tail >>= [transform; @num_transforms],
+}
+
+proposal_body_spi8(@num_transforms: u8 | {1..0xff}) = {
+    spi:        [u8; 8],
+    transforms: Tail >>= [transform; @num_transforms],
+}
+
+proposal = {
+    last_or_more:       u8 | {0, 2},
+    const reserved:     u8 = 0,
+    @proposal_length:   u16 | {8..0xffff},
+    proposal_num:       u8 | {1..},
+    @protocol_id:       ike_protocol_id,
+    @spi_size:          proposal_spi_size_byte,
+    @num_transforms:    u8 | {1..0xff},
+    body:               [u8; @proposal_length - 8] >>= choose(@spi_size) {
+        0 => proposal_body_spi0(@num_transforms),
+        4 => proposal_body_spi4(@num_transforms),
+        8 => proposal_body_spi8(@num_transforms),
+    },
+}
+
+
+// =============================================================================
+// §3.3  Security Association (SA) Payload
+//
+// Generic Payload Header + variable list of Proposal substructures.
+// The proposal list runs to the end of the payload.
+// =============================================================================
+
+sa_payload_body(@payload_length: u16 | {4..0xffff}) = {
+    proposals: [u8; @payload_length - |generic_payload_header|] >>= Vec<proposal>,
+}
+
+
+// =============================================================================
+// §3.4  Key Exchange (KE) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   |   Diffie-Hellman Group Num    |           RESERVED            |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                       Key Exchange Data                       ~
+//
+// ke_data length = payload_length - 4 (header) - 4 (dh_group + reserved) = payload_length - 8.
+// =============================================================================
+
+ke_payload_body(@payload_length: u16 | {8..0xffff}) = {
+    dh_group_num: dh_id,
+    const reserved: u16 = 0,
+    ke_data:      [u8; @payload_length - 8],
+}
+
+
+// =============================================================================
+// §3.5  Identification Payloads (IDi / IDr)
+//
+//   Generic Payload Header (4 bytes)
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   |   ID Type     |                 RESERVED                      |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                   Identification Data                         ~
+//
+// id_data length = payload_length - 8.
+// =============================================================================
+
+id_payload_body(@payload_length: u16 | {8..0xffff}) = {
+    id_type:  id_type,
+    const reserved: [u8; 3] = [0; 3],
+    id_data:  [u8; @payload_length - 8],
+}
+
+
+// =============================================================================
+// §3.6  Certificate (CERT) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   | Cert Encoding |                                               |
+//   +-+-+-+-+-+-+-+-+          Certificate Data                     ~
+//
+// cert_data length = payload_length - 5.
+// =============================================================================
+
+cert_payload_body(@payload_length: u16 | {5..0xffff}) = {
+    cert_encoding: cert_encoding,
+    cert_data:     [u8; @payload_length - 5],
+}
+
+
+// =============================================================================
+// §3.7  Certificate Request (CERTREQ) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   | Cert Encoding |                                               |
+//   +-+-+-+-+-+-+-+-+       Certification Authority                 ~
+//
+// ca_data length = payload_length - 5.
+// =============================================================================
+
+certreq_payload_body(@payload_length: u16 | {5..0xffff}) = {
+    cert_encoding:  cert_encoding,
+    ca_data:        [u8; @payload_length - 5],
+}
+
+
+// =============================================================================
+// §3.8  Authentication (AUTH) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   | Auth Method   |                RESERVED                       |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                      Authentication Data                      ~
+//
+// auth_data length = payload_length - 8.
+// =============================================================================
+
+auth_payload_body(@payload_length: u16 | {8..0xffff}) = {
+    auth_method: auth_method,
+    const reserved: [u8; 3] = [0; 3],
+    auth_data:   [u8; @payload_length - 8],
+}
+
+
+// =============================================================================
+// §3.9  Nonce (Ni / Nr) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   ~                         Nonce Data                            ~
+//
+// nonce_data length = payload_length - |generic_payload_header|, constrained to 16..256 bytes.
+// =============================================================================
+
+nonce_payload_body(@payload_length: u16 | {20..260}) = {
+    nonce_data: [u8; @payload_length - |generic_payload_header|],
+}
+
+
+// =============================================================================
+// §3.10  Notify (N) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   |  Protocol ID  |   SPI Size    |      Notify Message Type      |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                Security Parameter Index (SPI)                 ~
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                       Notification Data                       ~
+//
+// The variable part after the 4-byte Notify payload header is framed as
+// `payload_length - 8`, then interpreted according to `spi_size`.
+// =============================================================================
+
+notify_payload_body_spi0 = {
+    spi:               [u8; 0],
+    notification_data: Tail,
+}
+
+notify_payload_body_spi4 = {
+    spi:               [u8; 4],
+    notification_data: Tail,
+}
+
+notify_payload_body(@payload_length: u16 | {8..0xffff}) = {
+    @protocol_id:       notify_protocol_id,
+    @spi_size:          ipsec_spi_size_or_none,
+    notify_msg_type:    notify_msg_type,
+    rest:               [u8; @payload_length - 8] >>= choose(@spi_size) {
+        0 => notify_payload_body_spi0,
+        4 => notify_payload_body_spi4,
+    },
+}
+
+
+// =============================================================================
+// §3.11  Delete (D) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   | Protocol ID   |   SPI Size    |          Num of SPIs          |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~               Security Parameter Index(es) (SPI)              ~
+//
+// The SPI list is determined by `spi_size`: either empty or a counted list of
+// 4-byte IPsec SPIs. The enclosing payload framing enforces exact consumption.
+// =============================================================================
+
+delete_payload_spis_none = [u8; 0]
+
+delete_payload_spis_ipsec(@num_spis: u16) = [u32; @num_spis]
+
+delete_payload_body = {
+    @protocol_id: ike_protocol_id,
+    @spi_size:    ipsec_spi_size_or_none,
+    @num_spis:    u16,
+    spis:         choose(@spi_size) {
+        0 => delete_payload_spis_none,
+        4 => delete_payload_spis_ipsec(@num_spis),
+    },
+}
+
+
+// =============================================================================
+// §3.12  Vendor ID (V) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   ~                         Vendor ID                             ~
+//
+// vendor_id length = payload_length - |generic_payload_header|.
+// =============================================================================
+
+vendor_id_payload_body(@payload_length: u16 | {4..0xffff}) = {
+    vendor_id: [u8; @payload_length - |generic_payload_header|],
+}
+
+
+// =============================================================================
+// §3.13.1  Traffic Selector (individual TS item)
+//
+// TS Type 7 (TS_IPV4_ADDR_RANGE): fixed 16-byte structure
+// TS Type 8 (TS_IPV6_ADDR_RANGE): fixed 40-byte structure
+//
+// `selector_length` includes the 4-byte TS sub-header.
+//
+// Note: the selector_length field is redundant for TS types 7 and 8 (whose
+// sizes are statically known) but is parsed for forward compatibility.
+//
+// Unknown TS types still carry an explicit selector_length field, so their
+// remaining body can still be sliced precisely.
+// =============================================================================
+
+// IPv4 Traffic Selector (TS Type 7, Selector Length = 16)
+ts_ipv4 = {
+    const ts_type:         u8  = 7,
+    ip_protocol_id:        u8,
+    const selector_length: u16 = 16,
+    start_port:            u16,
+    end_port:              u16,
+    start_address:         [u8; 4],
+    end_address:           [u8; 4],
+}
+
+// IPv6 Traffic Selector (TS Type 8, Selector Length = 40)
+ts_ipv6 = {
+    const ts_type:         u8  = 8,
+    ip_protocol_id:        u8,
+    const selector_length: u16 = 40,
+    start_port:            u16,
+    end_port:              u16,
+    start_address:         [u8; 16],
+    end_address:           [u8; 16],
+}
+
+ts_unknown_inner = {
+    ip_protocol_id:        u8,
+    @selector_length:      u16 | {4..0xffff},
+    selector_data:         [u8; @selector_length - 4],
+}
+
+// Dispatch on TS type; unknown types still use selector_length for framing.
+traffic_selector = {
+    @ts_type_byte: ts_type,
+    ts_body: choose(@ts_type_byte) {
+        TS_IPV4_ADDR_RANGE => ts_ipv4_selector_body,
+        TS_IPV6_ADDR_RANGE => ts_ipv6_selector_body,
+        _ => ts_unknown_inner,
+    },
+}
+
+// Inner bodies (ts_type byte already consumed by the dispatcher above)
+ts_ipv4_selector_body = {
+    ip_protocol_id:        u8,
+    const selector_length: u16 = 16,
+    start_port:            u16,
+    end_port:              u16,
+    start_address:         [u8; 4],
+    end_address:           [u8; 4],
+}
+
+ts_ipv6_selector_body = {
+    ip_protocol_id:        u8,
+    const selector_length: u16 = 40,
+    start_port:            u16,
+    end_port:              u16,
+    start_address:         [u8; 16],
+    end_address:           [u8; 16],
+}
+
+
+// =============================================================================
+// §3.13  Traffic Selector (TS) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   | Number of TSs |                 RESERVED                      |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                       <Traffic Selectors>                     ~
+//
+// The Traffic Selector list runs to the end of the payload.
+// =============================================================================
+
+ts_payload_body(@payload_length: u16 | {8..0xffff}) = {
+    @num_ts:   u8 | {1..0xff},
+    const reserved: [u8; 3] = [0; 3],
+    selectors: [u8; @payload_length - 8] >>= [traffic_selector; @num_ts],
+}
+
+
+// =============================================================================
+// §3.14  Encrypted and Authenticated (SK) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   |                    Initialization Vector                      |
+//   |         (length is block size of the negotiated cipher)       |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                  Encrypted IKE Payloads                       ~
+//   ~                  Padding (0–255 bytes)                        ~
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   |  Pad Length   |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                  Integrity Checksum Data                      ~
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// The IV length equals the cipher block size (negotiated out-of-band).
+// The integrity checksum length is determined by the negotiated integrity alg.
+// Both are dynamic quantities not representable with current Vest primitives.
+//
+// [L1] All sub-regions (IV, ciphertext, padding, ICV) require arithmetic.
+// =============================================================================
+
+// Approximation: treat the entire encrypted body as an opaque byte tail.
+// A real decryption pass would re-parse the plaintext using the payload
+// formats defined in this file.
+sk_payload_body(@payload_length: u16 | {4..0xffff}) = {
+    // IV || EncryptedPayloads || Padding || PadLength || ICV
+    encrypted_body: [u8; @payload_length - |generic_payload_header|],
+}
+
+
+// =============================================================================
+// §3.15  Configuration (CP) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   |   CFG Type    |                    RESERVED                   |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                   Configuration Attributes                    ~
+//
+// The attributes region is exactly payload_length - 8 bytes.
+// =============================================================================
+
+cp_payload_body(@payload_length: u16 | {8..0xffff}) = {
+    cfg_type: cfg_type,
+    const reserved: [u8; 3] = [0; 3],
+    attributes: [u8; @payload_length - 8] >>= Vec<cfg_attribute>,
+}
+
+
+// =============================================================================
+// §3.15.1  Configuration Attribute
+//
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   |R|         Attribute Type      |            Length             |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   ~                             Value                             ~
+//
+// `length` is the byte length of `value` (does NOT include the 4-byte header).
+//
+// [L2] Bit 15 of the first word is the Reserved (R) bit; it is constrained to 0.
+// =============================================================================
+
+cfg_attribute = {
+    @r_and_attr_type: cfg_attr_type_word,
+    @length:          u16,
+    value:            [u8; @length],
+}
+
+
+// =============================================================================
+// §3.16  Extensible Authentication Protocol (EAP) Payload
+//
+//   Generic Payload Header (4 bytes)
+//   ~                       EAP Message                             ~
+//
+// The EAP message itself has the following layout (RFC 3748):
+//
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   |     Code      | Identifier    |           Length              |
+//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//   |     Type      |  Type_Data ...
+//   +-+-+-+-+-+-+-+-+-
+//
+// EAP `length` covers Code+Identifier+Length+Type+Type_Data.
+// The IKEv2 Payload Length = EAP length + 4 (generic header).
+// Per RFC 5996 §3.16: EAP length = IKEv2 Payload Length - 4.
+//
+// Request/Response type_data length is eap_length - 5.
+// =============================================================================
+
+eap_code = enum {
+    Request  = 1,
+    Response = 2,
+    Success  = 3,
+    Failure  = 4,
+    ...
+}
+
+// EAP message body inside the IKEv2 EAP payload.
+// For Success (3) and Failure (4), the message is exactly 4 bytes and
+// Type / Type_Data are absent.
+eap_message_success_failure = {
+    code:       eap_code | {Success, Failure},
+    identifier: u8,
+    const eap_length: u16 = 4,
+}
+
+// EAP Request or Response: Type and variable Type_Data follow.
+eap_message_req_resp = {
+    code:       eap_code | {Request, Response},
+    identifier: u8,
+    @eap_length: u16 | {5..0xffff},
+    eap_type:   u8,
+    type_data:  [u8; @eap_length - 5],
+}
+
+// EAP payload body dispatcher
+eap_payload_body(@payload_length: u16 | {8..0xffff}) = {
+    @code: eap_code,
+    eap_rest: choose(@code) {
+        Success  => eap_success_rest,
+        Failure  => eap_failure_rest,
+        Request  => eap_req_resp_rest,
+        Response => eap_req_resp_rest,
+    },
+}
+
+// Remaining bytes after reading `code` for Success/Failure (3 more bytes)
+eap_success_rest = {
+    identifier: u8,
+    const eap_length: u16 = 4,
+}
+
+// Remaining bytes after reading `code` for Failure (same layout as success)
+eap_failure_rest = {
+    identifier: u8,
+    const eap_length: u16 = 4,
+}
+
+// Remaining bytes after reading `code` for Request/Response
+eap_req_resp_rest = {
+    identifier:  u8,
+    @eap_length: u16 | {5..0xffff},
+    eap_type:    u8,
+    type_data:   [u8; @eap_length - 5],
+}
+
+
+// =============================================================================
+// Putting it all together: a dispatched IKEv2 payload
+//
+// Each concrete payload is framed by a generic_payload_header followed by a
+// body whose byte length is (header.payload_length - |generic_payload_header|).
+// We dispatch on the *previous* payload's next_payload field (the chaining
+// mechanism from §3.2), and use the parsed header length to frame the body.
+// =============================================================================
+
+ikev2_sa_payload_inner = {
+    proposals: Tail >>= Vec<proposal>,
+}
+
+ikev2_ke_payload_inner = {
+    dh_group_num: dh_id,
+    const reserved: u16 = 0,
+    ke_data: Tail,
+}
+
+ikev2_id_payload_inner = {
+    id_type: id_type,
+    const reserved: [u8; 3] = [0; 3],
+    id_data: Tail,
+}
+
+ikev2_cert_payload_inner = {
+    cert_encoding: cert_encoding,
+    cert_data: Tail,
+}
+
+ikev2_certreq_payload_inner = {
+    cert_encoding: cert_encoding,
+    ca_data: Tail,
+}
+
+ikev2_auth_payload_inner = {
+    auth_method: auth_method,
+    const reserved: [u8; 3] = [0; 3],
+    auth_data: Tail,
+}
+
+ikev2_nonce_payload_inner = {
+    nonce_data: Tail,
+}
+
+ikev2_notify_payload_inner = {
+    @protocol_id:       notify_protocol_id,
+    @spi_size:          ipsec_spi_size_or_none,
+    notify_msg_type:    notify_msg_type,
+    spi:                [u8; @spi_size],
+    notification_data:  Tail,
+}
+
+ikev2_vendor_id_payload_inner = {
+    vendor_id: Tail,
+}
+
+ikev2_ts_payload_inner = {
+    @num_ts:   u8 | {1..0xff},
+    const reserved: [u8; 3] = [0; 3],
+    selectors: Tail >>= [traffic_selector; @num_ts],
+}
+
+ikev2_sk_payload_inner = {
+    encrypted_body: Tail,
+}
+
+ikev2_cp_payload_inner = {
+    cfg_type: cfg_type,
+    const reserved: [u8; 3] = [0; 3],
+    attributes: Tail >>= Vec<cfg_attribute>,
+}
+
+ikev2_eap_payload_inner = {
+    @code: eap_code,
+    eap_rest: choose(@code) {
+        Success  => eap_success_rest,
+        Failure  => eap_failure_rest,
+        Request  => eap_req_resp_rest,
+        Response => eap_req_resp_rest,
+    },
+}
+
+ikev2_payload_body(@next_pt: next_payload_type) = choose(@next_pt) {
+    SA => ikev2_sa_payload_inner,
+    KE => ikev2_ke_payload_inner,
+    IDi => ikev2_id_payload_inner,
+    IDr => ikev2_id_payload_inner,
+    CERT => ikev2_cert_payload_inner,
+    CERTREQ => ikev2_certreq_payload_inner,
+    AUTH => ikev2_auth_payload_inner,
+    Nonce => ikev2_nonce_payload_inner,
+    Notify => ikev2_notify_payload_inner,
+    Delete => delete_payload_body,
+    VendorID => ikev2_vendor_id_payload_inner,
+    TSi => ikev2_ts_payload_inner,
+    TSr => ikev2_ts_payload_inner,
+    SK => ikev2_sk_payload_inner,
+    CP => ikev2_cp_payload_inner,
+    EAP => ikev2_eap_payload_inner,
+    _ => Tail,
+}
+
+// A single generic payload dispatched by next_payload_type.
+// `next_pt` is the type code carried in the *preceding* payload's header
+// (or in the IKE header for the first payload in a message).
+ikev2_payload(@next_pt: next_payload_type) = {
+    @hdr: generic_payload_header,
+    body: [u8; @hdr.payload_length - |generic_payload_header|] >>= ikev2_payload_body(@next_pt),
+}
diff --git a/vest-dsl/test/src/josh.rs b/vest-dsl/test/src/josh.rs
index 135afa1d..e6df3368 100644
--- a/vest-dsl/test/src/josh.rs
+++ b/vest-dsl/test/src/josh.rs
@@ -1049,6 +1049,9 @@ pub open spec fn spec_tst_mydata(tag: u8) -> SpecTstMydataCombinator {
 }
 
 pub fn tst_mydata<'a>(tag: u8) -> (o: TstMydataCombinator)
+    requires
+        spec_tst_tag().wf(tag@),
+
     ensures o@ == spec_tst_mydata(tag@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
@@ -1065,6 +1068,8 @@ pub fn tst_mydata<'a>(tag: u8) -> (o: TstMydataCombinator)
 pub fn parse_tst_mydata<'a>(input: &'a [u8], tag: u8) -> (res: PResult<<TstMydataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_tst_tag().wf(tag@),
+
     ensures
         res matches Ok((n, v)) ==> spec_tst_mydata(tag@).spec_parse(input@) == Some((n as int, v@)),
         spec_tst_mydata(tag@).spec_parse(input@) matches Some((n, v))
@@ -1080,6 +1085,8 @@ pub fn serialize_tst_mydata<'a>(v: <TstMydataCombinator as Combinator<'a, &'a [u
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_tst_mydata(tag@).wf(v@),
+        spec_tst_tag().wf(tag@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -1096,6 +1103,8 @@ pub fn tst_mydata_len<'a>(v: <TstMydataCombinator as Combinator<'a, &'a [u8], Ve
     requires
         spec_tst_mydata(tag@).wf(v@),
         spec_tst_mydata(tag@).spec_serialize(v@).len() <= usize::MAX,
+        spec_tst_tag().wf(tag@),
+
     ensures
         serialize_len == spec_tst_mydata(tag@).spec_serialize(v@).len(),
 {
@@ -1324,16 +1333,20 @@ type TstCont0Input<'a, 'b, 'x> = POrSType<TstCont0Type<'a, 'b>, TstCont0SType<'a
 impl<'a, 'b, 'x> Continuation<TstCont0Input<'a, 'b, 'x>> for TstCont0 {
     type Output = TstMydataCombinator;
 
-    open spec fn requires(&self, deps: TstCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: TstCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_tst_tag()).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: TstCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_tst_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_tst_cont0(deps@)
     }
 
     fn apply(&self, deps: TstCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let tag = *deps;
+                let tag = deps;
+                let tag = *tag;
                 tst_mydata(tag)
             }
             POrSType::S(deps) => {
diff --git a/vest-dsl/test/src/length_expr.rs b/vest-dsl/test/src/length_expr.rs
new file mode 100644
index 00000000..cec8fcbe
--- /dev/null
+++ b/vest-dsl/test/src/length_expr.rs
@@ -0,0 +1,3975 @@
+
+#![allow(warnings)]
+#![allow(unused)]
+use vstd::prelude::*;
+use vest_lib::regular::modifier::*;
+use vest_lib::regular::bytes;
+use vest_lib::regular::variant::*;
+use vest_lib::regular::sequence::*;
+use vest_lib::regular::repetition::*;
+use vest_lib::regular::disjoint::DisjointFrom;
+use vest_lib::regular::tag::*;
+use vest_lib::regular::uints::*;
+use vest_lib::utils::*;
+use vest_lib::properties::*;
+use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
+use vest_lib::regular::leb128::*;
+
+macro_rules! impl_wrapper_combinator {
+    ($combinator:ty, $combinator_alias:ty) => {
+        ::vstd::prelude::verus! {
+            impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for $combinator {
+                type Type = <$combinator_alias as Combinator<'a, &'a [u8], Vec<u8>>>::Type;
+                type SType = <$combinator_alias as Combinator<'a, &'a [u8], Vec<u8>>>::SType;
+                fn length(&self, v: Self::SType) -> usize
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+                open spec fn ex_requires(&self) -> bool
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+                fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&self.0, s) }
+                fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+            }
+        } // verus!
+    };
+}
+verus!{
+
+pub struct SpecHeader {
+    pub len: u16,
+    pub flags: u8,
+}
+
+pub type SpecHeaderInner = (u16, u8);
+
+
+impl SpecFrom<SpecHeader> for SpecHeaderInner {
+    open spec fn spec_from(m: SpecHeader) -> SpecHeaderInner {
+        (m.len, m.flags)
+    }
+}
+
+impl SpecFrom<SpecHeaderInner> for SpecHeader {
+    open spec fn spec_from(m: SpecHeaderInner) -> SpecHeader {
+        let (len, flags) = m;
+        SpecHeader { len, flags }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Header {
+    pub len: u16,
+    pub flags: u8,
+}
+
+impl View for Header {
+    type V = SpecHeader;
+
+    open spec fn view(&self) -> Self::V {
+        SpecHeader {
+            len: self.len@,
+            flags: self.flags@,
+        }
+    }
+}
+pub type HeaderInner = (u16, u8);
+
+pub type HeaderInnerRef<'a> = (&'a u16, &'a u8);
+impl<'a> From<&'a Header> for HeaderInnerRef<'a> {
+    fn ex_from(m: &'a Header) -> HeaderInnerRef<'a> {
+        (&m.len, &m.flags)
+    }
+}
+
+impl From<HeaderInner> for Header {
+    fn ex_from(m: HeaderInner) -> Header {
+        let (len, flags) = m;
+        Header { len, flags }
+    }
+}
+
+pub struct HeaderMapper;
+impl View for HeaderMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for HeaderMapper {
+    type Src = SpecHeaderInner;
+    type Dst = SpecHeader;
+}
+impl SpecIsoProof for HeaderMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for HeaderMapper {
+    type Src = HeaderInner;
+    type Dst = Header;
+    type RefSrc = HeaderInnerRef<'a>;
+}
+
+pub struct SpecHeaderCombinator(pub SpecHeaderCombinatorAlias);
+
+impl SpecCombinator for SpecHeaderCombinator {
+    type Type = SpecHeader;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecHeaderCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHeaderCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecHeaderCombinatorAlias = Mapped<SpecPair<Refined<U16Le, Predicate12905524399844557818>, U8>, HeaderMapper>;
+pub struct Predicate12905524399844557818;
+impl View for Predicate12905524399844557818 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate12905524399844557818 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 3 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate12905524399844557818 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 3 && i <= 65535)
+    }
+}
+
+pub struct HeaderCombinator(pub HeaderCombinatorAlias);
+
+impl View for HeaderCombinator {
+    type V = SpecHeaderCombinator;
+    open spec fn view(&self) -> Self::V { SpecHeaderCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeaderCombinator {
+    type Type = Header;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type HeaderCombinatorAlias = Mapped<Pair<Refined<U16Le, Predicate12905524399844557818>, U8, HeaderCont0>, HeaderMapper>;
+
+
+pub open spec fn spec_header() -> SpecHeaderCombinator {
+    SpecHeaderCombinator(
+    Mapped {
+        inner: Pair::spec_new(Refined { inner: U16Le, predicate: Predicate12905524399844557818 }, |deps| spec_header_cont0(deps)),
+        mapper: HeaderMapper,
+    })
+}
+
+pub open spec fn spec_header_cont0(deps: u16) -> U8 {
+    let len = deps;
+    U8
+}
+
+impl View for HeaderCont0 {
+    type V = spec_fn(u16) -> U8;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_header_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn header<'a>() -> (o: HeaderCombinator)
+    ensures o@ == spec_header(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = HeaderCombinator(
+    Mapped {
+        inner: Pair::new(Refined { inner: U16Le, predicate: Predicate12905524399844557818 }, HeaderCont0),
+        mapper: HeaderMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_header()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_header<'a>(input: &'a [u8]) -> (res: PResult<<HeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_header().spec_parse(input@) == Some((n as int, v@)),
+        spec_header().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_header().spec_parse(input@) is None,
+        spec_header().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_header<'a>(v: <HeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_header().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_header().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_header().spec_serialize(v@).len(),
+{
+    let combinator = header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct HeaderCont0;
+type HeaderCont0Type<'a, 'b> = &'b u16;
+type HeaderCont0SType<'a, 'x> = &'x u16;
+type HeaderCont0Input<'a, 'b, 'x> = POrSType<HeaderCont0Type<'a, 'b>, HeaderCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<HeaderCont0Input<'a, 'b, 'x>> for HeaderCont0 {
+    type Output = U8;
+
+    open spec fn requires(&self, deps: HeaderCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Le, predicate: Predicate12905524399844557818 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: HeaderCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_header_cont0(deps@)
+    }
+
+    fn apply(&self, deps: HeaderCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let len = deps;
+                let len = *len;
+                U8
+            }
+            POrSType::S(deps) => {
+                let len = deps;
+                let len = *len;
+                U8
+            }
+        }
+    }
+}
+                
+pub type SpecHeaderAlias = SpecHeader;
+pub type HeaderAlias = Header;
+pub type HeaderAliasRef<'a> = &'a Header;
+
+
+pub struct SpecHeaderAliasCombinator(pub SpecHeaderAliasCombinatorAlias);
+
+impl SpecCombinator for SpecHeaderAliasCombinator {
+    type Type = SpecHeaderAlias;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecHeaderAliasCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHeaderAliasCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecHeaderAliasCombinatorAlias = SpecHeaderCombinator;
+
+pub struct HeaderAliasCombinator(pub HeaderAliasCombinatorAlias);
+
+impl View for HeaderAliasCombinator {
+    type V = SpecHeaderAliasCombinator;
+    open spec fn view(&self) -> Self::V { SpecHeaderAliasCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeaderAliasCombinator {
+    type Type = HeaderAlias;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type HeaderAliasCombinatorAlias = HeaderCombinator;
+
+
+pub open spec fn spec_header_alias() -> SpecHeaderAliasCombinator {
+    SpecHeaderAliasCombinator(spec_header())
+}
+
+                
+pub fn header_alias<'a>() -> (o: HeaderAliasCombinator)
+    ensures o@ == spec_header_alias(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = HeaderAliasCombinator(header());
+    // assert({
+    //     &&& combinator@ == spec_header_alias()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_header_alias<'a>(input: &'a [u8]) -> (res: PResult<<HeaderAliasCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_header_alias().spec_parse(input@) == Some((n as int, v@)),
+        spec_header_alias().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_header_alias().spec_parse(input@) is None,
+        spec_header_alias().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = header_alias();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_header_alias<'a>(v: <HeaderAliasCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_header_alias().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_header_alias().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_header_alias().spec_serialize(v@).len(),
+{
+    let combinator = header_alias();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecDivide {
+    pub chunks: Seq<u8>,
+}
+
+pub type SpecDivideInner = Seq<u8>;
+
+
+impl SpecFrom<SpecDivide> for SpecDivideInner {
+    open spec fn spec_from(m: SpecDivide) -> SpecDivideInner {
+        m.chunks
+    }
+}
+
+impl SpecFrom<SpecDivideInner> for SpecDivide {
+    open spec fn spec_from(m: SpecDivideInner) -> SpecDivide {
+        let chunks = m;
+        SpecDivide { chunks }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Divide<'a> {
+    pub chunks: &'a [u8],
+}
+
+impl View for Divide<'_> {
+    type V = SpecDivide;
+
+    open spec fn view(&self) -> Self::V {
+        SpecDivide {
+            chunks: self.chunks@,
+        }
+    }
+}
+pub type DivideInner<'a> = &'a [u8];
+
+pub type DivideInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a Divide<'a>> for DivideInnerRef<'a> {
+    fn ex_from(m: &'a Divide) -> DivideInnerRef<'a> {
+        &m.chunks
+    }
+}
+
+impl<'a> From<DivideInner<'a>> for Divide<'a> {
+    fn ex_from(m: DivideInner) -> Divide {
+        let chunks = m;
+        Divide { chunks }
+    }
+}
+
+pub struct DivideMapper;
+impl View for DivideMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for DivideMapper {
+    type Src = SpecDivideInner;
+    type Dst = SpecDivide;
+}
+impl SpecIsoProof for DivideMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for DivideMapper {
+    type Src = DivideInner<'a>;
+    type Dst = Divide<'a>;
+    type RefSrc = DivideInnerRef<'a>;
+}
+
+pub struct SpecDivideCombinator(pub SpecDivideCombinatorAlias);
+
+impl SpecCombinator for SpecDivideCombinator {
+    type Type = SpecDivide;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecDivideCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDivideCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecDivideCombinatorAlias = Mapped<bytes::Variable, DivideMapper>;
+
+pub struct DivideCombinator(pub DivideCombinatorAlias);
+
+impl View for DivideCombinator {
+    type V = SpecDivideCombinator;
+    open spec fn view(&self) -> Self::V { SpecDivideCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DivideCombinator {
+    type Type = Divide<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type DivideCombinatorAlias = Mapped<bytes::Variable, DivideMapper>;
+
+
+pub open spec fn spec_divide(total: u32) -> SpecDivideCombinator {
+    SpecDivideCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::spec_from(total) / 4)) as usize),
+        mapper: DivideMapper,
+    })
+}
+
+pub fn divide<'a>(total: u32) -> (o: DivideCombinator)
+
+    ensures o@ == spec_divide(total@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = DivideCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::ex_from(total) / 4)) as usize),
+        mapper: DivideMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_divide(total@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_divide<'a>(input: &'a [u8], total: u32) -> (res: PResult<<DivideCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+
+    ensures
+        res matches Ok((n, v)) ==> spec_divide(total@).spec_parse(input@) == Some((n as int, v@)),
+        spec_divide(total@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_divide(total@).spec_parse(input@) is None,
+        spec_divide(total@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = divide( total );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_divide<'a>(v: <DivideCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, total: u32) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_divide(total@).wf(v@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_divide(total@).spec_serialize(v@).len() <= usize::MAX,
+
+    ensures
+        serialize_len == spec_divide(total@).spec_serialize(v@).len(),
+{
+    let combinator = divide( total );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub enum SpecFixedChoice {
+    Variant0(u16),
+    Variant1(u16),
+}
+
+pub type SpecFixedChoiceInner = Either<u16, u16>;
+
+impl SpecFrom<SpecFixedChoice> for SpecFixedChoiceInner {
+    open spec fn spec_from(m: SpecFixedChoice) -> SpecFixedChoiceInner {
+        match m {
+            SpecFixedChoice::Variant0(m) => Either::Left(m),
+            SpecFixedChoice::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecFixedChoiceInner> for SpecFixedChoice {
+    open spec fn spec_from(m: SpecFixedChoiceInner) -> SpecFixedChoice {
+        match m {
+            Either::Left(m) => SpecFixedChoice::Variant0(m),
+            Either::Right(m) => SpecFixedChoice::Variant1(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum FixedChoice {
+    Variant0(u16),
+    Variant1(u16),
+}
+
+pub type FixedChoiceInner = Either<u16, u16>;
+
+pub type FixedChoiceInnerRef<'a> = Either<&'a u16, &'a u16>;
+
+
+impl View for FixedChoice {
+    type V = SpecFixedChoice;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            FixedChoice::Variant0(m) => SpecFixedChoice::Variant0(m@),
+            FixedChoice::Variant1(m) => SpecFixedChoice::Variant1(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a FixedChoice> for FixedChoiceInnerRef<'a> {
+    fn ex_from(m: &'a FixedChoice) -> FixedChoiceInnerRef<'a> {
+        match m {
+            FixedChoice::Variant0(m) => Either::Left(m),
+            FixedChoice::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+impl From<FixedChoiceInner> for FixedChoice {
+    fn ex_from(m: FixedChoiceInner) -> FixedChoice {
+        match m {
+            Either::Left(m) => FixedChoice::Variant0(m),
+            Either::Right(m) => FixedChoice::Variant1(m),
+        }
+    }
+    
+}
+
+
+pub struct FixedChoiceMapper;
+impl View for FixedChoiceMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for FixedChoiceMapper {
+    type Src = SpecFixedChoiceInner;
+    type Dst = SpecFixedChoice;
+}
+impl SpecIsoProof for FixedChoiceMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for FixedChoiceMapper {
+    type Src = FixedChoiceInner;
+    type Dst = FixedChoice;
+    type RefSrc = FixedChoiceInnerRef<'a>;
+}
+
+type SpecFixedChoiceCombinatorAlias1 = Choice<Cond<U16Le>, Cond<U16Le>>;
+pub struct SpecFixedChoiceCombinator(pub SpecFixedChoiceCombinatorAlias);
+
+impl SpecCombinator for SpecFixedChoiceCombinator {
+    type Type = SpecFixedChoice;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecFixedChoiceCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecFixedChoiceCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecFixedChoiceCombinatorAlias = Mapped<SpecFixedChoiceCombinatorAlias1, FixedChoiceMapper>;
+type FixedChoiceCombinatorAlias1 = Choice<Cond<U16Le>, Cond<U16Le>>;
+pub struct FixedChoiceCombinator1(pub FixedChoiceCombinatorAlias1);
+impl View for FixedChoiceCombinator1 {
+    type V = SpecFixedChoiceCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(FixedChoiceCombinator1, FixedChoiceCombinatorAlias1);
+
+pub struct FixedChoiceCombinator(pub FixedChoiceCombinatorAlias);
+
+impl View for FixedChoiceCombinator {
+    type V = SpecFixedChoiceCombinator;
+    open spec fn view(&self) -> Self::V { SpecFixedChoiceCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FixedChoiceCombinator {
+    type Type = FixedChoice;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type FixedChoiceCombinatorAlias = Mapped<FixedChoiceCombinator1, FixedChoiceMapper>;
+
+
+pub open spec fn spec_fixed_choice(tag: u8) -> SpecFixedChoiceCombinator {
+    SpecFixedChoiceCombinator(Mapped { inner: Choice(Cond { cond: tag == 0, inner: U16Le }, Cond { cond: !(tag == 0), inner: U16Le }), mapper: FixedChoiceMapper })
+}
+
+pub fn fixed_choice<'a>(tag: u8) -> (o: FixedChoiceCombinator)
+
+    ensures o@ == spec_fixed_choice(tag@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = FixedChoiceCombinator(Mapped { inner: FixedChoiceCombinator1(Choice::new(Cond { cond: tag == 0, inner: U16Le }, Cond { cond: !(tag == 0), inner: U16Le })), mapper: FixedChoiceMapper });
+    // assert({
+    //     &&& combinator@ == spec_fixed_choice(tag@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_fixed_choice<'a>(input: &'a [u8], tag: u8) -> (res: PResult<<FixedChoiceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+
+    ensures
+        res matches Ok((n, v)) ==> spec_fixed_choice(tag@).spec_parse(input@) == Some((n as int, v@)),
+        spec_fixed_choice(tag@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_fixed_choice(tag@).spec_parse(input@) is None,
+        spec_fixed_choice(tag@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = fixed_choice( tag );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_fixed_choice<'a>(v: <FixedChoiceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, tag: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_fixed_choice(tag@).wf(v@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_fixed_choice(tag@).spec_serialize(v@).len() <= usize::MAX,
+
+    ensures
+        serialize_len == spec_fixed_choice(tag@).spec_serialize(v@).len(),
+{
+    let combinator = fixed_choice( tag );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecSimpleSub {
+    pub data: Seq<u8>,
+}
+
+pub type SpecSimpleSubInner = Seq<u8>;
+
+
+impl SpecFrom<SpecSimpleSub> for SpecSimpleSubInner {
+    open spec fn spec_from(m: SpecSimpleSub) -> SpecSimpleSubInner {
+        m.data
+    }
+}
+
+impl SpecFrom<SpecSimpleSubInner> for SpecSimpleSub {
+    open spec fn spec_from(m: SpecSimpleSubInner) -> SpecSimpleSub {
+        let data = m;
+        SpecSimpleSub { data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct SimpleSub<'a> {
+    pub data: &'a [u8],
+}
+
+impl View for SimpleSub<'_> {
+    type V = SpecSimpleSub;
+
+    open spec fn view(&self) -> Self::V {
+        SpecSimpleSub {
+            data: self.data@,
+        }
+    }
+}
+pub type SimpleSubInner<'a> = &'a [u8];
+
+pub type SimpleSubInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a SimpleSub<'a>> for SimpleSubInnerRef<'a> {
+    fn ex_from(m: &'a SimpleSub) -> SimpleSubInnerRef<'a> {
+        &m.data
+    }
+}
+
+impl<'a> From<SimpleSubInner<'a>> for SimpleSub<'a> {
+    fn ex_from(m: SimpleSubInner) -> SimpleSub {
+        let data = m;
+        SimpleSub { data }
+    }
+}
+
+pub struct SimpleSubMapper;
+impl View for SimpleSubMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for SimpleSubMapper {
+    type Src = SpecSimpleSubInner;
+    type Dst = SpecSimpleSub;
+}
+impl SpecIsoProof for SimpleSubMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for SimpleSubMapper {
+    type Src = SimpleSubInner<'a>;
+    type Dst = SimpleSub<'a>;
+    type RefSrc = SimpleSubInnerRef<'a>;
+}
+
+pub struct SpecSimpleSubCombinator(pub SpecSimpleSubCombinatorAlias);
+
+impl SpecCombinator for SpecSimpleSubCombinator {
+    type Type = SpecSimpleSub;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecSimpleSubCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSimpleSubCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecSimpleSubCombinatorAlias = Mapped<bytes::Variable, SimpleSubMapper>;
+
+pub struct SimpleSubCombinator(pub SimpleSubCombinatorAlias);
+
+impl View for SimpleSubCombinator {
+    type V = SpecSimpleSubCombinator;
+    open spec fn view(&self) -> Self::V { SpecSimpleSubCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SimpleSubCombinator {
+    type Type = SimpleSub<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type SimpleSubCombinatorAlias = Mapped<bytes::Variable, SimpleSubMapper>;
+
+
+pub open spec fn spec_simple_sub(len: u16) -> SpecSimpleSubCombinator {
+    SpecSimpleSubCombinator(
+    Mapped {
+        inner: bytes::Variable((((usize::spec_from(len) - 3) - 1)) as usize),
+        mapper: SimpleSubMapper,
+    })
+}
+
+pub fn simple_sub<'a>(len: u16) -> (o: SimpleSubCombinator)
+    requires
+        ((len) >= 4 && (len) <= 65535),
+
+    ensures o@ == spec_simple_sub(len@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = SimpleSubCombinator(
+    Mapped {
+        inner: bytes::Variable((((usize::ex_from(len) - 3) - 1)) as usize),
+        mapper: SimpleSubMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_simple_sub(len@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_simple_sub<'a>(input: &'a [u8], len: u16) -> (res: PResult<<SimpleSubCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((len) >= 4 && (len) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_simple_sub(len@).spec_parse(input@) == Some((n as int, v@)),
+        spec_simple_sub(len@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_simple_sub(len@).spec_parse(input@) is None,
+        spec_simple_sub(len@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = simple_sub( len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_simple_sub<'a>(v: <SimpleSubCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, len: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_simple_sub(len@).wf(v@),
+        ((len) >= 4 && (len) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_simple_sub(len@).spec_serialize(v@).len() <= usize::MAX,
+        ((len) >= 4 && (len) <= 65535),
+
+    ensures
+        serialize_len == spec_simple_sub(len@).spec_serialize(v@).len(),
+{
+    let combinator = simple_sub( len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecAliasSize {
+    pub bytes: Seq<u8>,
+}
+
+pub type SpecAliasSizeInner = Seq<u8>;
+
+
+impl SpecFrom<SpecAliasSize> for SpecAliasSizeInner {
+    open spec fn spec_from(m: SpecAliasSize) -> SpecAliasSizeInner {
+        m.bytes
+    }
+}
+
+impl SpecFrom<SpecAliasSizeInner> for SpecAliasSize {
+    open spec fn spec_from(m: SpecAliasSizeInner) -> SpecAliasSize {
+        let bytes = m;
+        SpecAliasSize { bytes }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct AliasSize<'a> {
+    pub bytes: &'a [u8],
+}
+
+impl View for AliasSize<'_> {
+    type V = SpecAliasSize;
+
+    open spec fn view(&self) -> Self::V {
+        SpecAliasSize {
+            bytes: self.bytes@,
+        }
+    }
+}
+pub type AliasSizeInner<'a> = &'a [u8];
+
+pub type AliasSizeInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a AliasSize<'a>> for AliasSizeInnerRef<'a> {
+    fn ex_from(m: &'a AliasSize) -> AliasSizeInnerRef<'a> {
+        &m.bytes
+    }
+}
+
+impl<'a> From<AliasSizeInner<'a>> for AliasSize<'a> {
+    fn ex_from(m: AliasSizeInner) -> AliasSize {
+        let bytes = m;
+        AliasSize { bytes }
+    }
+}
+
+pub struct AliasSizeMapper;
+impl View for AliasSizeMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for AliasSizeMapper {
+    type Src = SpecAliasSizeInner;
+    type Dst = SpecAliasSize;
+}
+impl SpecIsoProof for AliasSizeMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for AliasSizeMapper {
+    type Src = AliasSizeInner<'a>;
+    type Dst = AliasSize<'a>;
+    type RefSrc = AliasSizeInnerRef<'a>;
+}
+
+pub struct SpecAliasSizeCombinator(pub SpecAliasSizeCombinatorAlias);
+
+impl SpecCombinator for SpecAliasSizeCombinator {
+    type Type = SpecAliasSize;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecAliasSizeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecAliasSizeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecAliasSizeCombinatorAlias = Mapped<bytes::Fixed<3>, AliasSizeMapper>;
+
+pub struct AliasSizeCombinator(pub AliasSizeCombinatorAlias);
+
+impl View for AliasSizeCombinator {
+    type V = SpecAliasSizeCombinator;
+    open spec fn view(&self) -> Self::V { SpecAliasSizeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AliasSizeCombinator {
+    type Type = AliasSize<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type AliasSizeCombinatorAlias = Mapped<bytes::Fixed<3>, AliasSizeMapper>;
+
+
+pub open spec fn spec_alias_size() -> SpecAliasSizeCombinator {
+    SpecAliasSizeCombinator(
+    Mapped {
+        inner: bytes::Fixed::<3>,
+        mapper: AliasSizeMapper,
+    })
+}
+
+                
+pub fn alias_size<'a>() -> (o: AliasSizeCombinator)
+    ensures o@ == spec_alias_size(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = AliasSizeCombinator(
+    Mapped {
+        inner: bytes::Fixed::<3>,
+        mapper: AliasSizeMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_alias_size()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_alias_size<'a>(input: &'a [u8]) -> (res: PResult<<AliasSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_alias_size().spec_parse(input@) == Some((n as int, v@)),
+        spec_alias_size().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_alias_size().spec_parse(input@) is None,
+        spec_alias_size().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = alias_size();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_alias_size<'a>(v: <AliasSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_alias_size().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_alias_size().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_alias_size().spec_serialize(v@).len(),
+{
+    let combinator = alias_size();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecMultiArith {
+    pub body: Seq<u8>,
+}
+
+pub type SpecMultiArithInner = Seq<u8>;
+
+
+impl SpecFrom<SpecMultiArith> for SpecMultiArithInner {
+    open spec fn spec_from(m: SpecMultiArith) -> SpecMultiArithInner {
+        m.body
+    }
+}
+
+impl SpecFrom<SpecMultiArithInner> for SpecMultiArith {
+    open spec fn spec_from(m: SpecMultiArithInner) -> SpecMultiArith {
+        let body = m;
+        SpecMultiArith { body }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct MultiArith<'a> {
+    pub body: &'a [u8],
+}
+
+impl View for MultiArith<'_> {
+    type V = SpecMultiArith;
+
+    open spec fn view(&self) -> Self::V {
+        SpecMultiArith {
+            body: self.body@,
+        }
+    }
+}
+pub type MultiArithInner<'a> = &'a [u8];
+
+pub type MultiArithInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a MultiArith<'a>> for MultiArithInnerRef<'a> {
+    fn ex_from(m: &'a MultiArith) -> MultiArithInnerRef<'a> {
+        &m.body
+    }
+}
+
+impl<'a> From<MultiArithInner<'a>> for MultiArith<'a> {
+    fn ex_from(m: MultiArithInner) -> MultiArith {
+        let body = m;
+        MultiArith { body }
+    }
+}
+
+pub struct MultiArithMapper;
+impl View for MultiArithMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for MultiArithMapper {
+    type Src = SpecMultiArithInner;
+    type Dst = SpecMultiArith;
+}
+impl SpecIsoProof for MultiArithMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for MultiArithMapper {
+    type Src = MultiArithInner<'a>;
+    type Dst = MultiArith<'a>;
+    type RefSrc = MultiArithInnerRef<'a>;
+}
+
+pub struct SpecMultiArithCombinator(pub SpecMultiArithCombinatorAlias);
+
+impl SpecCombinator for SpecMultiArithCombinator {
+    type Type = SpecMultiArith;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecMultiArithCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMultiArithCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecMultiArithCombinatorAlias = Mapped<bytes::Variable, MultiArithMapper>;
+
+pub struct MultiArithCombinator(pub MultiArithCombinatorAlias);
+
+impl View for MultiArithCombinator {
+    type V = SpecMultiArithCombinator;
+    open spec fn view(&self) -> Self::V { SpecMultiArithCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MultiArithCombinator {
+    type Type = MultiArith<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type MultiArithCombinatorAlias = Mapped<bytes::Variable, MultiArithMapper>;
+
+
+pub open spec fn spec_multi_arith(total: u32, hdr_len: u8) -> SpecMultiArithCombinator {
+    SpecMultiArithCombinator(
+    Mapped {
+        inner: bytes::Variable((((usize::spec_from(total) - usize::spec_from(hdr_len)) - 8)) as usize),
+        mapper: MultiArithMapper,
+    })
+}
+
+pub fn multi_arith<'a>(total: u32, hdr_len: u8) -> (o: MultiArithCombinator)
+    requires
+        ((total) >= 263 && (total) <= 4294967295),
+        ((hdr_len) >= 0 && (hdr_len) <= 255),
+
+    ensures o@ == spec_multi_arith(total@, hdr_len@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = MultiArithCombinator(
+    Mapped {
+        inner: bytes::Variable((((usize::ex_from(total) - usize::ex_from(hdr_len)) - 8)) as usize),
+        mapper: MultiArithMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_multi_arith(total@, hdr_len@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_multi_arith<'a>(input: &'a [u8], total: u32, hdr_len: u8) -> (res: PResult<<MultiArithCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((total) >= 263 && (total) <= 4294967295),
+        ((hdr_len) >= 0 && (hdr_len) <= 255),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_multi_arith(total@, hdr_len@).spec_parse(input@) == Some((n as int, v@)),
+        spec_multi_arith(total@, hdr_len@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_multi_arith(total@, hdr_len@).spec_parse(input@) is None,
+        spec_multi_arith(total@, hdr_len@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = multi_arith( total, hdr_len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_multi_arith<'a>(v: <MultiArithCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, total: u32, hdr_len: u8) -> (o: SResult<usize, SerializeError>)
+    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),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_multi_arith(total@, hdr_len@).spec_serialize(v@).len() <= usize::MAX,
+        ((total) >= 263 && (total) <= 4294967295),
+        ((hdr_len) >= 0 && (hdr_len) <= 255),
+
+    ensures
+        serialize_len == spec_multi_arith(total@, hdr_len@).spec_serialize(v@).len(),
+{
+    let combinator = multi_arith( total, hdr_len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecSizeArith {
+    pub bytes: Seq<u8>,
+}
+
+pub type SpecSizeArithInner = Seq<u8>;
+
+
+impl SpecFrom<SpecSizeArith> for SpecSizeArithInner {
+    open spec fn spec_from(m: SpecSizeArith) -> SpecSizeArithInner {
+        m.bytes
+    }
+}
+
+impl SpecFrom<SpecSizeArithInner> for SpecSizeArith {
+    open spec fn spec_from(m: SpecSizeArithInner) -> SpecSizeArith {
+        let bytes = m;
+        SpecSizeArith { bytes }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct SizeArith<'a> {
+    pub bytes: &'a [u8],
+}
+
+impl View for SizeArith<'_> {
+    type V = SpecSizeArith;
+
+    open spec fn view(&self) -> Self::V {
+        SpecSizeArith {
+            bytes: self.bytes@,
+        }
+    }
+}
+pub type SizeArithInner<'a> = &'a [u8];
+
+pub type SizeArithInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a SizeArith<'a>> for SizeArithInnerRef<'a> {
+    fn ex_from(m: &'a SizeArith) -> SizeArithInnerRef<'a> {
+        &m.bytes
+    }
+}
+
+impl<'a> From<SizeArithInner<'a>> for SizeArith<'a> {
+    fn ex_from(m: SizeArithInner) -> SizeArith {
+        let bytes = m;
+        SizeArith { bytes }
+    }
+}
+
+pub struct SizeArithMapper;
+impl View for SizeArithMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for SizeArithMapper {
+    type Src = SpecSizeArithInner;
+    type Dst = SpecSizeArith;
+}
+impl SpecIsoProof for SizeArithMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for SizeArithMapper {
+    type Src = SizeArithInner<'a>;
+    type Dst = SizeArith<'a>;
+    type RefSrc = SizeArithInnerRef<'a>;
+}
+
+pub struct SpecSizeArithCombinator(pub SpecSizeArithCombinatorAlias);
+
+impl SpecCombinator for SpecSizeArithCombinator {
+    type Type = SpecSizeArith;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecSizeArithCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSizeArithCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecSizeArithCombinatorAlias = Mapped<bytes::Fixed<4>, SizeArithMapper>;
+
+pub struct SizeArithCombinator(pub SizeArithCombinatorAlias);
+
+impl View for SizeArithCombinator {
+    type V = SpecSizeArithCombinator;
+    open spec fn view(&self) -> Self::V { SpecSizeArithCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SizeArithCombinator {
+    type Type = SizeArith<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type SizeArithCombinatorAlias = Mapped<bytes::Fixed<4>, SizeArithMapper>;
+
+
+pub open spec fn spec_size_arith() -> SpecSizeArithCombinator {
+    SpecSizeArithCombinator(
+    Mapped {
+        inner: bytes::Fixed::<4>,
+        mapper: SizeArithMapper,
+    })
+}
+
+                
+pub fn size_arith<'a>() -> (o: SizeArithCombinator)
+    ensures o@ == spec_size_arith(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = SizeArithCombinator(
+    Mapped {
+        inner: bytes::Fixed::<4>,
+        mapper: SizeArithMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_size_arith()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_size_arith<'a>(input: &'a [u8]) -> (res: PResult<<SizeArithCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_size_arith().spec_parse(input@) == Some((n as int, v@)),
+        spec_size_arith().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_size_arith().spec_parse(input@) is None,
+        spec_size_arith().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = size_arith();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_size_arith<'a>(v: <SizeArithCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_size_arith().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_size_arith().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_size_arith().spec_serialize(v@).len(),
+{
+    let combinator = size_arith();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecPayloadWithHeader {
+    pub data: Seq<u8>,
+}
+
+pub type SpecPayloadWithHeaderInner = Seq<u8>;
+
+
+impl SpecFrom<SpecPayloadWithHeader> for SpecPayloadWithHeaderInner {
+    open spec fn spec_from(m: SpecPayloadWithHeader) -> SpecPayloadWithHeaderInner {
+        m.data
+    }
+}
+
+impl SpecFrom<SpecPayloadWithHeaderInner> for SpecPayloadWithHeader {
+    open spec fn spec_from(m: SpecPayloadWithHeaderInner) -> SpecPayloadWithHeader {
+        let data = m;
+        SpecPayloadWithHeader { data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct PayloadWithHeader<'a> {
+    pub data: &'a [u8],
+}
+
+impl View for PayloadWithHeader<'_> {
+    type V = SpecPayloadWithHeader;
+
+    open spec fn view(&self) -> Self::V {
+        SpecPayloadWithHeader {
+            data: self.data@,
+        }
+    }
+}
+pub type PayloadWithHeaderInner<'a> = &'a [u8];
+
+pub type PayloadWithHeaderInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a PayloadWithHeader<'a>> for PayloadWithHeaderInnerRef<'a> {
+    fn ex_from(m: &'a PayloadWithHeader) -> PayloadWithHeaderInnerRef<'a> {
+        &m.data
+    }
+}
+
+impl<'a> From<PayloadWithHeaderInner<'a>> for PayloadWithHeader<'a> {
+    fn ex_from(m: PayloadWithHeaderInner) -> PayloadWithHeader {
+        let data = m;
+        PayloadWithHeader { data }
+    }
+}
+
+pub struct PayloadWithHeaderMapper;
+impl View for PayloadWithHeaderMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for PayloadWithHeaderMapper {
+    type Src = SpecPayloadWithHeaderInner;
+    type Dst = SpecPayloadWithHeader;
+}
+impl SpecIsoProof for PayloadWithHeaderMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for PayloadWithHeaderMapper {
+    type Src = PayloadWithHeaderInner<'a>;
+    type Dst = PayloadWithHeader<'a>;
+    type RefSrc = PayloadWithHeaderInnerRef<'a>;
+}
+
+pub struct SpecPayloadWithHeaderCombinator(pub SpecPayloadWithHeaderCombinatorAlias);
+
+impl SpecCombinator for SpecPayloadWithHeaderCombinator {
+    type Type = SpecPayloadWithHeader;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecPayloadWithHeaderCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPayloadWithHeaderCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecPayloadWithHeaderCombinatorAlias = Mapped<bytes::Variable, PayloadWithHeaderMapper>;
+
+pub struct PayloadWithHeaderCombinator(pub PayloadWithHeaderCombinatorAlias);
+
+impl View for PayloadWithHeaderCombinator {
+    type V = SpecPayloadWithHeaderCombinator;
+    open spec fn view(&self) -> Self::V { SpecPayloadWithHeaderCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PayloadWithHeaderCombinator {
+    type Type = PayloadWithHeader<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type PayloadWithHeaderCombinatorAlias = Mapped<bytes::Variable, PayloadWithHeaderMapper>;
+
+
+pub open spec fn spec_payload_with_header(hdr: SpecHeader) -> SpecPayloadWithHeaderCombinator {
+    SpecPayloadWithHeaderCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::spec_from(hdr.len) - 3)) as usize),
+        mapper: PayloadWithHeaderMapper,
+    })
+}
+
+pub fn payload_with_header<'a>(hdr: Header) -> (o: PayloadWithHeaderCombinator)
+    requires
+        spec_header().wf(hdr@),
+
+    ensures o@ == spec_payload_with_header(hdr@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = PayloadWithHeaderCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::ex_from(hdr.len) - 3)) as usize),
+        mapper: PayloadWithHeaderMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_payload_with_header(hdr@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_payload_with_header<'a>(input: &'a [u8], hdr: Header) -> (res: PResult<<PayloadWithHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_header().wf(hdr@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_payload_with_header(hdr@).spec_parse(input@) == Some((n as int, v@)),
+        spec_payload_with_header(hdr@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_payload_with_header(hdr@).spec_parse(input@) is None,
+        spec_payload_with_header(hdr@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = payload_with_header( hdr );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_payload_with_header<'a>(v: <PayloadWithHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, hdr: Header) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_payload_with_header(hdr@).wf(v@),
+        spec_header().wf(hdr@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_payload_with_header(hdr@).spec_serialize(v@).len() <= usize::MAX,
+        spec_header().wf(hdr@),
+
+    ensures
+        serialize_len == spec_payload_with_header(hdr@).spec_serialize(v@).len(),
+{
+    let combinator = payload_with_header( hdr );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecMixedConst {
+    pub data: Seq<u8>,
+}
+
+pub type SpecMixedConstInner = Seq<u8>;
+
+
+impl SpecFrom<SpecMixedConst> for SpecMixedConstInner {
+    open spec fn spec_from(m: SpecMixedConst) -> SpecMixedConstInner {
+        m.data
+    }
+}
+
+impl SpecFrom<SpecMixedConstInner> for SpecMixedConst {
+    open spec fn spec_from(m: SpecMixedConstInner) -> SpecMixedConst {
+        let data = m;
+        SpecMixedConst { data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct MixedConst<'a> {
+    pub data: &'a [u8],
+}
+
+impl View for MixedConst<'_> {
+    type V = SpecMixedConst;
+
+    open spec fn view(&self) -> Self::V {
+        SpecMixedConst {
+            data: self.data@,
+        }
+    }
+}
+pub type MixedConstInner<'a> = &'a [u8];
+
+pub type MixedConstInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a MixedConst<'a>> for MixedConstInnerRef<'a> {
+    fn ex_from(m: &'a MixedConst) -> MixedConstInnerRef<'a> {
+        &m.data
+    }
+}
+
+impl<'a> From<MixedConstInner<'a>> for MixedConst<'a> {
+    fn ex_from(m: MixedConstInner) -> MixedConst {
+        let data = m;
+        MixedConst { data }
+    }
+}
+
+pub struct MixedConstMapper;
+impl View for MixedConstMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for MixedConstMapper {
+    type Src = SpecMixedConstInner;
+    type Dst = SpecMixedConst;
+}
+impl SpecIsoProof for MixedConstMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for MixedConstMapper {
+    type Src = MixedConstInner<'a>;
+    type Dst = MixedConst<'a>;
+    type RefSrc = MixedConstInnerRef<'a>;
+}
+
+pub struct SpecMixedConstCombinator(pub SpecMixedConstCombinatorAlias);
+
+impl SpecCombinator for SpecMixedConstCombinator {
+    type Type = SpecMixedConst;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecMixedConstCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMixedConstCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecMixedConstCombinatorAlias = Mapped<bytes::Variable, MixedConstMapper>;
+
+pub struct MixedConstCombinator(pub MixedConstCombinatorAlias);
+
+impl View for MixedConstCombinator {
+    type V = SpecMixedConstCombinator;
+    open spec fn view(&self) -> Self::V { SpecMixedConstCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MixedConstCombinator {
+    type Type = MixedConst<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type MixedConstCombinatorAlias = Mapped<bytes::Variable, MixedConstMapper>;
+
+
+pub open spec fn spec_mixed_const(len: u16) -> SpecMixedConstCombinator {
+    SpecMixedConstCombinator(
+    Mapped {
+        inner: bytes::Variable((((usize::spec_from(len) - 4) + 2)) as usize),
+        mapper: MixedConstMapper,
+    })
+}
+
+pub fn mixed_const<'a>(len: u16) -> (o: MixedConstCombinator)
+    requires
+        ((len) >= 4 && (len) <= 65535),
+
+    ensures o@ == spec_mixed_const(len@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = MixedConstCombinator(
+    Mapped {
+        inner: bytes::Variable((((usize::ex_from(len) - 4) + 2)) as usize),
+        mapper: MixedConstMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_mixed_const(len@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_mixed_const<'a>(input: &'a [u8], len: u16) -> (res: PResult<<MixedConstCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((len) >= 4 && (len) <= 65535),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_mixed_const(len@).spec_parse(input@) == Some((n as int, v@)),
+        spec_mixed_const(len@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_mixed_const(len@).spec_parse(input@) is None,
+        spec_mixed_const(len@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = mixed_const( len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_mixed_const<'a>(v: <MixedConstCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, len: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_mixed_const(len@).wf(v@),
+        ((len) >= 4 && (len) <= 65535),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_mixed_const(len@).spec_serialize(v@).len() <= usize::MAX,
+        ((len) >= 4 && (len) <= 65535),
+
+    ensures
+        serialize_len == spec_mixed_const(len@).spec_serialize(v@).len(),
+{
+    let combinator = mixed_const( len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub type SpecChoiceTag = Seq<u8>;
+pub type ChoiceTag<'a> = &'a [u8];
+pub type ChoiceTagRef<'a> = &'a &'a [u8];
+
+
+pub struct SpecChoiceTagCombinator(pub SpecChoiceTagCombinatorAlias);
+
+impl SpecCombinator for SpecChoiceTagCombinator {
+    type Type = SpecChoiceTag;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecChoiceTagCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecChoiceTagCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecChoiceTagCombinatorAlias = bytes::Fixed<2>;
+
+pub struct ChoiceTagCombinator(pub ChoiceTagCombinatorAlias);
+
+impl View for ChoiceTagCombinator {
+    type V = SpecChoiceTagCombinator;
+    open spec fn view(&self) -> Self::V { SpecChoiceTagCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceTagCombinator {
+    type Type = ChoiceTag<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ChoiceTagCombinatorAlias = bytes::Fixed<2>;
+
+
+pub open spec fn spec_choice_tag() -> SpecChoiceTagCombinator {
+    SpecChoiceTagCombinator(bytes::Fixed::<2>)
+}
+
+                
+pub fn choice_tag<'a>() -> (o: ChoiceTagCombinator)
+    ensures o@ == spec_choice_tag(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ChoiceTagCombinator(bytes::Fixed::<2>);
+    // assert({
+    //     &&& combinator@ == spec_choice_tag()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_choice_tag<'a>(input: &'a [u8]) -> (res: PResult<<ChoiceTagCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_choice_tag().spec_parse(input@) == Some((n as int, v@)),
+        spec_choice_tag().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_choice_tag().spec_parse(input@) is None,
+        spec_choice_tag().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = choice_tag();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_choice_tag<'a>(v: <ChoiceTagCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_choice_tag().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_choice_tag().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_choice_tag().spec_serialize(v@).len(),
+{
+    let combinator = choice_tag();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecNamedSize {
+    pub bytes: Seq<u8>,
+}
+
+pub type SpecNamedSizeInner = Seq<u8>;
+
+
+impl SpecFrom<SpecNamedSize> for SpecNamedSizeInner {
+    open spec fn spec_from(m: SpecNamedSize) -> SpecNamedSizeInner {
+        m.bytes
+    }
+}
+
+impl SpecFrom<SpecNamedSizeInner> for SpecNamedSize {
+    open spec fn spec_from(m: SpecNamedSizeInner) -> SpecNamedSize {
+        let bytes = m;
+        SpecNamedSize { bytes }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct NamedSize<'a> {
+    pub bytes: &'a [u8],
+}
+
+impl View for NamedSize<'_> {
+    type V = SpecNamedSize;
+
+    open spec fn view(&self) -> Self::V {
+        SpecNamedSize {
+            bytes: self.bytes@,
+        }
+    }
+}
+pub type NamedSizeInner<'a> = &'a [u8];
+
+pub type NamedSizeInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a NamedSize<'a>> for NamedSizeInnerRef<'a> {
+    fn ex_from(m: &'a NamedSize) -> NamedSizeInnerRef<'a> {
+        &m.bytes
+    }
+}
+
+impl<'a> From<NamedSizeInner<'a>> for NamedSize<'a> {
+    fn ex_from(m: NamedSizeInner) -> NamedSize {
+        let bytes = m;
+        NamedSize { bytes }
+    }
+}
+
+pub struct NamedSizeMapper;
+impl View for NamedSizeMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for NamedSizeMapper {
+    type Src = SpecNamedSizeInner;
+    type Dst = SpecNamedSize;
+}
+impl SpecIsoProof for NamedSizeMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for NamedSizeMapper {
+    type Src = NamedSizeInner<'a>;
+    type Dst = NamedSize<'a>;
+    type RefSrc = NamedSizeInnerRef<'a>;
+}
+
+pub struct SpecNamedSizeCombinator(pub SpecNamedSizeCombinatorAlias);
+
+impl SpecCombinator for SpecNamedSizeCombinator {
+    type Type = SpecNamedSize;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecNamedSizeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNamedSizeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecNamedSizeCombinatorAlias = Mapped<bytes::Fixed<3>, NamedSizeMapper>;
+
+pub struct NamedSizeCombinator(pub NamedSizeCombinatorAlias);
+
+impl View for NamedSizeCombinator {
+    type V = SpecNamedSizeCombinator;
+    open spec fn view(&self) -> Self::V { SpecNamedSizeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NamedSizeCombinator {
+    type Type = NamedSize<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type NamedSizeCombinatorAlias = Mapped<bytes::Fixed<3>, NamedSizeMapper>;
+
+
+pub open spec fn spec_named_size() -> SpecNamedSizeCombinator {
+    SpecNamedSizeCombinator(
+    Mapped {
+        inner: bytes::Fixed::<3>,
+        mapper: NamedSizeMapper,
+    })
+}
+
+                
+pub fn named_size<'a>() -> (o: NamedSizeCombinator)
+    ensures o@ == spec_named_size(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = NamedSizeCombinator(
+    Mapped {
+        inner: bytes::Fixed::<3>,
+        mapper: NamedSizeMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_named_size()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_named_size<'a>(input: &'a [u8]) -> (res: PResult<<NamedSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_named_size().spec_parse(input@) == Some((n as int, v@)),
+        spec_named_size().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_named_size().spec_parse(input@) is None,
+        spec_named_size().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = named_size();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_named_size<'a>(v: <NamedSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_named_size().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_named_size().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_named_size().spec_serialize(v@).len(),
+{
+    let combinator = named_size();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecChoiceFormatSize {
+    pub bytes: Seq<u8>,
+}
+
+pub type SpecChoiceFormatSizeInner = Seq<u8>;
+
+
+impl SpecFrom<SpecChoiceFormatSize> for SpecChoiceFormatSizeInner {
+    open spec fn spec_from(m: SpecChoiceFormatSize) -> SpecChoiceFormatSizeInner {
+        m.bytes
+    }
+}
+
+impl SpecFrom<SpecChoiceFormatSizeInner> for SpecChoiceFormatSize {
+    open spec fn spec_from(m: SpecChoiceFormatSizeInner) -> SpecChoiceFormatSize {
+        let bytes = m;
+        SpecChoiceFormatSize { bytes }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct ChoiceFormatSize<'a> {
+    pub bytes: &'a [u8],
+}
+
+impl View for ChoiceFormatSize<'_> {
+    type V = SpecChoiceFormatSize;
+
+    open spec fn view(&self) -> Self::V {
+        SpecChoiceFormatSize {
+            bytes: self.bytes@,
+        }
+    }
+}
+pub type ChoiceFormatSizeInner<'a> = &'a [u8];
+
+pub type ChoiceFormatSizeInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a ChoiceFormatSize<'a>> for ChoiceFormatSizeInnerRef<'a> {
+    fn ex_from(m: &'a ChoiceFormatSize) -> ChoiceFormatSizeInnerRef<'a> {
+        &m.bytes
+    }
+}
+
+impl<'a> From<ChoiceFormatSizeInner<'a>> for ChoiceFormatSize<'a> {
+    fn ex_from(m: ChoiceFormatSizeInner) -> ChoiceFormatSize {
+        let bytes = m;
+        ChoiceFormatSize { bytes }
+    }
+}
+
+pub struct ChoiceFormatSizeMapper;
+impl View for ChoiceFormatSizeMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ChoiceFormatSizeMapper {
+    type Src = SpecChoiceFormatSizeInner;
+    type Dst = SpecChoiceFormatSize;
+}
+impl SpecIsoProof for ChoiceFormatSizeMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ChoiceFormatSizeMapper {
+    type Src = ChoiceFormatSizeInner<'a>;
+    type Dst = ChoiceFormatSize<'a>;
+    type RefSrc = ChoiceFormatSizeInnerRef<'a>;
+}
+
+pub struct SpecChoiceFormatSizeCombinator(pub SpecChoiceFormatSizeCombinatorAlias);
+
+impl SpecCombinator for SpecChoiceFormatSizeCombinator {
+    type Type = SpecChoiceFormatSize;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecChoiceFormatSizeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecChoiceFormatSizeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecChoiceFormatSizeCombinatorAlias = Mapped<bytes::Fixed<2>, ChoiceFormatSizeMapper>;
+
+pub struct ChoiceFormatSizeCombinator(pub ChoiceFormatSizeCombinatorAlias);
+
+impl View for ChoiceFormatSizeCombinator {
+    type V = SpecChoiceFormatSizeCombinator;
+    open spec fn view(&self) -> Self::V { SpecChoiceFormatSizeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceFormatSizeCombinator {
+    type Type = ChoiceFormatSize<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ChoiceFormatSizeCombinatorAlias = Mapped<bytes::Fixed<2>, ChoiceFormatSizeMapper>;
+
+
+pub open spec fn spec_choice_format_size() -> SpecChoiceFormatSizeCombinator {
+    SpecChoiceFormatSizeCombinator(
+    Mapped {
+        inner: bytes::Fixed::<2>,
+        mapper: ChoiceFormatSizeMapper,
+    })
+}
+
+                
+pub fn choice_format_size<'a>() -> (o: ChoiceFormatSizeCombinator)
+    ensures o@ == spec_choice_format_size(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ChoiceFormatSizeCombinator(
+    Mapped {
+        inner: bytes::Fixed::<2>,
+        mapper: ChoiceFormatSizeMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_choice_format_size()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_choice_format_size<'a>(input: &'a [u8]) -> (res: PResult<<ChoiceFormatSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_choice_format_size().spec_parse(input@) == Some((n as int, v@)),
+        spec_choice_format_size().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_choice_format_size().spec_parse(input@) is None,
+        spec_choice_format_size().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = choice_format_size();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_choice_format_size<'a>(v: <ChoiceFormatSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_choice_format_size().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_choice_format_size().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_choice_format_size().spec_serialize(v@).len(),
+{
+    let combinator = choice_format_size();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub type SpecHeaderBytes = SpecHeader;
+pub type HeaderBytes = Header;
+pub type HeaderBytesRef<'a> = &'a Header;
+
+
+pub struct SpecHeaderBytesCombinator(pub SpecHeaderBytesCombinatorAlias);
+
+impl SpecCombinator for SpecHeaderBytesCombinator {
+    type Type = SpecHeaderBytes;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecHeaderBytesCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHeaderBytesCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecHeaderBytesCombinatorAlias = AndThen<bytes::Variable, SpecHeaderCombinator>;
+
+pub struct HeaderBytesCombinator(pub HeaderBytesCombinatorAlias);
+
+impl View for HeaderBytesCombinator {
+    type V = SpecHeaderBytesCombinator;
+    open spec fn view(&self) -> Self::V { SpecHeaderBytesCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeaderBytesCombinator {
+    type Type = HeaderBytes;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type HeaderBytesCombinatorAlias = AndThen<bytes::Variable, HeaderCombinator>;
+
+
+pub open spec fn spec_header_bytes() -> SpecHeaderBytesCombinator {
+    SpecHeaderBytesCombinator(AndThen(bytes::Variable(3), spec_header()))
+}
+
+                
+pub fn header_bytes<'a>() -> (o: HeaderBytesCombinator)
+    ensures o@ == spec_header_bytes(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = HeaderBytesCombinator(AndThen(bytes::Variable(3), header()));
+    // assert({
+    //     &&& combinator@ == spec_header_bytes()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_header_bytes<'a>(input: &'a [u8]) -> (res: PResult<<HeaderBytesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_header_bytes().spec_parse(input@) == Some((n as int, v@)),
+        spec_header_bytes().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_header_bytes().spec_parse(input@) is None,
+        spec_header_bytes().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = header_bytes();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_header_bytes<'a>(v: <HeaderBytesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_header_bytes().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_header_bytes().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_header_bytes().spec_serialize(v@).len(),
+{
+    let combinator = header_bytes();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecMultiply {
+    pub items: Seq<u8>,
+}
+
+pub type SpecMultiplyInner = Seq<u8>;
+
+
+impl SpecFrom<SpecMultiply> for SpecMultiplyInner {
+    open spec fn spec_from(m: SpecMultiply) -> SpecMultiplyInner {
+        m.items
+    }
+}
+
+impl SpecFrom<SpecMultiplyInner> for SpecMultiply {
+    open spec fn spec_from(m: SpecMultiplyInner) -> SpecMultiply {
+        let items = m;
+        SpecMultiply { items }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Multiply<'a> {
+    pub items: &'a [u8],
+}
+
+impl View for Multiply<'_> {
+    type V = SpecMultiply;
+
+    open spec fn view(&self) -> Self::V {
+        SpecMultiply {
+            items: self.items@,
+        }
+    }
+}
+pub type MultiplyInner<'a> = &'a [u8];
+
+pub type MultiplyInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a Multiply<'a>> for MultiplyInnerRef<'a> {
+    fn ex_from(m: &'a Multiply) -> MultiplyInnerRef<'a> {
+        &m.items
+    }
+}
+
+impl<'a> From<MultiplyInner<'a>> for Multiply<'a> {
+    fn ex_from(m: MultiplyInner) -> Multiply {
+        let items = m;
+        Multiply { items }
+    }
+}
+
+pub struct MultiplyMapper;
+impl View for MultiplyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for MultiplyMapper {
+    type Src = SpecMultiplyInner;
+    type Dst = SpecMultiply;
+}
+impl SpecIsoProof for MultiplyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for MultiplyMapper {
+    type Src = MultiplyInner<'a>;
+    type Dst = Multiply<'a>;
+    type RefSrc = MultiplyInnerRef<'a>;
+}
+
+pub struct SpecMultiplyCombinator(pub SpecMultiplyCombinatorAlias);
+
+impl SpecCombinator for SpecMultiplyCombinator {
+    type Type = SpecMultiply;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecMultiplyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMultiplyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecMultiplyCombinatorAlias = Mapped<bytes::Variable, MultiplyMapper>;
+
+pub struct MultiplyCombinator(pub MultiplyCombinatorAlias);
+
+impl View for MultiplyCombinator {
+    type V = SpecMultiplyCombinator;
+    open spec fn view(&self) -> Self::V { SpecMultiplyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MultiplyCombinator {
+    type Type = Multiply<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type MultiplyCombinatorAlias = Mapped<bytes::Variable, MultiplyMapper>;
+
+
+pub open spec fn spec_multiply(count: u16, size: u8) -> SpecMultiplyCombinator {
+    SpecMultiplyCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::spec_from(count) * usize::spec_from(size))) as usize),
+        mapper: MultiplyMapper,
+    })
+}
+
+pub fn multiply<'a>(count: u16, size: u8) -> (o: MultiplyCombinator)
+    requires
+        ((size) == 1),
+
+    ensures o@ == spec_multiply(count@, size@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = MultiplyCombinator(
+    Mapped {
+        inner: bytes::Variable(((usize::ex_from(count) * usize::ex_from(size))) as usize),
+        mapper: MultiplyMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_multiply(count@, size@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_multiply<'a>(input: &'a [u8], count: u16, size: u8) -> (res: PResult<<MultiplyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((size) == 1),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_multiply(count@, size@).spec_parse(input@) == Some((n as int, v@)),
+        spec_multiply(count@, size@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_multiply(count@, size@).spec_parse(input@) is None,
+        spec_multiply(count@, size@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = multiply( count, size );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_multiply<'a>(v: <MultiplyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, count: u16, size: u8) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_multiply(count@, size@).wf(v@),
+        ((size) == 1),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_multiply(count@, size@).spec_serialize(v@).len() <= usize::MAX,
+        ((size) == 1),
+
+    ensures
+        serialize_len == spec_multiply(count@, size@).spec_serialize(v@).len(),
+{
+    let combinator = multiply( count, size );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub enum SpecChoiceArraysFoldedBody {
+    Variant0(u8),
+    Variant1(u16),
+}
+
+pub type SpecChoiceArraysFoldedBodyInner = Either<u8, u16>;
+
+impl SpecFrom<SpecChoiceArraysFoldedBody> for SpecChoiceArraysFoldedBodyInner {
+    open spec fn spec_from(m: SpecChoiceArraysFoldedBody) -> SpecChoiceArraysFoldedBodyInner {
+        match m {
+            SpecChoiceArraysFoldedBody::Variant0(m) => Either::Left(m),
+            SpecChoiceArraysFoldedBody::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecChoiceArraysFoldedBodyInner> for SpecChoiceArraysFoldedBody {
+    open spec fn spec_from(m: SpecChoiceArraysFoldedBodyInner) -> SpecChoiceArraysFoldedBody {
+        match m {
+            Either::Left(m) => SpecChoiceArraysFoldedBody::Variant0(m),
+            Either::Right(m) => SpecChoiceArraysFoldedBody::Variant1(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ChoiceArraysFoldedBody {
+    Variant0(u8),
+    Variant1(u16),
+}
+
+pub type ChoiceArraysFoldedBodyInner = Either<u8, u16>;
+
+pub type ChoiceArraysFoldedBodyInnerRef<'a> = Either<&'a u8, &'a u16>;
+
+
+impl View for ChoiceArraysFoldedBody {
+    type V = SpecChoiceArraysFoldedBody;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            ChoiceArraysFoldedBody::Variant0(m) => SpecChoiceArraysFoldedBody::Variant0(m@),
+            ChoiceArraysFoldedBody::Variant1(m) => SpecChoiceArraysFoldedBody::Variant1(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a ChoiceArraysFoldedBody> for ChoiceArraysFoldedBodyInnerRef<'a> {
+    fn ex_from(m: &'a ChoiceArraysFoldedBody) -> ChoiceArraysFoldedBodyInnerRef<'a> {
+        match m {
+            ChoiceArraysFoldedBody::Variant0(m) => Either::Left(m),
+            ChoiceArraysFoldedBody::Variant1(m) => Either::Right(m),
+        }
+    }
+
+}
+
+impl From<ChoiceArraysFoldedBodyInner> for ChoiceArraysFoldedBody {
+    fn ex_from(m: ChoiceArraysFoldedBodyInner) -> ChoiceArraysFoldedBody {
+        match m {
+            Either::Left(m) => ChoiceArraysFoldedBody::Variant0(m),
+            Either::Right(m) => ChoiceArraysFoldedBody::Variant1(m),
+        }
+    }
+    
+}
+
+
+pub struct ChoiceArraysFoldedBodyMapper;
+impl View for ChoiceArraysFoldedBodyMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ChoiceArraysFoldedBodyMapper {
+    type Src = SpecChoiceArraysFoldedBodyInner;
+    type Dst = SpecChoiceArraysFoldedBody;
+}
+impl SpecIsoProof for ChoiceArraysFoldedBodyMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ChoiceArraysFoldedBodyMapper {
+    type Src = ChoiceArraysFoldedBodyInner;
+    type Dst = ChoiceArraysFoldedBody;
+    type RefSrc = ChoiceArraysFoldedBodyInnerRef<'a>;
+}
+
+type SpecChoiceArraysFoldedBodyCombinatorAlias1 = Choice<Cond<U8>, Cond<U16Le>>;
+pub struct SpecChoiceArraysFoldedBodyCombinator(pub SpecChoiceArraysFoldedBodyCombinatorAlias);
+
+impl SpecCombinator for SpecChoiceArraysFoldedBodyCombinator {
+    type Type = SpecChoiceArraysFoldedBody;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecChoiceArraysFoldedBodyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecChoiceArraysFoldedBodyCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecChoiceArraysFoldedBodyCombinatorAlias = Mapped<SpecChoiceArraysFoldedBodyCombinatorAlias1, ChoiceArraysFoldedBodyMapper>;
+type ChoiceArraysFoldedBodyCombinatorAlias1 = Choice<Cond<U8>, Cond<U16Le>>;
+pub struct ChoiceArraysFoldedBodyCombinator1(pub ChoiceArraysFoldedBodyCombinatorAlias1);
+impl View for ChoiceArraysFoldedBodyCombinator1 {
+    type V = SpecChoiceArraysFoldedBodyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ChoiceArraysFoldedBodyCombinator1, ChoiceArraysFoldedBodyCombinatorAlias1);
+
+pub struct ChoiceArraysFoldedBodyCombinator(pub ChoiceArraysFoldedBodyCombinatorAlias);
+
+impl View for ChoiceArraysFoldedBodyCombinator {
+    type V = SpecChoiceArraysFoldedBodyCombinator;
+    open spec fn view(&self) -> Self::V { SpecChoiceArraysFoldedBodyCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceArraysFoldedBodyCombinator {
+    type Type = ChoiceArraysFoldedBody;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ChoiceArraysFoldedBodyCombinatorAlias = Mapped<ChoiceArraysFoldedBodyCombinator1, ChoiceArraysFoldedBodyMapper>;
+
+
+pub open spec fn spec_choice_arrays_folded_body(tag: SpecChoiceTag) -> SpecChoiceArraysFoldedBodyCombinator {
+    SpecChoiceArraysFoldedBodyCombinator(Mapped { inner: Choice(Cond { cond: tag == seq![0u8, 0u8], inner: U8 }, Cond { cond: tag == seq![1u8, 1u8], inner: U16Le }), mapper: ChoiceArraysFoldedBodyMapper })
+}
+
+pub fn choice_arrays_folded_body<'a>(tag: ChoiceTag) -> (o: ChoiceArraysFoldedBodyCombinator)
+
+    ensures o@ == spec_choice_arrays_folded_body(tag@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ChoiceArraysFoldedBodyCombinator(Mapped { inner: ChoiceArraysFoldedBodyCombinator1(Choice::new(Cond { cond: compare_slice(tag, [0u8, 0u8].as_slice()), inner: U8 }, Cond { cond: compare_slice(tag, [1u8, 1u8].as_slice()), inner: U16Le })), mapper: ChoiceArraysFoldedBodyMapper });
+    // assert({
+    //     &&& combinator@ == spec_choice_arrays_folded_body(tag@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_choice_arrays_folded_body<'a>(input: &'a [u8], tag: ChoiceTag) -> (res: PResult<<ChoiceArraysFoldedBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+
+    ensures
+        res matches Ok((n, v)) ==> spec_choice_arrays_folded_body(tag@).spec_parse(input@) == Some((n as int, v@)),
+        spec_choice_arrays_folded_body(tag@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_choice_arrays_folded_body(tag@).spec_parse(input@) is None,
+        spec_choice_arrays_folded_body(tag@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = choice_arrays_folded_body( tag );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_choice_arrays_folded_body<'a>(v: <ChoiceArraysFoldedBodyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, tag: ChoiceTag) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_choice_arrays_folded_body(tag@).wf(v@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_choice_arrays_folded_body(tag@).spec_serialize(v@).len() <= usize::MAX,
+
+    ensures
+        serialize_len == spec_choice_arrays_folded_body(tag@).spec_serialize(v@).len(),
+{
+    let combinator = choice_arrays_folded_body( tag );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecChoiceArraysFolded {
+    pub tag: SpecChoiceTag,
+    pub body: SpecChoiceArraysFoldedBody,
+}
+
+pub type SpecChoiceArraysFoldedInner = (SpecChoiceTag, SpecChoiceArraysFoldedBody);
+
+
+impl SpecFrom<SpecChoiceArraysFolded> for SpecChoiceArraysFoldedInner {
+    open spec fn spec_from(m: SpecChoiceArraysFolded) -> SpecChoiceArraysFoldedInner {
+        (m.tag, m.body)
+    }
+}
+
+impl SpecFrom<SpecChoiceArraysFoldedInner> for SpecChoiceArraysFolded {
+    open spec fn spec_from(m: SpecChoiceArraysFoldedInner) -> SpecChoiceArraysFolded {
+        let (tag, body) = m;
+        SpecChoiceArraysFolded { tag, body }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct ChoiceArraysFolded<'a> {
+    pub tag: ChoiceTag<'a>,
+    pub body: ChoiceArraysFoldedBody,
+}
+
+impl View for ChoiceArraysFolded<'_> {
+    type V = SpecChoiceArraysFolded;
+
+    open spec fn view(&self) -> Self::V {
+        SpecChoiceArraysFolded {
+            tag: self.tag@,
+            body: self.body@,
+        }
+    }
+}
+pub type ChoiceArraysFoldedInner<'a> = (ChoiceTag<'a>, ChoiceArraysFoldedBody);
+
+pub type ChoiceArraysFoldedInnerRef<'a> = (&'a ChoiceTag<'a>, &'a ChoiceArraysFoldedBody);
+impl<'a> From<&'a ChoiceArraysFolded<'a>> for ChoiceArraysFoldedInnerRef<'a> {
+    fn ex_from(m: &'a ChoiceArraysFolded) -> ChoiceArraysFoldedInnerRef<'a> {
+        (&m.tag, &m.body)
+    }
+}
+
+impl<'a> From<ChoiceArraysFoldedInner<'a>> for ChoiceArraysFolded<'a> {
+    fn ex_from(m: ChoiceArraysFoldedInner) -> ChoiceArraysFolded {
+        let (tag, body) = m;
+        ChoiceArraysFolded { tag, body }
+    }
+}
+
+pub struct ChoiceArraysFoldedMapper;
+impl View for ChoiceArraysFoldedMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ChoiceArraysFoldedMapper {
+    type Src = SpecChoiceArraysFoldedInner;
+    type Dst = SpecChoiceArraysFolded;
+}
+impl SpecIsoProof for ChoiceArraysFoldedMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ChoiceArraysFoldedMapper {
+    type Src = ChoiceArraysFoldedInner<'a>;
+    type Dst = ChoiceArraysFolded<'a>;
+    type RefSrc = ChoiceArraysFoldedInnerRef<'a>;
+}
+
+pub struct SpecChoiceArraysFoldedCombinator(pub SpecChoiceArraysFoldedCombinatorAlias);
+
+impl SpecCombinator for SpecChoiceArraysFoldedCombinator {
+    type Type = SpecChoiceArraysFolded;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecChoiceArraysFoldedCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecChoiceArraysFoldedCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecChoiceArraysFoldedCombinatorAlias = Mapped<SpecPair<SpecChoiceTagCombinator, SpecChoiceArraysFoldedBodyCombinator>, ChoiceArraysFoldedMapper>;
+
+pub struct ChoiceArraysFoldedCombinator(pub ChoiceArraysFoldedCombinatorAlias);
+
+impl View for ChoiceArraysFoldedCombinator {
+    type V = SpecChoiceArraysFoldedCombinator;
+    open spec fn view(&self) -> Self::V { SpecChoiceArraysFoldedCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ChoiceArraysFoldedCombinator {
+    type Type = ChoiceArraysFolded<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ChoiceArraysFoldedCombinatorAlias = Mapped<Pair<ChoiceTagCombinator, ChoiceArraysFoldedBodyCombinator, ChoiceArraysFoldedCont0>, ChoiceArraysFoldedMapper>;
+
+
+pub open spec fn spec_choice_arrays_folded() -> SpecChoiceArraysFoldedCombinator {
+    SpecChoiceArraysFoldedCombinator(
+    Mapped {
+        inner: Pair::spec_new(spec_choice_tag(), |deps| spec_choice_arrays_folded_cont0(deps)),
+        mapper: ChoiceArraysFoldedMapper,
+    })
+}
+
+pub open spec fn spec_choice_arrays_folded_cont0(deps: SpecChoiceTag) -> SpecChoiceArraysFoldedBodyCombinator {
+    let tag = deps;
+    spec_choice_arrays_folded_body(tag)
+}
+
+impl View for ChoiceArraysFoldedCont0 {
+    type V = spec_fn(SpecChoiceTag) -> SpecChoiceArraysFoldedBodyCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: SpecChoiceTag| {
+            spec_choice_arrays_folded_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn choice_arrays_folded<'a>() -> (o: ChoiceArraysFoldedCombinator)
+    ensures o@ == spec_choice_arrays_folded(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ChoiceArraysFoldedCombinator(
+    Mapped {
+        inner: Pair::new(choice_tag(), ChoiceArraysFoldedCont0),
+        mapper: ChoiceArraysFoldedMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_choice_arrays_folded()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_choice_arrays_folded<'a>(input: &'a [u8]) -> (res: PResult<<ChoiceArraysFoldedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_choice_arrays_folded().spec_parse(input@) == Some((n as int, v@)),
+        spec_choice_arrays_folded().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_choice_arrays_folded().spec_parse(input@) is None,
+        spec_choice_arrays_folded().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = choice_arrays_folded();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_choice_arrays_folded<'a>(v: <ChoiceArraysFoldedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_choice_arrays_folded().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_choice_arrays_folded().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_choice_arrays_folded().spec_serialize(v@).len(),
+{
+    let combinator = choice_arrays_folded();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct ChoiceArraysFoldedCont0;
+type ChoiceArraysFoldedCont0Type<'a, 'b> = &'b ChoiceTag<'a>;
+type ChoiceArraysFoldedCont0SType<'a, 'x> = &'x ChoiceTag<'a>;
+type ChoiceArraysFoldedCont0Input<'a, 'b, 'x> = POrSType<ChoiceArraysFoldedCont0Type<'a, 'b>, ChoiceArraysFoldedCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ChoiceArraysFoldedCont0Input<'a, 'b, 'x>> for ChoiceArraysFoldedCont0 {
+    type Output = ChoiceArraysFoldedBodyCombinator;
+
+    open spec fn requires(&self, deps: ChoiceArraysFoldedCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_choice_tag()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: ChoiceArraysFoldedCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_choice_arrays_folded_cont0(deps@)
+    }
+
+    fn apply(&self, deps: ChoiceArraysFoldedCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let tag = deps;
+                let tag = *tag;
+                choice_arrays_folded_body(tag)
+            }
+            POrSType::S(deps) => {
+                let tag = deps;
+                let tag = *tag;
+                choice_arrays_folded_body(tag)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecParenExpr {
+    pub data: Seq<u8>,
+}
+
+pub type SpecParenExprInner = Seq<u8>;
+
+
+impl SpecFrom<SpecParenExpr> for SpecParenExprInner {
+    open spec fn spec_from(m: SpecParenExpr) -> SpecParenExprInner {
+        m.data
+    }
+}
+
+impl SpecFrom<SpecParenExprInner> for SpecParenExpr {
+    open spec fn spec_from(m: SpecParenExprInner) -> SpecParenExpr {
+        let data = m;
+        SpecParenExpr { data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct ParenExpr<'a> {
+    pub data: &'a [u8],
+}
+
+impl View for ParenExpr<'_> {
+    type V = SpecParenExpr;
+
+    open spec fn view(&self) -> Self::V {
+        SpecParenExpr {
+            data: self.data@,
+        }
+    }
+}
+pub type ParenExprInner<'a> = &'a [u8];
+
+pub type ParenExprInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a ParenExpr<'a>> for ParenExprInnerRef<'a> {
+    fn ex_from(m: &'a ParenExpr) -> ParenExprInnerRef<'a> {
+        &m.data
+    }
+}
+
+impl<'a> From<ParenExprInner<'a>> for ParenExpr<'a> {
+    fn ex_from(m: ParenExprInner) -> ParenExpr {
+        let data = m;
+        ParenExpr { data }
+    }
+}
+
+pub struct ParenExprMapper;
+impl View for ParenExprMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ParenExprMapper {
+    type Src = SpecParenExprInner;
+    type Dst = SpecParenExpr;
+}
+impl SpecIsoProof for ParenExprMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ParenExprMapper {
+    type Src = ParenExprInner<'a>;
+    type Dst = ParenExpr<'a>;
+    type RefSrc = ParenExprInnerRef<'a>;
+}
+
+pub struct SpecParenExprCombinator(pub SpecParenExprCombinatorAlias);
+
+impl SpecCombinator for SpecParenExprCombinator {
+    type Type = SpecParenExpr;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecParenExprCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecParenExprCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecParenExprCombinatorAlias = Mapped<bytes::Variable, ParenExprMapper>;
+
+pub struct ParenExprCombinator(pub ParenExprCombinatorAlias);
+
+impl View for ParenExprCombinator {
+    type V = SpecParenExprCombinator;
+    open spec fn view(&self) -> Self::V { SpecParenExprCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParenExprCombinator {
+    type Type = ParenExpr<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ParenExprCombinatorAlias = Mapped<bytes::Variable, ParenExprMapper>;
+
+
+pub open spec fn spec_paren_expr(a: u16, b: u8, c: u8) -> SpecParenExprCombinator {
+    SpecParenExprCombinator(
+    Mapped {
+        inner: bytes::Variable((((usize::spec_from(a) - usize::spec_from(b)) * usize::spec_from(c))) as usize),
+        mapper: ParenExprMapper,
+    })
+}
+
+pub fn paren_expr<'a>(a: u16, b: u8, c: u8) -> (o: ParenExprCombinator)
+    requires
+        ((a) >= 255 && (a) <= 65535),
+        ((b) >= 0 && (b) <= 255),
+        ((c) == 1),
+
+    ensures o@ == spec_paren_expr(a@, b@, c@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ParenExprCombinator(
+    Mapped {
+        inner: bytes::Variable((((usize::ex_from(a) - usize::ex_from(b)) * usize::ex_from(c))) as usize),
+        mapper: ParenExprMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_paren_expr(a@, b@, c@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_paren_expr<'a>(input: &'a [u8], a: u16, b: u8, c: u8) -> (res: PResult<<ParenExprCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((a) >= 255 && (a) <= 65535),
+        ((b) >= 0 && (b) <= 255),
+        ((c) == 1),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_paren_expr(a@, b@, c@).spec_parse(input@) == Some((n as int, v@)),
+        spec_paren_expr(a@, b@, c@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_paren_expr(a@, b@, c@).spec_parse(input@) is None,
+        spec_paren_expr(a@, b@, c@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = paren_expr( a, b, c );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_paren_expr<'a>(v: <ParenExprCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, a: u16, b: u8, c: u8) -> (o: SResult<usize, SerializeError>)
+    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),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_paren_expr(a@, b@, c@).spec_serialize(v@).len() <= usize::MAX,
+        ((a) >= 255 && (a) <= 65535),
+        ((b) >= 0 && (b) <= 255),
+        ((c) == 1),
+
+    ensures
+        serialize_len == spec_paren_expr(a@, b@, c@).spec_serialize(v@).len(),
+{
+    let combinator = paren_expr( a, b, c );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecReinterpretSize {
+    pub bytes: Seq<u8>,
+}
+
+pub type SpecReinterpretSizeInner = Seq<u8>;
+
+
+impl SpecFrom<SpecReinterpretSize> for SpecReinterpretSizeInner {
+    open spec fn spec_from(m: SpecReinterpretSize) -> SpecReinterpretSizeInner {
+        m.bytes
+    }
+}
+
+impl SpecFrom<SpecReinterpretSizeInner> for SpecReinterpretSize {
+    open spec fn spec_from(m: SpecReinterpretSizeInner) -> SpecReinterpretSize {
+        let bytes = m;
+        SpecReinterpretSize { bytes }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct ReinterpretSize<'a> {
+    pub bytes: &'a [u8],
+}
+
+impl View for ReinterpretSize<'_> {
+    type V = SpecReinterpretSize;
+
+    open spec fn view(&self) -> Self::V {
+        SpecReinterpretSize {
+            bytes: self.bytes@,
+        }
+    }
+}
+pub type ReinterpretSizeInner<'a> = &'a [u8];
+
+pub type ReinterpretSizeInnerRef<'a> = &'a &'a [u8];
+impl<'a> From<&'a ReinterpretSize<'a>> for ReinterpretSizeInnerRef<'a> {
+    fn ex_from(m: &'a ReinterpretSize) -> ReinterpretSizeInnerRef<'a> {
+        &m.bytes
+    }
+}
+
+impl<'a> From<ReinterpretSizeInner<'a>> for ReinterpretSize<'a> {
+    fn ex_from(m: ReinterpretSizeInner) -> ReinterpretSize {
+        let bytes = m;
+        ReinterpretSize { bytes }
+    }
+}
+
+pub struct ReinterpretSizeMapper;
+impl View for ReinterpretSizeMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ReinterpretSizeMapper {
+    type Src = SpecReinterpretSizeInner;
+    type Dst = SpecReinterpretSize;
+}
+impl SpecIsoProof for ReinterpretSizeMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ReinterpretSizeMapper {
+    type Src = ReinterpretSizeInner<'a>;
+    type Dst = ReinterpretSize<'a>;
+    type RefSrc = ReinterpretSizeInnerRef<'a>;
+}
+
+pub struct SpecReinterpretSizeCombinator(pub SpecReinterpretSizeCombinatorAlias);
+
+impl SpecCombinator for SpecReinterpretSizeCombinator {
+    type Type = SpecReinterpretSize;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecReinterpretSizeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecReinterpretSizeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecReinterpretSizeCombinatorAlias = Mapped<bytes::Fixed<3>, ReinterpretSizeMapper>;
+
+pub struct ReinterpretSizeCombinator(pub ReinterpretSizeCombinatorAlias);
+
+impl View for ReinterpretSizeCombinator {
+    type V = SpecReinterpretSizeCombinator;
+    open spec fn view(&self) -> Self::V { SpecReinterpretSizeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ReinterpretSizeCombinator {
+    type Type = ReinterpretSize<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ReinterpretSizeCombinatorAlias = Mapped<bytes::Fixed<3>, ReinterpretSizeMapper>;
+
+
+pub open spec fn spec_reinterpret_size() -> SpecReinterpretSizeCombinator {
+    SpecReinterpretSizeCombinator(
+    Mapped {
+        inner: bytes::Fixed::<3>,
+        mapper: ReinterpretSizeMapper,
+    })
+}
+
+                
+pub fn reinterpret_size<'a>() -> (o: ReinterpretSizeCombinator)
+    ensures o@ == spec_reinterpret_size(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ReinterpretSizeCombinator(
+    Mapped {
+        inner: bytes::Fixed::<3>,
+        mapper: ReinterpretSizeMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_reinterpret_size()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_reinterpret_size<'a>(input: &'a [u8]) -> (res: PResult<<ReinterpretSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_reinterpret_size().spec_parse(input@) == Some((n as int, v@)),
+        spec_reinterpret_size().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_reinterpret_size().spec_parse(input@) is None,
+        spec_reinterpret_size().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = reinterpret_size();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_reinterpret_size<'a>(v: <ReinterpretSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_reinterpret_size().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_reinterpret_size().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_reinterpret_size().spec_serialize(v@).len(),
+{
+    let combinator = reinterpret_size();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecPrimitiveSizes {
+    pub byte: Seq<u8>,
+    pub word: Seq<u8>,
+}
+
+pub type SpecPrimitiveSizesInner = (Seq<u8>, Seq<u8>);
+
+
+impl SpecFrom<SpecPrimitiveSizes> for SpecPrimitiveSizesInner {
+    open spec fn spec_from(m: SpecPrimitiveSizes) -> SpecPrimitiveSizesInner {
+        (m.byte, m.word)
+    }
+}
+
+impl SpecFrom<SpecPrimitiveSizesInner> for SpecPrimitiveSizes {
+    open spec fn spec_from(m: SpecPrimitiveSizesInner) -> SpecPrimitiveSizes {
+        let (byte, word) = m;
+        SpecPrimitiveSizes { byte, word }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct PrimitiveSizes<'a> {
+    pub byte: &'a [u8],
+    pub word: &'a [u8],
+}
+
+impl View for PrimitiveSizes<'_> {
+    type V = SpecPrimitiveSizes;
+
+    open spec fn view(&self) -> Self::V {
+        SpecPrimitiveSizes {
+            byte: self.byte@,
+            word: self.word@,
+        }
+    }
+}
+pub type PrimitiveSizesInner<'a> = (&'a [u8], &'a [u8]);
+
+pub type PrimitiveSizesInnerRef<'a> = (&'a &'a [u8], &'a &'a [u8]);
+impl<'a> From<&'a PrimitiveSizes<'a>> for PrimitiveSizesInnerRef<'a> {
+    fn ex_from(m: &'a PrimitiveSizes) -> PrimitiveSizesInnerRef<'a> {
+        (&m.byte, &m.word)
+    }
+}
+
+impl<'a> From<PrimitiveSizesInner<'a>> for PrimitiveSizes<'a> {
+    fn ex_from(m: PrimitiveSizesInner) -> PrimitiveSizes {
+        let (byte, word) = m;
+        PrimitiveSizes { byte, word }
+    }
+}
+
+pub struct PrimitiveSizesMapper;
+impl View for PrimitiveSizesMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for PrimitiveSizesMapper {
+    type Src = SpecPrimitiveSizesInner;
+    type Dst = SpecPrimitiveSizes;
+}
+impl SpecIsoProof for PrimitiveSizesMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for PrimitiveSizesMapper {
+    type Src = PrimitiveSizesInner<'a>;
+    type Dst = PrimitiveSizes<'a>;
+    type RefSrc = PrimitiveSizesInnerRef<'a>;
+}
+type SpecPrimitiveSizesCombinatorAlias1 = (bytes::Fixed<1>, bytes::Fixed<2>);
+pub struct SpecPrimitiveSizesCombinator(pub SpecPrimitiveSizesCombinatorAlias);
+
+impl SpecCombinator for SpecPrimitiveSizesCombinator {
+    type Type = SpecPrimitiveSizes;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecPrimitiveSizesCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPrimitiveSizesCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecPrimitiveSizesCombinatorAlias = Mapped<SpecPrimitiveSizesCombinatorAlias1, PrimitiveSizesMapper>;
+type PrimitiveSizesCombinatorAlias1 = (bytes::Fixed<1>, bytes::Fixed<2>);
+pub struct PrimitiveSizesCombinator1(pub PrimitiveSizesCombinatorAlias1);
+impl View for PrimitiveSizesCombinator1 {
+    type V = SpecPrimitiveSizesCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(PrimitiveSizesCombinator1, PrimitiveSizesCombinatorAlias1);
+
+pub struct PrimitiveSizesCombinator(pub PrimitiveSizesCombinatorAlias);
+
+impl View for PrimitiveSizesCombinator {
+    type V = SpecPrimitiveSizesCombinator;
+    open spec fn view(&self) -> Self::V { SpecPrimitiveSizesCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PrimitiveSizesCombinator {
+    type Type = PrimitiveSizes<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type PrimitiveSizesCombinatorAlias = Mapped<PrimitiveSizesCombinator1, PrimitiveSizesMapper>;
+
+
+pub open spec fn spec_primitive_sizes() -> SpecPrimitiveSizesCombinator {
+    SpecPrimitiveSizesCombinator(
+    Mapped {
+        inner: (bytes::Fixed::<1>, bytes::Fixed::<2>),
+        mapper: PrimitiveSizesMapper,
+    })
+}
+
+                
+pub fn primitive_sizes<'a>() -> (o: PrimitiveSizesCombinator)
+    ensures o@ == spec_primitive_sizes(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = PrimitiveSizesCombinator(
+    Mapped {
+        inner: PrimitiveSizesCombinator1((bytes::Fixed::<1>, bytes::Fixed::<2>)),
+        mapper: PrimitiveSizesMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_primitive_sizes()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_primitive_sizes<'a>(input: &'a [u8]) -> (res: PResult<<PrimitiveSizesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_primitive_sizes().spec_parse(input@) == Some((n as int, v@)),
+        spec_primitive_sizes().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_primitive_sizes().spec_parse(input@) is None,
+        spec_primitive_sizes().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = primitive_sizes();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_primitive_sizes<'a>(v: <PrimitiveSizesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_primitive_sizes().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_primitive_sizes().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_primitive_sizes().spec_serialize(v@).len(),
+{
+    let combinator = primitive_sizes();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+}
diff --git a/vest-dsl/test/src/length_expr.vest b/vest-dsl/test/src/length_expr.vest
new file mode 100644
index 00000000..61a69289
--- /dev/null
+++ b/vest-dsl/test/src/length_expr.vest
@@ -0,0 +1,76 @@
+header = {
+    @len: u16 | { 3..0xffff },
+    flags: u8,
+}
+
+primitive_sizes = {
+    byte: [u8; |u8|],
+    word: [u8; |u16|],
+}
+
+named_size = {
+    bytes: [u8; |header|],
+}
+
+header_alias = header
+
+alias_size = {
+    bytes: [u8; |header_alias|],
+}
+
+header_bytes = [u8; |header|] >>= header
+
+reinterpret_size = {
+    bytes: [u8; |header_bytes|],
+}
+
+fixed_choice(@tag: u8) = choose(@tag) {
+    0 => u16,
+    _ => u16,
+}
+
+choice_format_size = {
+    bytes: [u8; |fixed_choice|],
+}
+
+choice_tag = [u8; |u8| + |u8|]
+
+choice_arrays_folded = {
+    @tag: choice_tag,
+    body: choose(@tag) {
+        [0; 2] => u8,
+        [1; 2] => u16,
+    },
+}
+
+size_arith = {
+    bytes: [u8; |header| + |u8|],
+}
+
+simple_sub(@len: u16 | { 4..0xffff }) = {
+    data: [u8; @len - |header| - |u8|],
+}
+
+multi_arith(@total: u32 | { 263..0xffffffff }, @hdr_len: u8 | { 0..255 }) = {
+    body: [u8; @total - @hdr_len - 8],
+}
+
+multiply(@count: u16, @size: u8 | { 1 }) = {
+    items: [u8; @count * @size],
+}
+
+divide(@total: u32) = {
+    chunks: [u8; @total / 4],
+}
+
+paren_expr(@a: u16 | { 255..0xffff }, @b: u8 | { 0..255 }, @c: u8 | { 1 }) = {
+    data: [u8; (@a - @b) * @c],
+}
+
+mixed_const(@len: u16 | { 4..0xffff }) = {
+    data: [u8; @len - 4 + 2],
+}
+
+payload_with_header(@hdr: header) = {
+    data: [u8; @hdr.len - |header|],
+}
diff --git a/vest-dsl/test/src/lib.rs b/vest-dsl/test/src/lib.rs
index 2f2d85de..e98f2b6f 100644
--- a/vest-dsl/test/src/lib.rs
+++ b/vest-dsl/test/src/lib.rs
@@ -1,8 +1,12 @@
+pub mod anonymous_nested;
 pub mod codegen;
 pub mod elab;
 pub mod enum_constraints;
 pub mod enums;
+pub mod ikev2;
 pub mod josh;
+pub mod length_expr;
 pub mod matches;
+pub mod nested_access;
 pub mod opt;
 pub mod repeat;
diff --git a/vest-dsl/test/src/matches.rs b/vest-dsl/test/src/matches.rs
index d46e3038..97552dcb 100644
--- a/vest-dsl/test/src/matches.rs
+++ b/vest-dsl/test/src/matches.rs
@@ -198,6 +198,7 @@ pub open spec fn spec_msg5_content(i: VarInt) -> SpecMsg5ContentCombinator {
 }
 
 pub fn msg5_content<'a>(i: VarInt) -> (o: Msg5ContentCombinator)
+
     ensures o@ == spec_msg5_content(i@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
@@ -214,6 +215,7 @@ pub fn msg5_content<'a>(i: VarInt) -> (o: Msg5ContentCombinator)
 pub fn parse_msg5_content<'a>(input: &'a [u8], i: VarInt) -> (res: PResult<<Msg5ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
         res matches Ok((n, v)) ==> spec_msg5_content(i@).spec_parse(input@) == Some((n as int, v@)),
         spec_msg5_content(i@).spec_parse(input@) matches Some((n, v))
@@ -229,6 +231,7 @@ pub fn serialize_msg5_content<'a>(v: <Msg5ContentCombinator as Combinator<'a, &'
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_msg5_content(i@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -245,6 +248,7 @@ pub fn msg5_content_len<'a>(v: <Msg5ContentCombinator as Combinator<'a, &'a [u8]
     requires
         spec_msg5_content(i@).wf(v@),
         spec_msg5_content(i@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
         serialize_len == spec_msg5_content(i@).spec_serialize(v@).len(),
 {
@@ -652,11 +656,12 @@ pub open spec fn spec_msg1_payload(b: Seq<u8>) -> SpecMsg1PayloadCombinator {
 }
 
 pub fn msg1_payload<'a>(b: &'a [u8]) -> (o: Msg1PayloadCombinator)
+
     ensures o@ == spec_msg1_payload(b@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = Msg1PayloadCombinator(Mapped { inner: Msg1PayloadCombinator1(Choice::new(Cond { cond: compare_slice(b, [207, 33, 173, 116, 229, 154, 97, 17, 190, 29, 140, 2, 30, 101, 184, 145, 194, 162, 17, 22, 122, 187, 140, 94, 7, 158, 9, 226, 200, 168, 51, 156].as_slice()), inner: hello_retry_request() }, Cond { cond: !(compare_slice(b, [207, 33, 173, 116, 229, 154, 97, 17, 190, 29, 140, 2, 30, 101, 184, 145, 194, 162, 17, 22, 122, 187, 140, 94, 7, 158, 9, 226, 200, 168, 51, 156].as_slice())), inner: server_hello() })), mapper: Msg1PayloadMapper });
+    let combinator = Msg1PayloadCombinator(Mapped { inner: Msg1PayloadCombinator1(Choice::new(Cond { cond: compare_slice(b, [207u8, 33u8, 173u8, 116u8, 229u8, 154u8, 97u8, 17u8, 190u8, 29u8, 140u8, 2u8, 30u8, 101u8, 184u8, 145u8, 194u8, 162u8, 17u8, 22u8, 122u8, 187u8, 140u8, 94u8, 7u8, 158u8, 9u8, 226u8, 200u8, 168u8, 51u8, 156u8].as_slice()), inner: hello_retry_request() }, Cond { cond: !(compare_slice(b, [207u8, 33u8, 173u8, 116u8, 229u8, 154u8, 97u8, 17u8, 190u8, 29u8, 140u8, 2u8, 30u8, 101u8, 184u8, 145u8, 194u8, 162u8, 17u8, 22u8, 122u8, 187u8, 140u8, 94u8, 7u8, 158u8, 9u8, 226u8, 200u8, 168u8, 51u8, 156u8].as_slice())), inner: server_hello() })), mapper: Msg1PayloadMapper });
     // assert({
     //     &&& combinator@ == spec_msg1_payload(b@)
     //     &&& combinator@.requires()
@@ -668,6 +673,7 @@ pub fn msg1_payload<'a>(b: &'a [u8]) -> (o: Msg1PayloadCombinator)
 pub fn parse_msg1_payload<'a>(input: &'a [u8], b: &'a [u8]) -> (res: PResult<<Msg1PayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
         res matches Ok((n, v)) ==> spec_msg1_payload(b@).spec_parse(input@) == Some((n as int, v@)),
         spec_msg1_payload(b@).spec_parse(input@) matches Some((n, v))
@@ -683,6 +689,7 @@ pub fn serialize_msg1_payload<'a>(v: <Msg1PayloadCombinator as Combinator<'a, &'
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_msg1_payload(b@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -699,6 +706,7 @@ pub fn msg1_payload_len<'a>(v: <Msg1PayloadCombinator as Combinator<'a, &'a [u8]
     requires
         spec_msg1_payload(b@).wf(v@),
         spec_msg1_payload(b@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
         serialize_len == spec_msg1_payload(b@).spec_serialize(v@).len(),
 {
@@ -870,6 +878,7 @@ pub open spec fn spec_msg4_content(i: u24) -> SpecMsg4ContentCombinator {
 }
 
 pub fn msg4_content<'a>(i: u24) -> (o: Msg4ContentCombinator)
+
     ensures o@ == spec_msg4_content(i@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
@@ -886,6 +895,7 @@ pub fn msg4_content<'a>(i: u24) -> (o: Msg4ContentCombinator)
 pub fn parse_msg4_content<'a>(input: &'a [u8], i: u24) -> (res: PResult<<Msg4ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
         res matches Ok((n, v)) ==> spec_msg4_content(i@).spec_parse(input@) == Some((n as int, v@)),
         spec_msg4_content(i@).spec_parse(input@) matches Some((n, v))
@@ -901,6 +911,7 @@ pub fn serialize_msg4_content<'a>(v: <Msg4ContentCombinator as Combinator<'a, &'
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_msg4_content(i@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -917,6 +928,7 @@ pub fn msg4_content_len<'a>(v: <Msg4ContentCombinator as Combinator<'a, &'a [u8]
     requires
         spec_msg4_content(i@).wf(v@),
         spec_msg4_content(i@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
         serialize_len == spec_msg4_content(i@).spec_serialize(v@).len(),
 {
@@ -1120,6 +1132,7 @@ pub open spec fn spec_msg3_content(i: u8) -> SpecMsg3ContentCombinator {
 }
 
 pub fn msg3_content<'a>(i: u8) -> (o: Msg3ContentCombinator)
+
     ensures o@ == spec_msg3_content(i@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
@@ -1136,6 +1149,7 @@ pub fn msg3_content<'a>(i: u8) -> (o: Msg3ContentCombinator)
 pub fn parse_msg3_content<'a>(input: &'a [u8], i: u8) -> (res: PResult<<Msg3ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
         res matches Ok((n, v)) ==> spec_msg3_content(i@).spec_parse(input@) == Some((n as int, v@)),
         spec_msg3_content(i@).spec_parse(input@) matches Some((n, v))
@@ -1151,6 +1165,7 @@ pub fn serialize_msg3_content<'a>(v: <Msg3ContentCombinator as Combinator<'a, &'
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_msg3_content(i@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -1167,6 +1182,7 @@ pub fn msg3_content_len<'a>(v: <Msg3ContentCombinator as Combinator<'a, &'a [u8]
     requires
         spec_msg3_content(i@).wf(v@),
         spec_msg3_content(i@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
         serialize_len == spec_msg3_content(i@).spec_serialize(v@).len(),
 {
@@ -1395,16 +1411,20 @@ type Msg3Cont0Input<'a, 'b, 'x> = POrSType<Msg3Cont0Type<'a, 'b>, Msg3Cont0SType
 impl<'a, 'b, 'x> Continuation<Msg3Cont0Input<'a, 'b, 'x>> for Msg3Cont0 {
     type Output = Msg3ContentCombinator;
 
-    open spec fn requires(&self, deps: Msg3Cont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: Msg3Cont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U8).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: Msg3Cont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_msg3_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_msg3_cont0(deps@)
     }
 
     fn apply(&self, deps: Msg3Cont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let i = *deps;
+                let i = deps;
+                let i = *i;
                 msg3_content(i)
             }
             POrSType::S(deps) => {
@@ -1637,16 +1657,20 @@ type Msg5Cont0Input<'a, 'b, 'x> = POrSType<Msg5Cont0Type<'a, 'b>, Msg5Cont0SType
 impl<'a, 'b, 'x> Continuation<Msg5Cont0Input<'a, 'b, 'x>> for Msg5Cont0 {
     type Output = Msg5ContentCombinator;
 
-    open spec fn requires(&self, deps: Msg5Cont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: Msg5Cont0Input<'a, 'b, 'x>) -> bool {
+        &&& (BtcVarint).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: Msg5Cont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_msg5_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_msg5_cont0(deps@)
     }
 
     fn apply(&self, deps: Msg5Cont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let i = *deps;
+                let i = deps;
+                let i = *i;
                 msg5_content(i)
             }
             POrSType::S(deps) => {
@@ -1822,11 +1846,12 @@ pub open spec fn spec_msg2_content(b: Seq<u8>) -> SpecMsg2ContentCombinator {
 }
 
 pub fn msg2_content<'a>(b: &'a [u8]) -> (o: Msg2ContentCombinator)
+
     ensures o@ == spec_msg2_content(b@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = Msg2ContentCombinator(Mapped { inner: Msg2ContentCombinator1(Choice::new(Cond { cond: compare_slice(b, [22, 3, 1].as_slice()), inner: U16Le }, Cond { cond: !(compare_slice(b, [22, 3, 1].as_slice())), inner: U32Le })), mapper: Msg2ContentMapper });
+    let combinator = Msg2ContentCombinator(Mapped { inner: Msg2ContentCombinator1(Choice::new(Cond { cond: compare_slice(b, [22u8, 3u8, 1u8].as_slice()), inner: U16Le }, Cond { cond: !(compare_slice(b, [22u8, 3u8, 1u8].as_slice())), inner: U32Le })), mapper: Msg2ContentMapper });
     // assert({
     //     &&& combinator@ == spec_msg2_content(b@)
     //     &&& combinator@.requires()
@@ -1838,6 +1863,7 @@ pub fn msg2_content<'a>(b: &'a [u8]) -> (o: Msg2ContentCombinator)
 pub fn parse_msg2_content<'a>(input: &'a [u8], b: &'a [u8]) -> (res: PResult<<Msg2ContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
         res matches Ok((n, v)) ==> spec_msg2_content(b@).spec_parse(input@) == Some((n as int, v@)),
         spec_msg2_content(b@).spec_parse(input@) matches Some((n, v))
@@ -1853,6 +1879,7 @@ pub fn serialize_msg2_content<'a>(v: <Msg2ContentCombinator as Combinator<'a, &'
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_msg2_content(b@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -1869,6 +1896,7 @@ pub fn msg2_content_len<'a>(v: <Msg2ContentCombinator as Combinator<'a, &'a [u8]
     requires
         spec_msg2_content(b@).wf(v@),
         spec_msg2_content(b@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
         serialize_len == spec_msg2_content(b@).spec_serialize(v@).len(),
 {
@@ -2097,16 +2125,20 @@ type Msg1Cont0Input<'a, 'b, 'x> = POrSType<Msg1Cont0Type<'a, 'b>, Msg1Cont0SType
 impl<'a, 'b, 'x> Continuation<Msg1Cont0Input<'a, 'b, 'x>> for Msg1Cont0 {
     type Output = Msg1PayloadCombinator;
 
-    open spec fn requires(&self, deps: Msg1Cont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: Msg1Cont0Input<'a, 'b, 'x>) -> bool {
+        &&& (bytes::Fixed::<32>).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: Msg1Cont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_msg1_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_msg1_cont0(deps@)
     }
 
     fn apply(&self, deps: Msg1Cont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let b = *deps;
+                let b = deps;
+                let b = *b;
                 msg1_payload(b)
             }
             POrSType::S(deps) => {
@@ -2339,16 +2371,20 @@ type Msg2Cont0Input<'a, 'b, 'x> = POrSType<Msg2Cont0Type<'a, 'b>, Msg2Cont0SType
 impl<'a, 'b, 'x> Continuation<Msg2Cont0Input<'a, 'b, 'x>> for Msg2Cont0 {
     type Output = Msg2ContentCombinator;
 
-    open spec fn requires(&self, deps: Msg2Cont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: Msg2Cont0Input<'a, 'b, 'x>) -> bool {
+        &&& (bytes::Fixed::<3>).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: Msg2Cont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_msg2_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_msg2_cont0(deps@)
     }
 
     fn apply(&self, deps: Msg2Cont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let b = *deps;
+                let b = deps;
+                let b = *b;
                 msg2_content(b)
             }
             POrSType::S(deps) => {
@@ -2581,16 +2617,20 @@ type Msg4Cont0Input<'a, 'b, 'x> = POrSType<Msg4Cont0Type<'a, 'b>, Msg4Cont0SType
 impl<'a, 'b, 'x> Continuation<Msg4Cont0Input<'a, 'b, 'x>> for Msg4Cont0 {
     type Output = Msg4ContentCombinator;
 
-    open spec fn requires(&self, deps: Msg4Cont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: Msg4Cont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U24Le).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: Msg4Cont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_msg4_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_msg4_cont0(deps@)
     }
 
     fn apply(&self, deps: Msg4Cont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let i = *deps;
+                let i = deps;
+                let i = *i;
                 msg4_content(i)
             }
             POrSType::S(deps) => {
diff --git a/vest-dsl/test/src/nested_access.rs b/vest-dsl/test/src/nested_access.rs
new file mode 100644
index 00000000..97731545
--- /dev/null
+++ b/vest-dsl/test/src/nested_access.rs
@@ -0,0 +1,1229 @@
+
+#![allow(warnings)]
+#![allow(unused)]
+use vstd::prelude::*;
+use vest_lib::regular::modifier::*;
+use vest_lib::regular::bytes;
+use vest_lib::regular::variant::*;
+use vest_lib::regular::sequence::*;
+use vest_lib::regular::repetition::*;
+use vest_lib::regular::disjoint::DisjointFrom;
+use vest_lib::regular::tag::*;
+use vest_lib::regular::uints::*;
+use vest_lib::utils::*;
+use vest_lib::properties::*;
+use vest_lib::bitcoin::varint::{BtcVarint, VarInt};
+use vest_lib::regular::leb128::*;
+
+macro_rules! impl_wrapper_combinator {
+    ($combinator:ty, $combinator_alias:ty) => {
+        ::vstd::prelude::verus! {
+            impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for $combinator {
+                type Type = <$combinator_alias as Combinator<'a, &'a [u8], Vec<u8>>>::Type;
+                type SType = <$combinator_alias as Combinator<'a, &'a [u8], Vec<u8>>>::SType;
+                fn length(&self, v: Self::SType) -> usize
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+                open spec fn ex_requires(&self) -> bool
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+                fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&self.0, s) }
+                fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+                { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+            }
+        } // verus!
+    };
+}
+verus!{
+
+pub struct SpecGenericHeader {
+    pub next_type: u8,
+    pub reserved: u8,
+    pub payload_length: u16,
+}
+
+pub type SpecGenericHeaderInner = (u8, (u8, u16));
+
+
+impl SpecFrom<SpecGenericHeader> for SpecGenericHeaderInner {
+    open spec fn spec_from(m: SpecGenericHeader) -> SpecGenericHeaderInner {
+        (m.next_type, (m.reserved, m.payload_length))
+    }
+}
+
+impl SpecFrom<SpecGenericHeaderInner> for SpecGenericHeader {
+    open spec fn spec_from(m: SpecGenericHeaderInner) -> SpecGenericHeader {
+        let (next_type, (reserved, payload_length)) = m;
+        SpecGenericHeader { next_type, reserved, payload_length }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct GenericHeader {
+    pub next_type: u8,
+    pub reserved: u8,
+    pub payload_length: u16,
+}
+
+impl View for GenericHeader {
+    type V = SpecGenericHeader;
+
+    open spec fn view(&self) -> Self::V {
+        SpecGenericHeader {
+            next_type: self.next_type@,
+            reserved: self.reserved@,
+            payload_length: self.payload_length@,
+        }
+    }
+}
+pub type GenericHeaderInner = (u8, (u8, u16));
+
+pub type GenericHeaderInnerRef<'a> = (&'a u8, (&'a u8, &'a u16));
+impl<'a> From<&'a GenericHeader> for GenericHeaderInnerRef<'a> {
+    fn ex_from(m: &'a GenericHeader) -> GenericHeaderInnerRef<'a> {
+        (&m.next_type, (&m.reserved, &m.payload_length))
+    }
+}
+
+impl From<GenericHeaderInner> for GenericHeader {
+    fn ex_from(m: GenericHeaderInner) -> GenericHeader {
+        let (next_type, (reserved, payload_length)) = m;
+        GenericHeader { next_type, reserved, payload_length }
+    }
+}
+
+pub struct GenericHeaderMapper;
+impl View for GenericHeaderMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for GenericHeaderMapper {
+    type Src = SpecGenericHeaderInner;
+    type Dst = SpecGenericHeader;
+}
+impl SpecIsoProof for GenericHeaderMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for GenericHeaderMapper {
+    type Src = GenericHeaderInner;
+    type Dst = GenericHeader;
+    type RefSrc = GenericHeaderInnerRef<'a>;
+}
+type SpecGenericHeaderCombinatorAlias1 = (U8, Refined<U16Le, Predicate18193225726552524852>);
+type SpecGenericHeaderCombinatorAlias2 = (U8, SpecGenericHeaderCombinatorAlias1);
+pub struct SpecGenericHeaderCombinator(pub SpecGenericHeaderCombinatorAlias);
+
+impl SpecCombinator for SpecGenericHeaderCombinator {
+    type Type = SpecGenericHeader;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecGenericHeaderCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecGenericHeaderCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecGenericHeaderCombinatorAlias = Mapped<SpecGenericHeaderCombinatorAlias2, GenericHeaderMapper>;
+pub struct Predicate18193225726552524852;
+impl View for Predicate18193225726552524852 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate18193225726552524852 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 8 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate18193225726552524852 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 8 && i <= 65535)
+    }
+}
+type GenericHeaderCombinatorAlias1 = (U8, Refined<U16Le, Predicate18193225726552524852>);
+type GenericHeaderCombinatorAlias2 = (U8, GenericHeaderCombinator1);
+pub struct GenericHeaderCombinator1(pub GenericHeaderCombinatorAlias1);
+impl View for GenericHeaderCombinator1 {
+    type V = SpecGenericHeaderCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(GenericHeaderCombinator1, GenericHeaderCombinatorAlias1);
+
+pub struct GenericHeaderCombinator2(pub GenericHeaderCombinatorAlias2);
+impl View for GenericHeaderCombinator2 {
+    type V = SpecGenericHeaderCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(GenericHeaderCombinator2, GenericHeaderCombinatorAlias2);
+
+pub struct GenericHeaderCombinator(pub GenericHeaderCombinatorAlias);
+
+impl View for GenericHeaderCombinator {
+    type V = SpecGenericHeaderCombinator;
+    open spec fn view(&self) -> Self::V { SpecGenericHeaderCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GenericHeaderCombinator {
+    type Type = GenericHeader;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type GenericHeaderCombinatorAlias = Mapped<GenericHeaderCombinator2, GenericHeaderMapper>;
+
+
+pub open spec fn spec_generic_header() -> SpecGenericHeaderCombinator {
+    SpecGenericHeaderCombinator(
+    Mapped {
+        inner: (U8, (U8, Refined { inner: U16Le, predicate: Predicate18193225726552524852 })),
+        mapper: GenericHeaderMapper,
+    })
+}
+
+                
+pub fn generic_header<'a>() -> (o: GenericHeaderCombinator)
+    ensures o@ == spec_generic_header(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = GenericHeaderCombinator(
+    Mapped {
+        inner: GenericHeaderCombinator2((U8, GenericHeaderCombinator1((U8, Refined { inner: U16Le, predicate: Predicate18193225726552524852 })))),
+        mapper: GenericHeaderMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_generic_header()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_generic_header<'a>(input: &'a [u8]) -> (res: PResult<<GenericHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_generic_header().spec_parse(input@) == Some((n as int, v@)),
+        spec_generic_header().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_generic_header().spec_parse(input@) is None,
+        spec_generic_header().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = generic_header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_generic_header<'a>(v: <GenericHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_generic_header().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_generic_header().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_generic_header().spec_serialize(v@).len(),
+{
+    let combinator = generic_header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecOuterHeader {
+    pub magic: u32,
+    pub inner: SpecGenericHeader,
+}
+
+pub type SpecOuterHeaderInner = (u32, SpecGenericHeader);
+
+
+impl SpecFrom<SpecOuterHeader> for SpecOuterHeaderInner {
+    open spec fn spec_from(m: SpecOuterHeader) -> SpecOuterHeaderInner {
+        (m.magic, m.inner)
+    }
+}
+
+impl SpecFrom<SpecOuterHeaderInner> for SpecOuterHeader {
+    open spec fn spec_from(m: SpecOuterHeaderInner) -> SpecOuterHeader {
+        let (magic, inner) = m;
+        SpecOuterHeader { magic, inner }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct OuterHeader {
+    pub magic: u32,
+    pub inner: GenericHeader,
+}
+
+impl View for OuterHeader {
+    type V = SpecOuterHeader;
+
+    open spec fn view(&self) -> Self::V {
+        SpecOuterHeader {
+            magic: self.magic@,
+            inner: self.inner@,
+        }
+    }
+}
+pub type OuterHeaderInner = (u32, GenericHeader);
+
+pub type OuterHeaderInnerRef<'a> = (&'a u32, &'a GenericHeader);
+impl<'a> From<&'a OuterHeader> for OuterHeaderInnerRef<'a> {
+    fn ex_from(m: &'a OuterHeader) -> OuterHeaderInnerRef<'a> {
+        (&m.magic, &m.inner)
+    }
+}
+
+impl From<OuterHeaderInner> for OuterHeader {
+    fn ex_from(m: OuterHeaderInner) -> OuterHeader {
+        let (magic, inner) = m;
+        OuterHeader { magic, inner }
+    }
+}
+
+pub struct OuterHeaderMapper;
+impl View for OuterHeaderMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for OuterHeaderMapper {
+    type Src = SpecOuterHeaderInner;
+    type Dst = SpecOuterHeader;
+}
+impl SpecIsoProof for OuterHeaderMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for OuterHeaderMapper {
+    type Src = OuterHeaderInner;
+    type Dst = OuterHeader;
+    type RefSrc = OuterHeaderInnerRef<'a>;
+}
+type SpecOuterHeaderCombinatorAlias1 = (U32Le, SpecGenericHeaderCombinator);
+pub struct SpecOuterHeaderCombinator(pub SpecOuterHeaderCombinatorAlias);
+
+impl SpecCombinator for SpecOuterHeaderCombinator {
+    type Type = SpecOuterHeader;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecOuterHeaderCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOuterHeaderCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecOuterHeaderCombinatorAlias = Mapped<SpecOuterHeaderCombinatorAlias1, OuterHeaderMapper>;
+type OuterHeaderCombinatorAlias1 = (U32Le, GenericHeaderCombinator);
+pub struct OuterHeaderCombinator1(pub OuterHeaderCombinatorAlias1);
+impl View for OuterHeaderCombinator1 {
+    type V = SpecOuterHeaderCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(OuterHeaderCombinator1, OuterHeaderCombinatorAlias1);
+
+pub struct OuterHeaderCombinator(pub OuterHeaderCombinatorAlias);
+
+impl View for OuterHeaderCombinator {
+    type V = SpecOuterHeaderCombinator;
+    open spec fn view(&self) -> Self::V { SpecOuterHeaderCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OuterHeaderCombinator {
+    type Type = OuterHeader;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type OuterHeaderCombinatorAlias = Mapped<OuterHeaderCombinator1, OuterHeaderMapper>;
+
+
+pub open spec fn spec_outer_header() -> SpecOuterHeaderCombinator {
+    SpecOuterHeaderCombinator(
+    Mapped {
+        inner: (U32Le, spec_generic_header()),
+        mapper: OuterHeaderMapper,
+    })
+}
+
+                
+pub fn outer_header<'a>() -> (o: OuterHeaderCombinator)
+    ensures o@ == spec_outer_header(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = OuterHeaderCombinator(
+    Mapped {
+        inner: OuterHeaderCombinator1((U32Le, generic_header())),
+        mapper: OuterHeaderMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_outer_header()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_outer_header<'a>(input: &'a [u8]) -> (res: PResult<<OuterHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_outer_header().spec_parse(input@) == Some((n as int, v@)),
+        spec_outer_header().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_outer_header().spec_parse(input@) is None,
+        spec_outer_header().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = outer_header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_outer_header<'a>(v: <OuterHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_outer_header().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_outer_header().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_outer_header().spec_serialize(v@).len(),
+{
+    let combinator = outer_header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecPayloadWithHeader {
+    pub hdr: SpecGenericHeader,
+    pub body: Seq<u8>,
+}
+
+pub type SpecPayloadWithHeaderInner = (SpecGenericHeader, Seq<u8>);
+
+
+impl SpecFrom<SpecPayloadWithHeader> for SpecPayloadWithHeaderInner {
+    open spec fn spec_from(m: SpecPayloadWithHeader) -> SpecPayloadWithHeaderInner {
+        (m.hdr, m.body)
+    }
+}
+
+impl SpecFrom<SpecPayloadWithHeaderInner> for SpecPayloadWithHeader {
+    open spec fn spec_from(m: SpecPayloadWithHeaderInner) -> SpecPayloadWithHeader {
+        let (hdr, body) = m;
+        SpecPayloadWithHeader { hdr, body }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct PayloadWithHeader<'a> {
+    pub hdr: GenericHeader,
+    pub body: &'a [u8],
+}
+
+impl View for PayloadWithHeader<'_> {
+    type V = SpecPayloadWithHeader;
+
+    open spec fn view(&self) -> Self::V {
+        SpecPayloadWithHeader {
+            hdr: self.hdr@,
+            body: self.body@,
+        }
+    }
+}
+pub type PayloadWithHeaderInner<'a> = (GenericHeader, &'a [u8]);
+
+pub type PayloadWithHeaderInnerRef<'a> = (&'a GenericHeader, &'a &'a [u8]);
+impl<'a> From<&'a PayloadWithHeader<'a>> for PayloadWithHeaderInnerRef<'a> {
+    fn ex_from(m: &'a PayloadWithHeader) -> PayloadWithHeaderInnerRef<'a> {
+        (&m.hdr, &m.body)
+    }
+}
+
+impl<'a> From<PayloadWithHeaderInner<'a>> for PayloadWithHeader<'a> {
+    fn ex_from(m: PayloadWithHeaderInner) -> PayloadWithHeader {
+        let (hdr, body) = m;
+        PayloadWithHeader { hdr, body }
+    }
+}
+
+pub struct PayloadWithHeaderMapper;
+impl View for PayloadWithHeaderMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for PayloadWithHeaderMapper {
+    type Src = SpecPayloadWithHeaderInner;
+    type Dst = SpecPayloadWithHeader;
+}
+impl SpecIsoProof for PayloadWithHeaderMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for PayloadWithHeaderMapper {
+    type Src = PayloadWithHeaderInner<'a>;
+    type Dst = PayloadWithHeader<'a>;
+    type RefSrc = PayloadWithHeaderInnerRef<'a>;
+}
+
+pub struct SpecPayloadWithHeaderCombinator(pub SpecPayloadWithHeaderCombinatorAlias);
+
+impl SpecCombinator for SpecPayloadWithHeaderCombinator {
+    type Type = SpecPayloadWithHeader;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecPayloadWithHeaderCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPayloadWithHeaderCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecPayloadWithHeaderCombinatorAlias = Mapped<SpecPair<SpecGenericHeaderCombinator, bytes::Variable>, PayloadWithHeaderMapper>;
+
+pub struct PayloadWithHeaderCombinator(pub PayloadWithHeaderCombinatorAlias);
+
+impl View for PayloadWithHeaderCombinator {
+    type V = SpecPayloadWithHeaderCombinator;
+    open spec fn view(&self) -> Self::V { SpecPayloadWithHeaderCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PayloadWithHeaderCombinator {
+    type Type = PayloadWithHeader<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type PayloadWithHeaderCombinatorAlias = Mapped<Pair<GenericHeaderCombinator, bytes::Variable, PayloadWithHeaderCont0>, PayloadWithHeaderMapper>;
+
+
+pub open spec fn spec_payload_with_header() -> SpecPayloadWithHeaderCombinator {
+    SpecPayloadWithHeaderCombinator(
+    Mapped {
+        inner: Pair::spec_new(spec_generic_header(), |deps| spec_payload_with_header_cont0(deps)),
+        mapper: PayloadWithHeaderMapper,
+    })
+}
+
+pub open spec fn spec_payload_with_header_cont0(deps: SpecGenericHeader) -> bytes::Variable {
+    let hdr = deps;
+    bytes::Variable(((usize::spec_from(hdr.payload_length) - 4)) as usize)
+}
+
+impl View for PayloadWithHeaderCont0 {
+    type V = spec_fn(SpecGenericHeader) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: SpecGenericHeader| {
+            spec_payload_with_header_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn payload_with_header<'a>() -> (o: PayloadWithHeaderCombinator)
+    ensures o@ == spec_payload_with_header(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = PayloadWithHeaderCombinator(
+    Mapped {
+        inner: Pair::new(generic_header(), PayloadWithHeaderCont0),
+        mapper: PayloadWithHeaderMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_payload_with_header()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_payload_with_header<'a>(input: &'a [u8]) -> (res: PResult<<PayloadWithHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_payload_with_header().spec_parse(input@) == Some((n as int, v@)),
+        spec_payload_with_header().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_payload_with_header().spec_parse(input@) is None,
+        spec_payload_with_header().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = payload_with_header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_payload_with_header<'a>(v: <PayloadWithHeaderCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_payload_with_header().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_payload_with_header().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_payload_with_header().spec_serialize(v@).len(),
+{
+    let combinator = payload_with_header();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct PayloadWithHeaderCont0;
+type PayloadWithHeaderCont0Type<'a, 'b> = &'b GenericHeader;
+type PayloadWithHeaderCont0SType<'a, 'x> = &'x GenericHeader;
+type PayloadWithHeaderCont0Input<'a, 'b, 'x> = POrSType<PayloadWithHeaderCont0Type<'a, 'b>, PayloadWithHeaderCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<PayloadWithHeaderCont0Input<'a, 'b, 'x>> for PayloadWithHeaderCont0 {
+    type Output = bytes::Variable;
+
+    open spec fn requires(&self, deps: PayloadWithHeaderCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_generic_header()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: PayloadWithHeaderCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_payload_with_header_cont0(deps@)
+    }
+
+    fn apply(&self, deps: PayloadWithHeaderCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let hdr = deps;
+                bytes::Variable(((usize::ex_from(hdr.payload_length) - 4)) as usize)
+            }
+            POrSType::S(deps) => {
+                let hdr = deps;
+                bytes::Variable(((usize::ex_from(hdr.payload_length) - 4)) as usize)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecDeepNested {
+    pub outer: SpecOuterHeader,
+    pub data: Seq<u8>,
+}
+
+pub type SpecDeepNestedInner = (SpecOuterHeader, Seq<u8>);
+
+
+impl SpecFrom<SpecDeepNested> for SpecDeepNestedInner {
+    open spec fn spec_from(m: SpecDeepNested) -> SpecDeepNestedInner {
+        (m.outer, m.data)
+    }
+}
+
+impl SpecFrom<SpecDeepNestedInner> for SpecDeepNested {
+    open spec fn spec_from(m: SpecDeepNestedInner) -> SpecDeepNested {
+        let (outer, data) = m;
+        SpecDeepNested { outer, data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct DeepNested<'a> {
+    pub outer: OuterHeader,
+    pub data: &'a [u8],
+}
+
+impl View for DeepNested<'_> {
+    type V = SpecDeepNested;
+
+    open spec fn view(&self) -> Self::V {
+        SpecDeepNested {
+            outer: self.outer@,
+            data: self.data@,
+        }
+    }
+}
+pub type DeepNestedInner<'a> = (OuterHeader, &'a [u8]);
+
+pub type DeepNestedInnerRef<'a> = (&'a OuterHeader, &'a &'a [u8]);
+impl<'a> From<&'a DeepNested<'a>> for DeepNestedInnerRef<'a> {
+    fn ex_from(m: &'a DeepNested) -> DeepNestedInnerRef<'a> {
+        (&m.outer, &m.data)
+    }
+}
+
+impl<'a> From<DeepNestedInner<'a>> for DeepNested<'a> {
+    fn ex_from(m: DeepNestedInner) -> DeepNested {
+        let (outer, data) = m;
+        DeepNested { outer, data }
+    }
+}
+
+pub struct DeepNestedMapper;
+impl View for DeepNestedMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for DeepNestedMapper {
+    type Src = SpecDeepNestedInner;
+    type Dst = SpecDeepNested;
+}
+impl SpecIsoProof for DeepNestedMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for DeepNestedMapper {
+    type Src = DeepNestedInner<'a>;
+    type Dst = DeepNested<'a>;
+    type RefSrc = DeepNestedInnerRef<'a>;
+}
+
+pub struct SpecDeepNestedCombinator(pub SpecDeepNestedCombinatorAlias);
+
+impl SpecCombinator for SpecDeepNestedCombinator {
+    type Type = SpecDeepNested;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecDeepNestedCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDeepNestedCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecDeepNestedCombinatorAlias = Mapped<SpecPair<SpecOuterHeaderCombinator, bytes::Variable>, DeepNestedMapper>;
+
+pub struct DeepNestedCombinator(pub DeepNestedCombinatorAlias);
+
+impl View for DeepNestedCombinator {
+    type V = SpecDeepNestedCombinator;
+    open spec fn view(&self) -> Self::V { SpecDeepNestedCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DeepNestedCombinator {
+    type Type = DeepNested<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type DeepNestedCombinatorAlias = Mapped<Pair<OuterHeaderCombinator, bytes::Variable, DeepNestedCont0>, DeepNestedMapper>;
+
+
+pub open spec fn spec_deep_nested() -> SpecDeepNestedCombinator {
+    SpecDeepNestedCombinator(
+    Mapped {
+        inner: Pair::spec_new(spec_outer_header(), |deps| spec_deep_nested_cont0(deps)),
+        mapper: DeepNestedMapper,
+    })
+}
+
+pub open spec fn spec_deep_nested_cont0(deps: SpecOuterHeader) -> bytes::Variable {
+    let outer = deps;
+    bytes::Variable(((usize::spec_from(outer.inner.payload_length) - 8)) as usize)
+}
+
+impl View for DeepNestedCont0 {
+    type V = spec_fn(SpecOuterHeader) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: SpecOuterHeader| {
+            spec_deep_nested_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn deep_nested<'a>() -> (o: DeepNestedCombinator)
+    ensures o@ == spec_deep_nested(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = DeepNestedCombinator(
+    Mapped {
+        inner: Pair::new(outer_header(), DeepNestedCont0),
+        mapper: DeepNestedMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_deep_nested()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_deep_nested<'a>(input: &'a [u8]) -> (res: PResult<<DeepNestedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_deep_nested().spec_parse(input@) == Some((n as int, v@)),
+        spec_deep_nested().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_deep_nested().spec_parse(input@) is None,
+        spec_deep_nested().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = deep_nested();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_deep_nested<'a>(v: <DeepNestedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_deep_nested().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&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@),
+        spec_deep_nested().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_deep_nested().spec_serialize(v@).len(),
+{
+    let combinator = deep_nested();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct DeepNestedCont0;
+type DeepNestedCont0Type<'a, 'b> = &'b OuterHeader;
+type DeepNestedCont0SType<'a, 'x> = &'x OuterHeader;
+type DeepNestedCont0Input<'a, 'b, 'x> = POrSType<DeepNestedCont0Type<'a, 'b>, DeepNestedCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<DeepNestedCont0Input<'a, 'b, 'x>> for DeepNestedCont0 {
+    type Output = bytes::Variable;
+
+    open spec fn requires(&self, deps: DeepNestedCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_outer_header()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: DeepNestedCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_deep_nested_cont0(deps@)
+    }
+
+    fn apply(&self, deps: DeepNestedCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let outer = deps;
+                bytes::Variable(((usize::ex_from(outer.inner.payload_length) - 8)) as usize)
+            }
+            POrSType::S(deps) => {
+                let outer = deps;
+                bytes::Variable(((usize::ex_from(outer.inner.payload_length) - 8)) as usize)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecCombinedExample {
+    pub header: SpecGenericHeader,
+    pub body: Seq<u8>,
+}
+
+pub type SpecCombinedExampleInner = (SpecGenericHeader, Seq<u8>);
+
+
+impl SpecFrom<SpecCombinedExample> for SpecCombinedExampleInner {
+    open spec fn spec_from(m: SpecCombinedExample) -> SpecCombinedExampleInner {
+        (m.header, m.body)
+    }
+}
+
+impl SpecFrom<SpecCombinedExampleInner> for SpecCombinedExample {
+    open spec fn spec_from(m: SpecCombinedExampleInner) -> SpecCombinedExample {
+        let (header, body) = m;
+        SpecCombinedExample { header, body }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CombinedExample<'a> {
+    pub header: GenericHeader,
+    pub body: &'a [u8],
+}
+
+impl View for CombinedExample<'_> {
+    type V = SpecCombinedExample;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCombinedExample {
+            header: self.header@,
+            body: self.body@,
+        }
+    }
+}
+pub type CombinedExampleInner<'a> = (GenericHeader, &'a [u8]);
+
+pub type CombinedExampleInnerRef<'a> = (&'a GenericHeader, &'a &'a [u8]);
+impl<'a> From<&'a CombinedExample<'a>> for CombinedExampleInnerRef<'a> {
+    fn ex_from(m: &'a CombinedExample) -> CombinedExampleInnerRef<'a> {
+        (&m.header, &m.body)
+    }
+}
+
+impl<'a> From<CombinedExampleInner<'a>> for CombinedExample<'a> {
+    fn ex_from(m: CombinedExampleInner) -> CombinedExample {
+        let (header, body) = m;
+        CombinedExample { header, body }
+    }
+}
+
+pub struct CombinedExampleMapper;
+impl View for CombinedExampleMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CombinedExampleMapper {
+    type Src = SpecCombinedExampleInner;
+    type Dst = SpecCombinedExample;
+}
+impl SpecIsoProof for CombinedExampleMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CombinedExampleMapper {
+    type Src = CombinedExampleInner<'a>;
+    type Dst = CombinedExample<'a>;
+    type RefSrc = CombinedExampleInnerRef<'a>;
+}
+
+pub struct SpecCombinedExampleCombinator(pub SpecCombinedExampleCombinatorAlias);
+
+impl SpecCombinator for SpecCombinedExampleCombinator {
+    type Type = SpecCombinedExample;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCombinedExampleCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCombinedExampleCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCombinedExampleCombinatorAlias = Mapped<SpecPair<SpecGenericHeaderCombinator, bytes::Variable>, CombinedExampleMapper>;
+
+pub struct CombinedExampleCombinator(pub CombinedExampleCombinatorAlias);
+
+impl View for CombinedExampleCombinator {
+    type V = SpecCombinedExampleCombinator;
+    open spec fn view(&self) -> Self::V { SpecCombinedExampleCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CombinedExampleCombinator {
+    type Type = CombinedExample<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CombinedExampleCombinatorAlias = Mapped<Pair<GenericHeaderCombinator, bytes::Variable, CombinedExampleCont0>, CombinedExampleMapper>;
+
+
+pub open spec fn spec_combined_example(total_len: u32) -> SpecCombinedExampleCombinator {
+    SpecCombinedExampleCombinator(
+    Mapped {
+        inner: Pair::spec_new(spec_generic_header(), |deps| spec_combined_example_cont0(total_len, deps)),
+        mapper: CombinedExampleMapper,
+    })
+}
+
+pub open spec fn spec_combined_example_cont0(total_len: u32, deps: SpecGenericHeader) -> bytes::Variable {
+    let header = deps;
+    bytes::Variable(((usize::spec_from(total_len) - usize::spec_from(header.payload_length))) as usize)
+}
+
+impl View for CombinedExampleCont0 {
+    type V = spec_fn(SpecGenericHeader) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: SpecGenericHeader| {
+            spec_combined_example_cont0(self.total_len@, deps)
+        }
+    }
+}
+
+pub fn combined_example<'a>(total_len: u32) -> (o: CombinedExampleCombinator)
+    requires
+        ((total_len) >= 65535 && (total_len) <= 4294967295),
+
+    ensures o@ == spec_combined_example(total_len@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CombinedExampleCombinator(
+    Mapped {
+        inner: Pair::new(generic_header(), CombinedExampleCont0 { total_len }),
+        mapper: CombinedExampleMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_combined_example(total_len@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_combined_example<'a>(input: &'a [u8], total_len: u32) -> (res: PResult<<CombinedExampleCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        ((total_len) >= 65535 && (total_len) <= 4294967295),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_combined_example(total_len@).spec_parse(input@) == Some((n as int, v@)),
+        spec_combined_example(total_len@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_combined_example(total_len@).spec_parse(input@) is None,
+        spec_combined_example(total_len@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = combined_example( total_len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_combined_example<'a>(v: <CombinedExampleCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, total_len: u32) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_combined_example(total_len@).wf(v@),
+        ((total_len) >= 65535 && (total_len) <= 4294967295),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& 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 );
+    combinator.serialize(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@),
+        spec_combined_example(total_len@).spec_serialize(v@).len() <= usize::MAX,
+        ((total_len) >= 65535 && (total_len) <= 4294967295),
+
+    ensures
+        serialize_len == spec_combined_example(total_len@).spec_serialize(v@).len(),
+{
+    let combinator = combined_example( total_len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct CombinedExampleCont0 {
+    pub total_len: u32,
+}
+type CombinedExampleCont0Type<'a, 'b> = &'b GenericHeader;
+type CombinedExampleCont0SType<'a, 'x> = &'x GenericHeader;
+type CombinedExampleCont0Input<'a, 'b, 'x> = POrSType<CombinedExampleCont0Type<'a, 'b>, CombinedExampleCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CombinedExampleCont0Input<'a, 'b, 'x>> for CombinedExampleCont0 {
+    type Output = bytes::Variable;
+
+    open spec fn requires(&self, deps: CombinedExampleCont0Input<'a, 'b, 'x>) -> bool {        let total_len = self.total_len@;
+
+        &&& ((self.total_len@) >= 65535 && (self.total_len@) <= 4294967295)
+        &&& (spec_generic_header()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CombinedExampleCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_combined_example_cont0(self.total_len@, deps@)
+    }
+
+    fn apply(&self, deps: CombinedExampleCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let header = deps;
+                let total_len = self.total_len;
+                bytes::Variable(((usize::ex_from(total_len) - usize::ex_from(header.payload_length))) as usize)
+            }
+            POrSType::S(deps) => {
+                let header = deps;
+                let total_len = self.total_len;
+                bytes::Variable(((usize::ex_from(total_len) - usize::ex_from(header.payload_length))) as usize)
+            }
+        }
+    }
+}
+
+}
diff --git a/vest-dsl/test/src/nested_access.vest b/vest-dsl/test/src/nested_access.vest
new file mode 100644
index 00000000..dc26c40b
--- /dev/null
+++ b/vest-dsl/test/src/nested_access.vest
@@ -0,0 +1,25 @@
+generic_header = {
+    next_type: u8,
+    reserved: u8,
+    @payload_length: u16 | { 8..0xffff },
+}
+
+payload_with_header = {
+    @hdr: generic_header,
+    body: [u8; @hdr.payload_length - 4],
+}
+
+outer_header = {
+    magic: u32,
+    @inner: generic_header,
+}
+
+deep_nested = {
+    @outer: outer_header,
+    data: [u8; @outer.inner.payload_length - 8],
+}
+
+combined_example(@total_len: u32 | { 65535..0xffffffff }) = {
+    @header: generic_header,
+    body: [u8; @total_len - @header.payload_length],
+}
diff --git a/vest-dsl/test/src/repeat.rs b/vest-dsl/test/src/repeat.rs
index 1717c60f..cae995fd 100644
--- a/vest-dsl/test/src/repeat.rs
+++ b/vest-dsl/test/src/repeat.rs
@@ -195,7 +195,7 @@ pub open spec fn spec_opaque_u16() -> SpecOpaqueU16Combinator {
 
 pub open spec fn spec_opaque_u16_cont0(deps: u16) -> bytes::Variable {
     let l = deps;
-    bytes::Variable(l.spec_into())
+    bytes::Variable((usize::spec_from(l)) as usize)
 }
 
 impl View for OpaqueU16Cont0 {
@@ -275,22 +275,26 @@ type OpaqueU16Cont0Input<'a, 'b, 'x> = POrSType<OpaqueU16Cont0Type<'a, 'b>, Opaq
 impl<'a, 'b, 'x> Continuation<OpaqueU16Cont0Input<'a, 'b, 'x>> for OpaqueU16Cont0 {
     type Output = bytes::Variable;
 
-    open spec fn requires(&self, deps: OpaqueU16Cont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: OpaqueU16Cont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Le, predicate: Predicate17626095872143391426 }).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: OpaqueU16Cont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_opaque_u16_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_opaque_u16_cont0(deps@)
     }
 
     fn apply(&self, deps: OpaqueU16Cont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                bytes::Variable(l.ex_into())
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
         }
     }
@@ -354,7 +358,7 @@ pub type RepeatFixCombinatorAlias = RepeatN<U16Le>;
 
 
 pub open spec fn spec_repeat_fix() -> SpecRepeatFixCombinator {
-    SpecRepeatFixCombinator(RepeatN(U16Le, 32))
+    SpecRepeatFixCombinator(RepeatN(U16Le, (32) as usize))
 }
 
                 
@@ -363,7 +367,7 @@ pub fn repeat_fix<'a>() -> (o: RepeatFixCombinator)
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = RepeatFixCombinator(RepeatN(U16Le, 32));
+    let combinator = RepeatFixCombinator(RepeatN(U16Le, (32) as usize));
     // assert({
     //     &&& combinator@ == spec_repeat_fix()
     //     &&& combinator@.requires()
@@ -693,7 +697,7 @@ pub open spec fn spec_responder_id_list() -> SpecResponderIdListCombinator {
 
 pub open spec fn spec_responder_id_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecResponderIdCombinator>> {
     let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_responder_id()))
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_responder_id()))
 }
 
 impl View for ResponderIdListCont0 {
@@ -773,22 +777,26 @@ type ResponderIdListCont0Input<'a, 'b, 'x> = POrSType<ResponderIdListCont0Type<'
 impl<'a, 'b, 'x> Continuation<ResponderIdListCont0Input<'a, 'b, 'x>> for ResponderIdListCont0 {
     type Output = AndThen<bytes::Variable, Repeat<ResponderIdCombinator>>;
 
-    open spec fn requires(&self, deps: ResponderIdListCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: ResponderIdListCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Le, predicate: Predicate2984462868727922620 }).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: ResponderIdListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_responder_id_list_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_responder_id_list_cont0(deps@)
     }
 
     fn apply(&self, deps: ResponderIdListCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(responder_id()))
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(responder_id()))
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(responder_id()))
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(responder_id()))
             }
         }
     }
@@ -935,7 +943,7 @@ pub open spec fn spec_repeat_dyn() -> SpecRepeatDynCombinator {
 
 pub open spec fn spec_repeat_dyn_cont0(deps: VarInt) -> RepeatN<SpecResponderIdListCombinator> {
     let l = deps;
-    RepeatN(spec_responder_id_list(), l.spec_into())
+    RepeatN(spec_responder_id_list(), (usize::spec_from(l)) as usize)
 }
 
 impl View for RepeatDynCont0 {
@@ -1015,22 +1023,26 @@ type RepeatDynCont0Input<'a, 'b, 'x> = POrSType<RepeatDynCont0Type<'a, 'b>, Repe
 impl<'a, 'b, 'x> Continuation<RepeatDynCont0Input<'a, 'b, 'x>> for RepeatDynCont0 {
     type Output = RepeatN<ResponderIdListCombinator>;
 
-    open spec fn requires(&self, deps: RepeatDynCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: RepeatDynCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (BtcVarint).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: RepeatDynCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_repeat_dyn_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_repeat_dyn_cont0(deps@)
     }
 
     fn apply(&self, deps: RepeatDynCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(responder_id_list(), l.ex_into())
+                let l = deps;
+                let l = *l;
+                RepeatN(responder_id_list(), (usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                RepeatN(responder_id_list(), l.ex_into())
+                RepeatN(responder_id_list(), (usize::ex_from(l)) as usize)
             }
         }
     }
diff --git a/vest-dsl/tls/parse.output b/vest-dsl/tls/parse.output
new file mode 100644
index 00000000..b2e1cab5
--- /dev/null
+++ b/vest-dsl/tls/parse.output
@@ -0,0 +1,12266 @@
+Number of client msgs: 135
+Number of server msgs: 167
+domain: google.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [251, 231, 158, 219, 85, 206, 74, 141, 119, 68, 105, 97, 11, 136, 185, 23, 118, 108, 219, 71, 143, 78, 235, 172, 248, 255, 220, 32, 131, 103, 144, 115] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [103, 111, 111, 103, 108, 101, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [103, 111, 111, 103, 108, 101, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [103, 111, 111, 103, 108, 101, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 111, 111, 103, 108, 101, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 111, 111, 103, 108, 101, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 111, 111, 103, 108, 101, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 111, 111, 103, 108, 101, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [235, 12, 124, 239, 168, 11, 74, 200, 207, 96, 80, 69, 155, 202, 193, 160, 149, 239, 150, 17, 59, 204, 218, 16, 229, 200, 7, 17, 236, 127, 254, 100] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [235, 12, 124, 239, 168, 11, 74, 200, 207, 96, 80, 69, 155, 202, 193, 160, 149, 239, 150, 17, 59, 204, 218, 16, 229, 200, 7, 17, 236, 127, 254, 100] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [235, 12, 124, 239, 168, 11, 74, 200, 207, 96, 80, 69, 155, 202, 193, 160, 149, 239, 150, 17, 59, 204, 218, 16, 229, 200, 7, 17, 236, 127, 254, 100] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [235, 12, 124, 239, 168, 11, 74, 200, 207, 96, 80, 69, 155, 202, 193, 160, 149, 239, 150, 17, 59, 204, 218, 16, 229, 200, 7, 17, 236, 127, 254, 100] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 111, 111, 103, 108, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [235, 12, 124, 239, 168, 11, 74, 200, 207, 96, 80, 69, 155, 202, 193, 160, 149, 239, 150, 17, 59, 204, 218, 16, 229, 200, 7, 17, 236, 127, 254, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [127, 183, 151, 234, 249, 81, 18, 246, 233, 165, 33, 116, 18, 236, 32, 81, 23, 76, 142, 20, 122, 206, 189, 107, 127, 35, 120, 140, 103, 121, 142, 169], legacy_session_id: SessionId { l: 32, id: [251, 231, 158, 219, 85, 206, 74, 141, 119, 68, 105, 97, 11, 136, 185, 23, 118, 108, 219, 71, 143, 78, 235, 172, 248, 255, 220, 32, 131, 103, 144, 115] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 111, 111, 103, 108, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [235, 12, 124, 239, 168, 11, 74, 200, 207, 96, 80, 69, 155, 202, 193, 160, 149, 239, 150, 17, 59, 204, 218, 16, 229, 200, 7, 17, 236, 127, 254, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [127, 183, 151, 234, 249, 81, 18, 246, 233, 165, 33, 116, 18, 236, 32, 81, 23, 76, 142, 20, 122, 206, 189, 107, 127, 35, 120, 140, 103, 121, 142, 169], legacy_session_id: SessionId { l: 32, id: [251, 231, 158, 219, 85, 206, 74, 141, 119, 68, 105, 97, 11, 136, 185, 23, 118, 108, 219, 71, 143, 78, 235, 172, 248, 255, 220, 32, 131, 103, 144, 115] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 111, 111, 103, 108, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [235, 12, 124, 239, 168, 11, 74, 200, 207, 96, 80, 69, 155, 202, 193, 160, 149, 239, 150, 17, 59, 204, 218, 16, 229, 200, 7, 17, 236, 127, 254, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [127, 183, 151, 234, 249, 81, 18, 246, 233, 165, 33, 116, 18, 236, 32, 81, 23, 76, 142, 20, 122, 206, 189, 107, 127, 35, 120, 140, 103, 121, 142, 169], legacy_session_id: SessionId { l: 32, id: [251, 231, 158, 219, 85, 206, 74, 141, 119, 68, 105, 97, 11, 136, 185, 23, 118, 108, 219, 71, 143, 78, 235, 172, 248, 255, 220, 32, 131, 103, 144, 115] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 111, 111, 103, 108, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [235, 12, 124, 239, 168, 11, 74, 200, 207, 96, 80, 69, 155, 202, 193, 160, 149, 239, 150, 17, 59, 204, 218, 16, 229, 200, 7, 17, 236, 127, 254, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: microsoft.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [0, 235, 132, 97, 194, 83, 207, 188, 34, 55, 62, 144, 89, 10, 118, 244, 119, 148, 132, 66, 38, 42, 209, 43, 88, 94, 203, 210, 196, 226, 6, 146] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((15, Opaque1Ffff { l: 13, data: [109, 105, 99, 114, 111, 115, 111, 102, 116, 46, 99, 111, 109] }))
+[trace] HostName: Ok((15, Opaque1Ffff { l: 13, data: [109, 105, 99, 114, 111, 115, 111, 102, 116, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((15, HostName(Opaque1Ffff { l: 13, data: [109, 105, 99, 114, 111, 115, 111, 102, 116, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((16, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [109, 105, 99, 114, 111, 115, 111, 102, 116, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((18, ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [109, 105, 99, 114, 111, 115, 111, 102, 116, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((18, ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [109, 105, 99, 114, 111, 115, 111, 102, 116, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((22, ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [109, 105, 99, 114, 111, 115, 111, 102, 116, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [168, 231, 17, 49, 14, 204, 205, 34, 31, 133, 249, 188, 195, 234, 30, 86, 174, 42, 131, 131, 116, 29, 177, 68, 46, 71, 202, 77, 255, 193, 88, 96] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 231, 17, 49, 14, 204, 205, 34, 31, 133, 249, 188, 195, 234, 30, 86, 174, 42, 131, 131, 116, 29, 177, 68, 46, 71, 202, 77, 255, 193, 88, 96] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 231, 17, 49, 14, 204, 205, 34, 31, 133, 249, 188, 195, 234, 30, 86, 174, 42, 131, 131, 116, 29, 177, 68, 46, 71, 202, 77, 255, 193, 88, 96] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 231, 17, 49, 14, 204, 205, 34, 31, 133, 249, 188, 195, 234, 30, 86, 174, 42, 131, 131, 116, 29, 177, 68, 46, 71, 202, 77, 255, 193, 88, 96] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((218, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((218, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((222, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [109, 105, 99, 114, 111, 115, 111, 102, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 231, 17, 49, 14, 204, 205, 34, 31, 133, 249, 188, 195, 234, 30, 86, 174, 42, 131, 131, 116, 29, 177, 68, 46, 71, 202, 77, 255, 193, 88, 96] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [125, 165, 207, 211, 25, 148, 98, 137, 233, 18, 108, 162, 244, 250, 54, 109, 102, 45, 138, 248, 133, 240, 148, 165, 128, 228, 138, 225, 147, 190, 99, 156], legacy_session_id: SessionId { l: 32, id: [0, 235, 132, 97, 194, 83, 207, 188, 34, 55, 62, 144, 89, 10, 118, 244, 119, 148, 132, 66, 38, 42, 209, 43, 88, 94, 203, 210, 196, 226, 6, 146] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [109, 105, 99, 114, 111, 115, 111, 102, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 231, 17, 49, 14, 204, 205, 34, 31, 133, 249, 188, 195, 234, 30, 86, 174, 42, 131, 131, 116, 29, 177, 68, 46, 71, 202, 77, 255, 193, 88, 96] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [125, 165, 207, 211, 25, 148, 98, 137, 233, 18, 108, 162, 244, 250, 54, 109, 102, 45, 138, 248, 133, 240, 148, 165, 128, 228, 138, 225, 147, 190, 99, 156], legacy_session_id: SessionId { l: 32, id: [0, 235, 132, 97, 194, 83, 207, 188, 34, 55, 62, 144, 89, 10, 118, 244, 119, 148, 132, 66, 38, 42, 209, 43, 88, 94, 203, 210, 196, 226, 6, 146] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [109, 105, 99, 114, 111, 115, 111, 102, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 231, 17, 49, 14, 204, 205, 34, 31, 133, 249, 188, 195, 234, 30, 86, 174, 42, 131, 131, 116, 29, 177, 68, 46, 71, 202, 77, 255, 193, 88, 96] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [125, 165, 207, 211, 25, 148, 98, 137, 233, 18, 108, 162, 244, 250, 54, 109, 102, 45, 138, 248, 133, 240, 148, 165, 128, 228, 138, 225, 147, 190, 99, 156], legacy_session_id: SessionId { l: 32, id: [0, 235, 132, 97, 194, 83, 207, 188, 34, 55, 62, 144, 89, 10, 118, 244, 119, 148, 132, 66, 38, 42, 209, 43, 88, 94, 203, 210, 196, 226, 6, 146] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [109, 105, 99, 114, 111, 115, 111, 102, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 231, 17, 49, 14, 204, 205, 34, 31, 133, 249, 188, 195, 234, 30, 86, 174, 42, 131, 131, 116, 29, 177, 68, 46, 71, 202, 77, 255, 193, 88, 96] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: mail.ru
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [23, 86, 83, 170, 81, 83, 227, 117, 151, 141, 99, 135, 114, 12, 137, 139, 160, 250, 250, 97, 9, 135, 187, 122, 177, 202, 12, 42, 159, 179, 77, 32] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((9, Opaque1Ffff { l: 7, data: [109, 97, 105, 108, 46, 114, 117] }))
+[trace] HostName: Ok((9, Opaque1Ffff { l: 7, data: [109, 97, 105, 108, 46, 114, 117] }))
+[trace] ServerNameName: Ok((9, HostName(Opaque1Ffff { l: 7, data: [109, 97, 105, 108, 46, 114, 117] })))
+[trace] ServerName: Ok((10, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 97, 105, 108, 46, 114, 117] }) }))
+[trace] ServerNameList: Ok((12, ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 97, 105, 108, 46, 114, 117] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((12, ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 97, 105, 108, 46, 114, 117] }) }]) })))
+[trace] ClientHelloExtension: Ok((16, ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 97, 105, 108, 46, 114, 117] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [81, 138, 85, 249, 87, 176, 94, 161, 32, 48, 40, 150, 228, 143, 152, 56, 165, 95, 11, 216, 55, 120, 80, 200, 44, 217, 87, 231, 220, 90, 215, 13] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [81, 138, 85, 249, 87, 176, 94, 161, 32, 48, 40, 150, 228, 143, 152, 56, 165, 95, 11, 216, 55, 120, 80, 200, 44, 217, 87, 231, 220, 90, 215, 13] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [81, 138, 85, 249, 87, 176, 94, 161, 32, 48, 40, 150, 228, 143, 152, 56, 165, 95, 11, 216, 55, 120, 80, 200, 44, 217, 87, 231, 220, 90, 215, 13] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [81, 138, 85, 249, 87, 176, 94, 161, 32, 48, 40, 150, 228, 143, 152, 56, 165, 95, 11, 216, 55, 120, 80, 200, 44, 217, 87, 231, 220, 90, 215, 13] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((224, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((224, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((228, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 97, 105, 108, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [81, 138, 85, 249, 87, 176, 94, 161, 32, 48, 40, 150, 228, 143, 152, 56, 165, 95, 11, 216, 55, 120, 80, 200, 44, 217, 87, 231, 220, 90, 215, 13] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [61, 156, 240, 146, 100, 119, 30, 235, 72, 20, 106, 229, 205, 14, 218, 78, 166, 124, 202, 183, 205, 75, 130, 180, 204, 1, 183, 88, 107, 211, 47, 115], legacy_session_id: SessionId { l: 32, id: [23, 86, 83, 170, 81, 83, 227, 117, 151, 141, 99, 135, 114, 12, 137, 139, 160, 250, 250, 97, 9, 135, 187, 122, 177, 202, 12, 42, 159, 179, 77, 32] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 97, 105, 108, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [81, 138, 85, 249, 87, 176, 94, 161, 32, 48, 40, 150, 228, 143, 152, 56, 165, 95, 11, 216, 55, 120, 80, 200, 44, 217, 87, 231, 220, 90, 215, 13] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [61, 156, 240, 146, 100, 119, 30, 235, 72, 20, 106, 229, 205, 14, 218, 78, 166, 124, 202, 183, 205, 75, 130, 180, 204, 1, 183, 88, 107, 211, 47, 115], legacy_session_id: SessionId { l: 32, id: [23, 86, 83, 170, 81, 83, 227, 117, 151, 141, 99, 135, 114, 12, 137, 139, 160, 250, 250, 97, 9, 135, 187, 122, 177, 202, 12, 42, 159, 179, 77, 32] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 97, 105, 108, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [81, 138, 85, 249, 87, 176, 94, 161, 32, 48, 40, 150, 228, 143, 152, 56, 165, 95, 11, 216, 55, 120, 80, 200, 44, 217, 87, 231, 220, 90, 215, 13] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [61, 156, 240, 146, 100, 119, 30, 235, 72, 20, 106, 229, 205, 14, 218, 78, 166, 124, 202, 183, 205, 75, 130, 180, 204, 1, 183, 88, 107, 211, 47, 115], legacy_session_id: SessionId { l: 32, id: [23, 86, 83, 170, 81, 83, 227, 117, 151, 141, 99, 135, 114, 12, 137, 139, 160, 250, 250, 97, 9, 135, 187, 122, 177, 202, 12, 42, 159, 179, 77, 32] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 97, 105, 108, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [81, 138, 85, 249, 87, 176, 94, 161, 32, 48, 40, 150, 228, 143, 152, 56, 165, 95, 11, 216, 55, 120, 80, 200, 44, 217, 87, 231, 220, 90, 215, 13] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(20a1c62ee6c64ef6869de22a61fbf4dba8b55f5f09665287c0d3953baf76a75708) }, encoded: 1000002120a1c62ee6c64ef6869de22a61fbf4dba8b55f5f09665287c0d3953baf76a75708 }
+=====================================
+domain: facebook.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [109, 201, 206, 240, 10, 226, 180, 12, 88, 94, 19, 123, 176, 201, 209, 102, 191, 211, 68, 88, 111, 37, 33, 132, 201, 28, 1, 222, 93, 201, 161, 129] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((14, Opaque1Ffff { l: 12, data: [102, 97, 99, 101, 98, 111, 111, 107, 46, 99, 111, 109] }))
+[trace] HostName: Ok((14, Opaque1Ffff { l: 12, data: [102, 97, 99, 101, 98, 111, 111, 107, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((14, HostName(Opaque1Ffff { l: 12, data: [102, 97, 99, 101, 98, 111, 111, 107, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((15, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [102, 97, 99, 101, 98, 111, 111, 107, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((17, ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [102, 97, 99, 101, 98, 111, 111, 107, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((17, ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [102, 97, 99, 101, 98, 111, 111, 107, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((21, ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [102, 97, 99, 101, 98, 111, 111, 107, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [217, 212, 134, 56, 56, 166, 144, 164, 181, 66, 242, 222, 156, 221, 231, 137, 91, 164, 198, 61, 165, 4, 70, 41, 235, 247, 222, 209, 241, 112, 10, 50] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 212, 134, 56, 56, 166, 144, 164, 181, 66, 242, 222, 156, 221, 231, 137, 91, 164, 198, 61, 165, 4, 70, 41, 235, 247, 222, 209, 241, 112, 10, 50] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 212, 134, 56, 56, 166, 144, 164, 181, 66, 242, 222, 156, 221, 231, 137, 91, 164, 198, 61, 165, 4, 70, 41, 235, 247, 222, 209, 241, 112, 10, 50] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 212, 134, 56, 56, 166, 144, 164, 181, 66, 242, 222, 156, 221, 231, 137, 91, 164, 198, 61, 165, 4, 70, 41, 235, 247, 222, 209, 241, 112, 10, 50] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((219, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((219, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((223, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [102, 97, 99, 101, 98, 111, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 212, 134, 56, 56, 166, 144, 164, 181, 66, 242, 222, 156, 221, 231, 137, 91, 164, 198, 61, 165, 4, 70, 41, 235, 247, 222, 209, 241, 112, 10, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [249, 251, 179, 217, 251, 92, 220, 134, 191, 116, 223, 39, 28, 189, 255, 14, 47, 255, 119, 95, 114, 1, 157, 115, 12, 151, 19, 188, 197, 11, 254, 112], legacy_session_id: SessionId { l: 32, id: [109, 201, 206, 240, 10, 226, 180, 12, 88, 94, 19, 123, 176, 201, 209, 102, 191, 211, 68, 88, 111, 37, 33, 132, 201, 28, 1, 222, 93, 201, 161, 129] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [102, 97, 99, 101, 98, 111, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 212, 134, 56, 56, 166, 144, 164, 181, 66, 242, 222, 156, 221, 231, 137, 91, 164, 198, 61, 165, 4, 70, 41, 235, 247, 222, 209, 241, 112, 10, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [249, 251, 179, 217, 251, 92, 220, 134, 191, 116, 223, 39, 28, 189, 255, 14, 47, 255, 119, 95, 114, 1, 157, 115, 12, 151, 19, 188, 197, 11, 254, 112], legacy_session_id: SessionId { l: 32, id: [109, 201, 206, 240, 10, 226, 180, 12, 88, 94, 19, 123, 176, 201, 209, 102, 191, 211, 68, 88, 111, 37, 33, 132, 201, 28, 1, 222, 93, 201, 161, 129] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [102, 97, 99, 101, 98, 111, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 212, 134, 56, 56, 166, 144, 164, 181, 66, 242, 222, 156, 221, 231, 137, 91, 164, 198, 61, 165, 4, 70, 41, 235, 247, 222, 209, 241, 112, 10, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [249, 251, 179, 217, 251, 92, 220, 134, 191, 116, 223, 39, 28, 189, 255, 14, 47, 255, 119, 95, 114, 1, 157, 115, 12, 151, 19, 188, 197, 11, 254, 112], legacy_session_id: SessionId { l: 32, id: [109, 201, 206, 240, 10, 226, 180, 12, 88, 94, 19, 123, 176, 201, 209, 102, 191, 211, 68, 88, 111, 37, 33, 132, 201, 28, 1, 222, 93, 201, 161, 129] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [102, 97, 99, 101, 98, 111, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 212, 134, 56, 56, 166, 144, 164, 181, 66, 242, 222, 156, 221, 231, 137, 91, 164, 198, 61, 165, 4, 70, 41, 235, 247, 222, 209, 241, 112, 10, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: dzen.ru
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [68, 38, 255, 67, 153, 208, 204, 210, 20, 96, 51, 7, 248, 53, 122, 156, 190, 184, 39, 139, 183, 175, 111, 170, 147, 162, 237, 86, 143, 251, 163, 107] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((9, Opaque1Ffff { l: 7, data: [100, 122, 101, 110, 46, 114, 117] }))
+[trace] HostName: Ok((9, Opaque1Ffff { l: 7, data: [100, 122, 101, 110, 46, 114, 117] }))
+[trace] ServerNameName: Ok((9, HostName(Opaque1Ffff { l: 7, data: [100, 122, 101, 110, 46, 114, 117] })))
+[trace] ServerName: Ok((10, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [100, 122, 101, 110, 46, 114, 117] }) }))
+[trace] ServerNameList: Ok((12, ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [100, 122, 101, 110, 46, 114, 117] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((12, ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [100, 122, 101, 110, 46, 114, 117] }) }]) })))
+[trace] ClientHelloExtension: Ok((16, ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [100, 122, 101, 110, 46, 114, 117] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [0, 188, 211, 208, 208, 200, 57, 152, 52, 234, 90, 174, 99, 241, 133, 87, 61, 115, 228, 63, 27, 100, 71, 79, 124, 235, 92, 241, 72, 151, 71, 52] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [0, 188, 211, 208, 208, 200, 57, 152, 52, 234, 90, 174, 99, 241, 133, 87, 61, 115, 228, 63, 27, 100, 71, 79, 124, 235, 92, 241, 72, 151, 71, 52] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [0, 188, 211, 208, 208, 200, 57, 152, 52, 234, 90, 174, 99, 241, 133, 87, 61, 115, 228, 63, 27, 100, 71, 79, 124, 235, 92, 241, 72, 151, 71, 52] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [0, 188, 211, 208, 208, 200, 57, 152, 52, 234, 90, 174, 99, 241, 133, 87, 61, 115, 228, 63, 27, 100, 71, 79, 124, 235, 92, 241, 72, 151, 71, 52] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((224, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((224, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((228, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [100, 122, 101, 110, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [0, 188, 211, 208, 208, 200, 57, 152, 52, 234, 90, 174, 99, 241, 133, 87, 61, 115, 228, 63, 27, 100, 71, 79, 124, 235, 92, 241, 72, 151, 71, 52] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [31, 104, 41, 116, 154, 98, 6, 203, 122, 147, 158, 100, 193, 99, 54, 34, 47, 10, 64, 47, 58, 188, 65, 74, 170, 84, 108, 82, 126, 193, 190, 129], legacy_session_id: SessionId { l: 32, id: [68, 38, 255, 67, 153, 208, 204, 210, 20, 96, 51, 7, 248, 53, 122, 156, 190, 184, 39, 139, 183, 175, 111, 170, 147, 162, 237, 86, 143, 251, 163, 107] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [100, 122, 101, 110, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [0, 188, 211, 208, 208, 200, 57, 152, 52, 234, 90, 174, 99, 241, 133, 87, 61, 115, 228, 63, 27, 100, 71, 79, 124, 235, 92, 241, 72, 151, 71, 52] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [31, 104, 41, 116, 154, 98, 6, 203, 122, 147, 158, 100, 193, 99, 54, 34, 47, 10, 64, 47, 58, 188, 65, 74, 170, 84, 108, 82, 126, 193, 190, 129], legacy_session_id: SessionId { l: 32, id: [68, 38, 255, 67, 153, 208, 204, 210, 20, 96, 51, 7, 248, 53, 122, 156, 190, 184, 39, 139, 183, 175, 111, 170, 147, 162, 237, 86, 143, 251, 163, 107] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [100, 122, 101, 110, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [0, 188, 211, 208, 208, 200, 57, 152, 52, 234, 90, 174, 99, 241, 133, 87, 61, 115, 228, 63, 27, 100, 71, 79, 124, 235, 92, 241, 72, 151, 71, 52] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [31, 104, 41, 116, 154, 98, 6, 203, 122, 147, 158, 100, 193, 99, 54, 34, 47, 10, 64, 47, 58, 188, 65, 74, 170, 84, 108, 82, 126, 193, 190, 129], legacy_session_id: SessionId { l: 32, id: [68, 38, 255, 67, 153, 208, 204, 210, 20, 96, 51, 7, 248, 53, 122, 156, 190, 184, 39, 139, 183, 175, 111, 170, 147, 162, 237, 86, 143, 251, 163, 107] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [100, 122, 101, 110, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [0, 188, 211, 208, 208, 200, 57, 152, 52, 234, 90, 174, 99, 241, 133, 87, 61, 115, 228, 63, 27, 100, 71, 79, 124, 235, 92, 241, 72, 151, 71, 52] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(204fb0b238ec9c8d0d235bfa9f9eaded392fb1d289292720e0e958c19821b7987e) }, encoded: 10000021204fb0b238ec9c8d0d235bfa9f9eaded392fb1d289292720e0e958c19821b7987e }
+=====================================
+domain: apple.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [59, 194, 213, 254, 117, 26, 234, 182, 151, 101, 208, 121, 49, 141, 19, 163, 115, 89, 14, 197, 108, 144, 88, 202, 131, 169, 232, 12, 123, 92, 182, 58] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [97, 112, 112, 108, 101, 46, 99, 111, 109] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [97, 112, 112, 108, 101, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [97, 112, 112, 108, 101, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 112, 112, 108, 101, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 112, 112, 108, 101, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 112, 112, 108, 101, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 112, 112, 108, 101, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [246, 19, 163, 142, 82, 141, 152, 236, 117, 144, 178, 29, 146, 96, 136, 122, 159, 136, 14, 161, 71, 247, 157, 71, 48, 120, 210, 120, 161, 143, 169, 109] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [246, 19, 163, 142, 82, 141, 152, 236, 117, 144, 178, 29, 146, 96, 136, 122, 159, 136, 14, 161, 71, 247, 157, 71, 48, 120, 210, 120, 161, 143, 169, 109] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [246, 19, 163, 142, 82, 141, 152, 236, 117, 144, 178, 29, 146, 96, 136, 122, 159, 136, 14, 161, 71, 247, 157, 71, 48, 120, 210, 120, 161, 143, 169, 109] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [246, 19, 163, 142, 82, 141, 152, 236, 117, 144, 178, 29, 146, 96, 136, 122, 159, 136, 14, 161, 71, 247, 157, 71, 48, 120, 210, 120, 161, 143, 169, 109] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 112, 112, 108, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [246, 19, 163, 142, 82, 141, 152, 236, 117, 144, 178, 29, 146, 96, 136, 122, 159, 136, 14, 161, 71, 247, 157, 71, 48, 120, 210, 120, 161, 143, 169, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [133, 225, 14, 48, 6, 57, 87, 104, 88, 205, 234, 65, 210, 179, 37, 163, 1, 36, 168, 226, 169, 237, 35, 140, 201, 30, 235, 81, 167, 124, 229, 184], legacy_session_id: SessionId { l: 32, id: [59, 194, 213, 254, 117, 26, 234, 182, 151, 101, 208, 121, 49, 141, 19, 163, 115, 89, 14, 197, 108, 144, 88, 202, 131, 169, 232, 12, 123, 92, 182, 58] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 112, 112, 108, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [246, 19, 163, 142, 82, 141, 152, 236, 117, 144, 178, 29, 146, 96, 136, 122, 159, 136, 14, 161, 71, 247, 157, 71, 48, 120, 210, 120, 161, 143, 169, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [133, 225, 14, 48, 6, 57, 87, 104, 88, 205, 234, 65, 210, 179, 37, 163, 1, 36, 168, 226, 169, 237, 35, 140, 201, 30, 235, 81, 167, 124, 229, 184], legacy_session_id: SessionId { l: 32, id: [59, 194, 213, 254, 117, 26, 234, 182, 151, 101, 208, 121, 49, 141, 19, 163, 115, 89, 14, 197, 108, 144, 88, 202, 131, 169, 232, 12, 123, 92, 182, 58] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 112, 112, 108, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [246, 19, 163, 142, 82, 141, 152, 236, 117, 144, 178, 29, 146, 96, 136, 122, 159, 136, 14, 161, 71, 247, 157, 71, 48, 120, 210, 120, 161, 143, 169, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [133, 225, 14, 48, 6, 57, 87, 104, 88, 205, 234, 65, 210, 179, 37, 163, 1, 36, 168, 226, 169, 237, 35, 140, 201, 30, 235, 81, 167, 124, 229, 184], legacy_session_id: SessionId { l: 32, id: [59, 194, 213, 254, 117, 26, 234, 182, 151, 101, 208, 121, 49, 141, 19, 163, 115, 89, 14, 197, 108, 144, 88, 202, 131, 169, 232, 12, 123, 92, 182, 58] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 112, 112, 108, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [246, 19, 163, 142, 82, 141, 152, 236, 117, 144, 178, 29, 146, 96, 136, 122, 159, 136, 14, 161, 71, 247, 157, 71, 48, 120, 210, 120, 161, 143, 169, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: youtube.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [133, 105, 16, 46, 131, 150, 221, 2, 9, 131, 26, 136, 249, 197, 247, 181, 250, 61, 3, 25, 230, 119, 104, 247, 183, 202, 154, 90, 244, 78, 57, 205] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [136, 6, 28, 212, 46, 139, 163, 30, 96, 1, 233, 27, 13, 83, 147, 19, 94, 94, 190, 15, 248, 90, 74, 57, 108, 121, 168, 41, 223, 182, 161, 99] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [136, 6, 28, 212, 46, 139, 163, 30, 96, 1, 233, 27, 13, 83, 147, 19, 94, 94, 190, 15, 248, 90, 74, 57, 108, 121, 168, 41, 223, 182, 161, 99] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [136, 6, 28, 212, 46, 139, 163, 30, 96, 1, 233, 27, 13, 83, 147, 19, 94, 94, 190, 15, 248, 90, 74, 57, 108, 121, 168, 41, 223, 182, 161, 99] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [136, 6, 28, 212, 46, 139, 163, 30, 96, 1, 233, 27, 13, 83, 147, 19, 94, 94, 190, 15, 248, 90, 74, 57, 108, 121, 168, 41, 223, 182, 161, 99] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [136, 6, 28, 212, 46, 139, 163, 30, 96, 1, 233, 27, 13, 83, 147, 19, 94, 94, 190, 15, 248, 90, 74, 57, 108, 121, 168, 41, 223, 182, 161, 99] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [191, 251, 224, 197, 104, 139, 50, 66, 129, 37, 123, 157, 104, 177, 104, 89, 26, 173, 185, 107, 89, 201, 153, 146, 0, 57, 198, 147, 206, 226, 235, 102], legacy_session_id: SessionId { l: 32, id: [133, 105, 16, 46, 131, 150, 221, 2, 9, 131, 26, 136, 249, 197, 247, 181, 250, 61, 3, 25, 230, 119, 104, 247, 183, 202, 154, 90, 244, 78, 57, 205] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [136, 6, 28, 212, 46, 139, 163, 30, 96, 1, 233, 27, 13, 83, 147, 19, 94, 94, 190, 15, 248, 90, 74, 57, 108, 121, 168, 41, 223, 182, 161, 99] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [191, 251, 224, 197, 104, 139, 50, 66, 129, 37, 123, 157, 104, 177, 104, 89, 26, 173, 185, 107, 89, 201, 153, 146, 0, 57, 198, 147, 206, 226, 235, 102], legacy_session_id: SessionId { l: 32, id: [133, 105, 16, 46, 131, 150, 221, 2, 9, 131, 26, 136, 249, 197, 247, 181, 250, 61, 3, 25, 230, 119, 104, 247, 183, 202, 154, 90, 244, 78, 57, 205] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [136, 6, 28, 212, 46, 139, 163, 30, 96, 1, 233, 27, 13, 83, 147, 19, 94, 94, 190, 15, 248, 90, 74, 57, 108, 121, 168, 41, 223, 182, 161, 99] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [191, 251, 224, 197, 104, 139, 50, 66, 129, 37, 123, 157, 104, 177, 104, 89, 26, 173, 185, 107, 89, 201, 153, 146, 0, 57, 198, 147, 206, 226, 235, 102], legacy_session_id: SessionId { l: 32, id: [133, 105, 16, 46, 131, 150, 221, 2, 9, 131, 26, 136, 249, 197, 247, 181, 250, 61, 3, 25, 230, 119, 104, 247, 183, 202, 154, 90, 244, 78, 57, 205] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [121, 111, 117, 116, 117, 98, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [136, 6, 28, 212, 46, 139, 163, 30, 96, 1, 233, 27, 13, 83, 147, 19, 94, 94, 190, 15, 248, 90, 74, 57, 108, 121, 168, 41, 223, 182, 161, 99] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: googleapis.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [85, 31, 198, 100, 22, 117, 36, 58, 235, 25, 72, 197, 165, 97, 170, 224, 40, 248, 172, 103, 132, 41, 164, 3, 229, 233, 59, 249, 100, 37, 52, 148] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((16, Opaque1Ffff { l: 14, data: [103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109] }))
+[trace] HostName: Ok((16, Opaque1Ffff { l: 14, data: [103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((16, HostName(Opaque1Ffff { l: 14, data: [103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((17, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((19, ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((19, ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((23, ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [168, 107, 247, 154, 19, 30, 121, 49, 110, 143, 141, 197, 155, 176, 9, 75, 137, 149, 60, 16, 152, 52, 222, 255, 136, 13, 74, 172, 33, 60, 148, 21] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 107, 247, 154, 19, 30, 121, 49, 110, 143, 141, 197, 155, 176, 9, 75, 137, 149, 60, 16, 152, 52, 222, 255, 136, 13, 74, 172, 33, 60, 148, 21] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 107, 247, 154, 19, 30, 121, 49, 110, 143, 141, 197, 155, 176, 9, 75, 137, 149, 60, 16, 152, 52, 222, 255, 136, 13, 74, 172, 33, 60, 148, 21] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 107, 247, 154, 19, 30, 121, 49, 110, 143, 141, 197, 155, 176, 9, 75, 137, 149, 60, 16, 152, 52, 222, 255, 136, 13, 74, 172, 33, 60, 148, 21] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((217, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((217, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((221, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 107, 247, 154, 19, 30, 121, 49, 110, 143, 141, 197, 155, 176, 9, 75, 137, 149, 60, 16, 152, 52, 222, 255, 136, 13, 74, 172, 33, 60, 148, 21] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [186, 38, 79, 192, 242, 91, 25, 241, 145, 29, 230, 205, 241, 153, 63, 7, 223, 140, 231, 53, 72, 108, 46, 196, 155, 47, 82, 189, 118, 66, 129, 60], legacy_session_id: SessionId { l: 32, id: [85, 31, 198, 100, 22, 117, 36, 58, 235, 25, 72, 197, 165, 97, 170, 224, 40, 248, 172, 103, 132, 41, 164, 3, 229, 233, 59, 249, 100, 37, 52, 148] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 107, 247, 154, 19, 30, 121, 49, 110, 143, 141, 197, 155, 176, 9, 75, 137, 149, 60, 16, 152, 52, 222, 255, 136, 13, 74, 172, 33, 60, 148, 21] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [186, 38, 79, 192, 242, 91, 25, 241, 145, 29, 230, 205, 241, 153, 63, 7, 223, 140, 231, 53, 72, 108, 46, 196, 155, 47, 82, 189, 118, 66, 129, 60], legacy_session_id: SessionId { l: 32, id: [85, 31, 198, 100, 22, 117, 36, 58, 235, 25, 72, 197, 165, 97, 170, 224, 40, 248, 172, 103, 132, 41, 164, 3, 229, 233, 59, 249, 100, 37, 52, 148] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 107, 247, 154, 19, 30, 121, 49, 110, 143, 141, 197, 155, 176, 9, 75, 137, 149, 60, 16, 152, 52, 222, 255, 136, 13, 74, 172, 33, 60, 148, 21] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [186, 38, 79, 192, 242, 91, 25, 241, 145, 29, 230, 205, 241, 153, 63, 7, 223, 140, 231, 53, 72, 108, 46, 196, 155, 47, 82, 189, 118, 66, 129, 60], legacy_session_id: SessionId { l: 32, id: [85, 31, 198, 100, 22, 117, 36, 58, 235, 25, 72, 197, 165, 97, 170, 224, 40, 248, 172, 103, 132, 41, 164, 3, 229, 233, 59, 249, 100, 37, 52, 148] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [168, 107, 247, 154, 19, 30, 121, 49, 110, 143, 141, 197, 155, 176, 9, 75, 137, 149, 60, 16, 152, 52, 222, 255, 136, 13, 74, 172, 33, 60, 148, 21] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: cloudflare.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [105, 178, 46, 239, 136, 245, 120, 224, 106, 1, 65, 125, 93, 139, 56, 254, 166, 67, 226, 10, 120, 117, 53, 231, 82, 111, 181, 123, 6, 79, 30, 79] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((16, Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 99, 111, 109] }))
+[trace] HostName: Ok((16, Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((16, HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((17, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((19, ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((19, ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((23, ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [1, 117, 7, 217, 75, 35, 68, 169, 66, 124, 154, 192, 209, 134, 201, 164, 8, 231, 78, 26, 113, 226, 93, 117, 226, 227, 75, 117, 216, 123, 171, 97] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [1, 117, 7, 217, 75, 35, 68, 169, 66, 124, 154, 192, 209, 134, 201, 164, 8, 231, 78, 26, 113, 226, 93, 117, 226, 227, 75, 117, 216, 123, 171, 97] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [1, 117, 7, 217, 75, 35, 68, 169, 66, 124, 154, 192, 209, 134, 201, 164, 8, 231, 78, 26, 113, 226, 93, 117, 226, 227, 75, 117, 216, 123, 171, 97] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [1, 117, 7, 217, 75, 35, 68, 169, 66, 124, 154, 192, 209, 134, 201, 164, 8, 231, 78, 26, 113, 226, 93, 117, 226, 227, 75, 117, 216, 123, 171, 97] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((217, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((217, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((221, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [1, 117, 7, 217, 75, 35, 68, 169, 66, 124, 154, 192, 209, 134, 201, 164, 8, 231, 78, 26, 113, 226, 93, 117, 226, 227, 75, 117, 216, 123, 171, 97] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [68, 74, 67, 86, 9, 213, 229, 76, 112, 165, 45, 66, 179, 188, 93, 68, 239, 199, 182, 161, 207, 239, 135, 127, 171, 61, 231, 163, 167, 166, 141, 17], legacy_session_id: SessionId { l: 32, id: [105, 178, 46, 239, 136, 245, 120, 224, 106, 1, 65, 125, 93, 139, 56, 254, 166, 67, 226, 10, 120, 117, 53, 231, 82, 111, 181, 123, 6, 79, 30, 79] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [1, 117, 7, 217, 75, 35, 68, 169, 66, 124, 154, 192, 209, 134, 201, 164, 8, 231, 78, 26, 113, 226, 93, 117, 226, 227, 75, 117, 216, 123, 171, 97] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [68, 74, 67, 86, 9, 213, 229, 76, 112, 165, 45, 66, 179, 188, 93, 68, 239, 199, 182, 161, 207, 239, 135, 127, 171, 61, 231, 163, 167, 166, 141, 17], legacy_session_id: SessionId { l: 32, id: [105, 178, 46, 239, 136, 245, 120, 224, 106, 1, 65, 125, 93, 139, 56, 254, 166, 67, 226, 10, 120, 117, 53, 231, 82, 111, 181, 123, 6, 79, 30, 79] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [1, 117, 7, 217, 75, 35, 68, 169, 66, 124, 154, 192, 209, 134, 201, 164, 8, 231, 78, 26, 113, 226, 93, 117, 226, 227, 75, 117, 216, 123, 171, 97] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [68, 74, 67, 86, 9, 213, 229, 76, 112, 165, 45, 66, 179, 188, 93, 68, 239, 199, 182, 161, 207, 239, 135, 127, 171, 61, 231, 163, 167, 166, 141, 17], legacy_session_id: SessionId { l: 32, id: [105, 178, 46, 239, 136, 245, 120, 224, 106, 1, 65, 125, 93, 139, 56, 254, 166, 67, 226, 10, 120, 117, 53, 231, 82, 111, 181, 123, 6, 79, 30, 79] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [1, 117, 7, 217, 75, 35, 68, 169, 66, 124, 154, 192, 209, 134, 201, 164, 8, 231, 78, 26, 113, 226, 93, 117, 226, 227, 75, 117, 216, 123, 171, 97] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: twitter.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [32, 54, 116, 62, 48, 170, 107, 89, 12, 253, 151, 178, 103, 75, 237, 112, 85, 44, 101, 219, 110, 70, 247, 190, 44, 42, 174, 38, 28, 197, 135, 130] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [116, 119, 105, 116, 116, 101, 114, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [116, 119, 105, 116, 116, 101, 114, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [116, 119, 105, 116, 116, 101, 114, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 119, 105, 116, 116, 101, 114, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 119, 105, 116, 116, 101, 114, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 119, 105, 116, 116, 101, 114, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 119, 105, 116, 116, 101, 114, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [31, 159, 21, 205, 241, 149, 251, 57, 2, 37, 234, 169, 126, 159, 173, 166, 116, 7, 5, 196, 231, 80, 25, 164, 44, 194, 237, 162, 227, 228, 226, 58] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [31, 159, 21, 205, 241, 149, 251, 57, 2, 37, 234, 169, 126, 159, 173, 166, 116, 7, 5, 196, 231, 80, 25, 164, 44, 194, 237, 162, 227, 228, 226, 58] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [31, 159, 21, 205, 241, 149, 251, 57, 2, 37, 234, 169, 126, 159, 173, 166, 116, 7, 5, 196, 231, 80, 25, 164, 44, 194, 237, 162, 227, 228, 226, 58] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [31, 159, 21, 205, 241, 149, 251, 57, 2, 37, 234, 169, 126, 159, 173, 166, 116, 7, 5, 196, 231, 80, 25, 164, 44, 194, 237, 162, 227, 228, 226, 58] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 119, 105, 116, 116, 101, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [31, 159, 21, 205, 241, 149, 251, 57, 2, 37, 234, 169, 126, 159, 173, 166, 116, 7, 5, 196, 231, 80, 25, 164, 44, 194, 237, 162, 227, 228, 226, 58] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [61, 99, 92, 69, 76, 109, 175, 171, 241, 111, 188, 152, 81, 124, 231, 237, 165, 165, 173, 177, 40, 174, 243, 75, 194, 2, 231, 19, 21, 30, 14, 147], legacy_session_id: SessionId { l: 32, id: [32, 54, 116, 62, 48, 170, 107, 89, 12, 253, 151, 178, 103, 75, 237, 112, 85, 44, 101, 219, 110, 70, 247, 190, 44, 42, 174, 38, 28, 197, 135, 130] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 119, 105, 116, 116, 101, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [31, 159, 21, 205, 241, 149, 251, 57, 2, 37, 234, 169, 126, 159, 173, 166, 116, 7, 5, 196, 231, 80, 25, 164, 44, 194, 237, 162, 227, 228, 226, 58] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [61, 99, 92, 69, 76, 109, 175, 171, 241, 111, 188, 152, 81, 124, 231, 237, 165, 165, 173, 177, 40, 174, 243, 75, 194, 2, 231, 19, 21, 30, 14, 147], legacy_session_id: SessionId { l: 32, id: [32, 54, 116, 62, 48, 170, 107, 89, 12, 253, 151, 178, 103, 75, 237, 112, 85, 44, 101, 219, 110, 70, 247, 190, 44, 42, 174, 38, 28, 197, 135, 130] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 119, 105, 116, 116, 101, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [31, 159, 21, 205, 241, 149, 251, 57, 2, 37, 234, 169, 126, 159, 173, 166, 116, 7, 5, 196, 231, 80, 25, 164, 44, 194, 237, 162, 227, 228, 226, 58] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [61, 99, 92, 69, 76, 109, 175, 171, 241, 111, 188, 152, 81, 124, 231, 237, 165, 165, 173, 177, 40, 174, 243, 75, 194, 2, 231, 19, 21, 30, 14, 147], legacy_session_id: SessionId { l: 32, id: [32, 54, 116, 62, 48, 170, 107, 89, 12, 253, 151, 178, 103, 75, 237, 112, 85, 44, 101, 219, 110, 70, 247, 190, 44, 42, 174, 38, 28, 197, 135, 130] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 119, 105, 116, 116, 101, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [31, 159, 21, 205, 241, 149, 251, 57, 2, 37, 234, 169, 126, 159, 173, 166, 116, 7, 5, 196, 231, 80, 25, 164, 44, 194, 237, 162, 227, 228, 226, 58] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: instagram.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [193, 231, 188, 48, 224, 82, 7, 183, 107, 23, 156, 54, 65, 87, 248, 142, 155, 198, 252, 214, 232, 117, 148, 142, 236, 122, 202, 85, 44, 1, 202, 184] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((15, Opaque1Ffff { l: 13, data: [105, 110, 115, 116, 97, 103, 114, 97, 109, 46, 99, 111, 109] }))
+[trace] HostName: Ok((15, Opaque1Ffff { l: 13, data: [105, 110, 115, 116, 97, 103, 114, 97, 109, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((15, HostName(Opaque1Ffff { l: 13, data: [105, 110, 115, 116, 97, 103, 114, 97, 109, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((16, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [105, 110, 115, 116, 97, 103, 114, 97, 109, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((18, ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [105, 110, 115, 116, 97, 103, 114, 97, 109, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((18, ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [105, 110, 115, 116, 97, 103, 114, 97, 109, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((22, ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [105, 110, 115, 116, 97, 103, 114, 97, 109, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [230, 244, 155, 18, 132, 34, 71, 103, 57, 142, 22, 138, 4, 124, 219, 41, 111, 214, 106, 240, 252, 50, 85, 50, 155, 176, 21, 79, 112, 52, 2, 63] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [230, 244, 155, 18, 132, 34, 71, 103, 57, 142, 22, 138, 4, 124, 219, 41, 111, 214, 106, 240, 252, 50, 85, 50, 155, 176, 21, 79, 112, 52, 2, 63] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [230, 244, 155, 18, 132, 34, 71, 103, 57, 142, 22, 138, 4, 124, 219, 41, 111, 214, 106, 240, 252, 50, 85, 50, 155, 176, 21, 79, 112, 52, 2, 63] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [230, 244, 155, 18, 132, 34, 71, 103, 57, 142, 22, 138, 4, 124, 219, 41, 111, 214, 106, 240, 252, 50, 85, 50, 155, 176, 21, 79, 112, 52, 2, 63] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((218, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((218, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((222, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [105, 110, 115, 116, 97, 103, 114, 97, 109, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [230, 244, 155, 18, 132, 34, 71, 103, 57, 142, 22, 138, 4, 124, 219, 41, 111, 214, 106, 240, 252, 50, 85, 50, 155, 176, 21, 79, 112, 52, 2, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [138, 81, 100, 101, 234, 238, 75, 90, 56, 157, 52, 178, 46, 192, 71, 17, 194, 154, 142, 234, 126, 37, 71, 35, 27, 183, 160, 9, 154, 11, 71, 217], legacy_session_id: SessionId { l: 32, id: [193, 231, 188, 48, 224, 82, 7, 183, 107, 23, 156, 54, 65, 87, 248, 142, 155, 198, 252, 214, 232, 117, 148, 142, 236, 122, 202, 85, 44, 1, 202, 184] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [105, 110, 115, 116, 97, 103, 114, 97, 109, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [230, 244, 155, 18, 132, 34, 71, 103, 57, 142, 22, 138, 4, 124, 219, 41, 111, 214, 106, 240, 252, 50, 85, 50, 155, 176, 21, 79, 112, 52, 2, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [138, 81, 100, 101, 234, 238, 75, 90, 56, 157, 52, 178, 46, 192, 71, 17, 194, 154, 142, 234, 126, 37, 71, 35, 27, 183, 160, 9, 154, 11, 71, 217], legacy_session_id: SessionId { l: 32, id: [193, 231, 188, 48, 224, 82, 7, 183, 107, 23, 156, 54, 65, 87, 248, 142, 155, 198, 252, 214, 232, 117, 148, 142, 236, 122, 202, 85, 44, 1, 202, 184] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [105, 110, 115, 116, 97, 103, 114, 97, 109, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [230, 244, 155, 18, 132, 34, 71, 103, 57, 142, 22, 138, 4, 124, 219, 41, 111, 214, 106, 240, 252, 50, 85, 50, 155, 176, 21, 79, 112, 52, 2, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [138, 81, 100, 101, 234, 238, 75, 90, 56, 157, 52, 178, 46, 192, 71, 17, 194, 154, 142, 234, 126, 37, 71, 35, 27, 183, 160, 9, 154, 11, 71, 217], legacy_session_id: SessionId { l: 32, id: [193, 231, 188, 48, 224, 82, 7, 183, 107, 23, 156, 54, 65, 87, 248, 142, 155, 198, 252, 214, 232, 117, 148, 142, 236, 122, 202, 85, 44, 1, 202, 184] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [105, 110, 115, 116, 97, 103, 114, 97, 109, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [230, 244, 155, 18, 132, 34, 71, 103, 57, 142, 22, 138, 4, 124, 219, 41, 111, 214, 106, 240, 252, 50, 85, 50, 155, 176, 21, 79, 112, 52, 2, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: gstatic.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [237, 125, 97, 76, 150, 60, 74, 71, 217, 180, 223, 37, 255, 57, 226, 111, 29, 51, 52, 130, 53, 248, 66, 169, 119, 253, 213, 133, 130, 19, 4, 17] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [103, 115, 116, 97, 116, 105, 99, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [103, 115, 116, 97, 116, 105, 99, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [103, 115, 116, 97, 116, 105, 99, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [103, 115, 116, 97, 116, 105, 99, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [103, 115, 116, 97, 116, 105, 99, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [103, 115, 116, 97, 116, 105, 99, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [103, 115, 116, 97, 116, 105, 99, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [119, 11, 62, 44, 170, 82, 81, 15, 15, 12, 159, 187, 204, 151, 10, 168, 77, 242, 145, 249, 160, 30, 195, 60, 223, 123, 91, 114, 90, 229, 4, 105] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [119, 11, 62, 44, 170, 82, 81, 15, 15, 12, 159, 187, 204, 151, 10, 168, 77, 242, 145, 249, 160, 30, 195, 60, 223, 123, 91, 114, 90, 229, 4, 105] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [119, 11, 62, 44, 170, 82, 81, 15, 15, 12, 159, 187, 204, 151, 10, 168, 77, 242, 145, 249, 160, 30, 195, 60, 223, 123, 91, 114, 90, 229, 4, 105] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [119, 11, 62, 44, 170, 82, 81, 15, 15, 12, 159, 187, 204, 151, 10, 168, 77, 242, 145, 249, 160, 30, 195, 60, 223, 123, 91, 114, 90, 229, 4, 105] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [103, 115, 116, 97, 116, 105, 99, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [119, 11, 62, 44, 170, 82, 81, 15, 15, 12, 159, 187, 204, 151, 10, 168, 77, 242, 145, 249, 160, 30, 195, 60, 223, 123, 91, 114, 90, 229, 4, 105] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [167, 48, 128, 175, 119, 211, 186, 195, 185, 34, 125, 179, 6, 89, 49, 75, 12, 141, 110, 247, 253, 230, 221, 153, 191, 220, 213, 158, 35, 87, 116, 134], legacy_session_id: SessionId { l: 32, id: [237, 125, 97, 76, 150, 60, 74, 71, 217, 180, 223, 37, 255, 57, 226, 111, 29, 51, 52, 130, 53, 248, 66, 169, 119, 253, 213, 133, 130, 19, 4, 17] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [103, 115, 116, 97, 116, 105, 99, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [119, 11, 62, 44, 170, 82, 81, 15, 15, 12, 159, 187, 204, 151, 10, 168, 77, 242, 145, 249, 160, 30, 195, 60, 223, 123, 91, 114, 90, 229, 4, 105] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [167, 48, 128, 175, 119, 211, 186, 195, 185, 34, 125, 179, 6, 89, 49, 75, 12, 141, 110, 247, 253, 230, 221, 153, 191, 220, 213, 158, 35, 87, 116, 134], legacy_session_id: SessionId { l: 32, id: [237, 125, 97, 76, 150, 60, 74, 71, 217, 180, 223, 37, 255, 57, 226, 111, 29, 51, 52, 130, 53, 248, 66, 169, 119, 253, 213, 133, 130, 19, 4, 17] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [103, 115, 116, 97, 116, 105, 99, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [119, 11, 62, 44, 170, 82, 81, 15, 15, 12, 159, 187, 204, 151, 10, 168, 77, 242, 145, 249, 160, 30, 195, 60, 223, 123, 91, 114, 90, 229, 4, 105] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [167, 48, 128, 175, 119, 211, 186, 195, 185, 34, 125, 179, 6, 89, 49, 75, 12, 141, 110, 247, 253, 230, 221, 153, 191, 220, 213, 158, 35, 87, 116, 134], legacy_session_id: SessionId { l: 32, id: [237, 125, 97, 76, 150, 60, 74, 71, 217, 180, 223, 37, 255, 57, 226, 111, 29, 51, 52, 130, 53, 248, 66, 169, 119, 253, 213, 133, 130, 19, 4, 17] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [103, 115, 116, 97, 116, 105, 99, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [119, 11, 62, 44, 170, 82, 81, 15, 15, 12, 159, 187, 204, 151, 10, 168, 77, 242, 145, 249, 160, 30, 195, 60, 223, 123, 91, 114, 90, 229, 4, 105] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: azure.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [239, 85, 46, 161, 191, 244, 74, 227, 226, 232, 18, 12, 87, 149, 67, 161, 18, 76, 55, 248, 148, 99, 9, 240, 198, 175, 74, 36, 245, 12, 78, 61] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [97, 122, 117, 114, 101, 46, 99, 111, 109] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [97, 122, 117, 114, 101, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [97, 122, 117, 114, 101, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 122, 117, 114, 101, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 122, 117, 114, 101, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 122, 117, 114, 101, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 122, 117, 114, 101, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [70, 152, 160, 76, 252, 221, 246, 57, 237, 215, 33, 247, 246, 126, 157, 70, 74, 216, 229, 54, 146, 185, 146, 190, 107, 82, 150, 228, 38, 211, 151, 13] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [70, 152, 160, 76, 252, 221, 246, 57, 237, 215, 33, 247, 246, 126, 157, 70, 74, 216, 229, 54, 146, 185, 146, 190, 107, 82, 150, 228, 38, 211, 151, 13] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [70, 152, 160, 76, 252, 221, 246, 57, 237, 215, 33, 247, 246, 126, 157, 70, 74, 216, 229, 54, 146, 185, 146, 190, 107, 82, 150, 228, 38, 211, 151, 13] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [70, 152, 160, 76, 252, 221, 246, 57, 237, 215, 33, 247, 246, 126, 157, 70, 74, 216, 229, 54, 146, 185, 146, 190, 107, 82, 150, 228, 38, 211, 151, 13] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 122, 117, 114, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [70, 152, 160, 76, 252, 221, 246, 57, 237, 215, 33, 247, 246, 126, 157, 70, 74, 216, 229, 54, 146, 185, 146, 190, 107, 82, 150, 228, 38, 211, 151, 13] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [70, 105, 21, 121, 212, 58, 113, 158, 53, 84, 44, 121, 216, 109, 142, 1, 42, 54, 71, 210, 204, 128, 217, 188, 187, 162, 183, 52, 222, 125, 153, 156], legacy_session_id: SessionId { l: 32, id: [239, 85, 46, 161, 191, 244, 74, 227, 226, 232, 18, 12, 87, 149, 67, 161, 18, 76, 55, 248, 148, 99, 9, 240, 198, 175, 74, 36, 245, 12, 78, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 122, 117, 114, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [70, 152, 160, 76, 252, 221, 246, 57, 237, 215, 33, 247, 246, 126, 157, 70, 74, 216, 229, 54, 146, 185, 146, 190, 107, 82, 150, 228, 38, 211, 151, 13] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [70, 105, 21, 121, 212, 58, 113, 158, 53, 84, 44, 121, 216, 109, 142, 1, 42, 54, 71, 210, 204, 128, 217, 188, 187, 162, 183, 52, 222, 125, 153, 156], legacy_session_id: SessionId { l: 32, id: [239, 85, 46, 161, 191, 244, 74, 227, 226, 232, 18, 12, 87, 149, 67, 161, 18, 76, 55, 248, 148, 99, 9, 240, 198, 175, 74, 36, 245, 12, 78, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 122, 117, 114, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [70, 152, 160, 76, 252, 221, 246, 57, 237, 215, 33, 247, 246, 126, 157, 70, 74, 216, 229, 54, 146, 185, 146, 190, 107, 82, 150, 228, 38, 211, 151, 13] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [70, 105, 21, 121, 212, 58, 113, 158, 53, 84, 44, 121, 216, 109, 142, 1, 42, 54, 71, 210, 204, 128, 217, 188, 187, 162, 183, 52, 222, 125, 153, 156], legacy_session_id: SessionId { l: 32, id: [239, 85, 46, 161, 191, 244, 74, 227, 226, 232, 18, 12, 87, 149, 67, 161, 18, 76, 55, 248, 148, 99, 9, 240, 198, 175, 74, 36, 245, 12, 78, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 122, 117, 114, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [70, 152, 160, 76, 252, 221, 246, 57, 237, 215, 33, 247, 246, 126, 157, 70, 74, 216, 229, 54, 146, 185, 146, 190, 107, 82, 150, 228, 38, 211, 151, 13] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: linkedin.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [63, 142, 41, 67, 14, 140, 55, 44, 9, 56, 70, 71, 231, 124, 41, 221, 118, 115, 111, 185, 181, 99, 163, 207, 1, 203, 213, 89, 116, 61, 228, 89] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((14, Opaque1Ffff { l: 12, data: [108, 105, 110, 107, 101, 100, 105, 110, 46, 99, 111, 109] }))
+[trace] HostName: Ok((14, Opaque1Ffff { l: 12, data: [108, 105, 110, 107, 101, 100, 105, 110, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((14, HostName(Opaque1Ffff { l: 12, data: [108, 105, 110, 107, 101, 100, 105, 110, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((15, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [108, 105, 110, 107, 101, 100, 105, 110, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((17, ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [108, 105, 110, 107, 101, 100, 105, 110, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((17, ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [108, 105, 110, 107, 101, 100, 105, 110, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((21, ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [108, 105, 110, 107, 101, 100, 105, 110, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [96, 230, 197, 182, 40, 2, 161, 160, 61, 117, 168, 88, 179, 208, 217, 214, 21, 194, 173, 206, 143, 48, 104, 116, 44, 51, 59, 105, 58, 227, 228, 104] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [96, 230, 197, 182, 40, 2, 161, 160, 61, 117, 168, 88, 179, 208, 217, 214, 21, 194, 173, 206, 143, 48, 104, 116, 44, 51, 59, 105, 58, 227, 228, 104] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [96, 230, 197, 182, 40, 2, 161, 160, 61, 117, 168, 88, 179, 208, 217, 214, 21, 194, 173, 206, 143, 48, 104, 116, 44, 51, 59, 105, 58, 227, 228, 104] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [96, 230, 197, 182, 40, 2, 161, 160, 61, 117, 168, 88, 179, 208, 217, 214, 21, 194, 173, 206, 143, 48, 104, 116, 44, 51, 59, 105, 58, 227, 228, 104] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((219, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((219, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((223, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [108, 105, 110, 107, 101, 100, 105, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [96, 230, 197, 182, 40, 2, 161, 160, 61, 117, 168, 88, 179, 208, 217, 214, 21, 194, 173, 206, 143, 48, 104, 116, 44, 51, 59, 105, 58, 227, 228, 104] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [60, 64, 161, 118, 52, 208, 123, 209, 208, 155, 245, 213, 95, 213, 130, 127, 121, 127, 213, 192, 28, 212, 156, 103, 242, 150, 92, 181, 248, 218, 51, 51], legacy_session_id: SessionId { l: 32, id: [63, 142, 41, 67, 14, 140, 55, 44, 9, 56, 70, 71, 231, 124, 41, 221, 118, 115, 111, 185, 181, 99, 163, 207, 1, 203, 213, 89, 116, 61, 228, 89] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [108, 105, 110, 107, 101, 100, 105, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [96, 230, 197, 182, 40, 2, 161, 160, 61, 117, 168, 88, 179, 208, 217, 214, 21, 194, 173, 206, 143, 48, 104, 116, 44, 51, 59, 105, 58, 227, 228, 104] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [60, 64, 161, 118, 52, 208, 123, 209, 208, 155, 245, 213, 95, 213, 130, 127, 121, 127, 213, 192, 28, 212, 156, 103, 242, 150, 92, 181, 248, 218, 51, 51], legacy_session_id: SessionId { l: 32, id: [63, 142, 41, 67, 14, 140, 55, 44, 9, 56, 70, 71, 231, 124, 41, 221, 118, 115, 111, 185, 181, 99, 163, 207, 1, 203, 213, 89, 116, 61, 228, 89] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [108, 105, 110, 107, 101, 100, 105, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [96, 230, 197, 182, 40, 2, 161, 160, 61, 117, 168, 88, 179, 208, 217, 214, 21, 194, 173, 206, 143, 48, 104, 116, 44, 51, 59, 105, 58, 227, 228, 104] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [60, 64, 161, 118, 52, 208, 123, 209, 208, 155, 245, 213, 95, 213, 130, 127, 121, 127, 213, 192, 28, 212, 156, 103, 242, 150, 92, 181, 248, 218, 51, 51], legacy_session_id: SessionId { l: 32, id: [63, 142, 41, 67, 14, 140, 55, 44, 9, 56, 70, 71, 231, 124, 41, 221, 118, 115, 111, 185, 181, 99, 163, 207, 1, 203, 213, 89, 116, 61, 228, 89] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [108, 105, 110, 107, 101, 100, 105, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [96, 230, 197, 182, 40, 2, 161, 160, 61, 117, 168, 88, 179, 208, 217, 214, 21, 194, 173, 206, 143, 48, 104, 116, 44, 51, 59, 105, 58, 227, 228, 104] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(8504013611d2004df7d82f827c8e4bebfe026a34c183740bab390009d0969d6ea59012090c730f23cbb3b5609627d0e6e8b99f4adc5ddce7354e3d4da61578e1440da2720193b53f91dfbae3417042661bcd82f4fda29936e7d4bf3a32c58766805a73a274cddde461d7ae238d1ce91472147a5081ccefed9c1adb2e2c80ac92299fe8a634a9) }, encoded: 100000868504013611d2004df7d82f827c8e4bebfe026a34c183740bab390009d0969d6ea59012090c730f23cbb3b5609627d0e6e8b99f4adc5ddce7354e3d4da61578e1440da2720193b53f91dfbae3417042661bcd82f4fda29936e7d4bf3a32c58766805a73a274cddde461d7ae238d1ce91472147a5081ccefed9c1adb2e2c80ac92299fe8a634a9 }
+=====================================
+domain: office.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [253, 42, 158, 42, 58, 107, 134, 102, 84, 84, 161, 254, 118, 16, 30, 229, 114, 172, 193, 153, 181, 115, 174, 118, 101, 124, 113, 5, 219, 214, 85, 150] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [7, 112, 220, 147, 215, 173, 77, 86, 101, 192, 194, 88, 25, 134, 109, 146, 151, 178, 175, 253, 3, 251, 202, 40, 247, 214, 98, 94, 61, 203, 56, 51] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 112, 220, 147, 215, 173, 77, 86, 101, 192, 194, 88, 25, 134, 109, 146, 151, 178, 175, 253, 3, 251, 202, 40, 247, 214, 98, 94, 61, 203, 56, 51] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 112, 220, 147, 215, 173, 77, 86, 101, 192, 194, 88, 25, 134, 109, 146, 151, 178, 175, 253, 3, 251, 202, 40, 247, 214, 98, 94, 61, 203, 56, 51] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 112, 220, 147, 215, 173, 77, 86, 101, 192, 194, 88, 25, 134, 109, 146, 151, 178, 175, 253, 3, 251, 202, 40, 247, 214, 98, 94, 61, 203, 56, 51] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 112, 220, 147, 215, 173, 77, 86, 101, 192, 194, 88, 25, 134, 109, 146, 151, 178, 175, 253, 3, 251, 202, 40, 247, 214, 98, 94, 61, 203, 56, 51] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [6, 236, 41, 122, 102, 155, 226, 177, 209, 161, 243, 168, 123, 38, 223, 220, 219, 114, 239, 174, 73, 216, 223, 212, 173, 54, 89, 240, 49, 177, 26, 21], legacy_session_id: SessionId { l: 32, id: [253, 42, 158, 42, 58, 107, 134, 102, 84, 84, 161, 254, 118, 16, 30, 229, 114, 172, 193, 153, 181, 115, 174, 118, 101, 124, 113, 5, 219, 214, 85, 150] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 112, 220, 147, 215, 173, 77, 86, 101, 192, 194, 88, 25, 134, 109, 146, 151, 178, 175, 253, 3, 251, 202, 40, 247, 214, 98, 94, 61, 203, 56, 51] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [6, 236, 41, 122, 102, 155, 226, 177, 209, 161, 243, 168, 123, 38, 223, 220, 219, 114, 239, 174, 73, 216, 223, 212, 173, 54, 89, 240, 49, 177, 26, 21], legacy_session_id: SessionId { l: 32, id: [253, 42, 158, 42, 58, 107, 134, 102, 84, 84, 161, 254, 118, 16, 30, 229, 114, 172, 193, 153, 181, 115, 174, 118, 101, 124, 113, 5, 219, 214, 85, 150] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 112, 220, 147, 215, 173, 77, 86, 101, 192, 194, 88, 25, 134, 109, 146, 151, 178, 175, 253, 3, 251, 202, 40, 247, 214, 98, 94, 61, 203, 56, 51] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [6, 236, 41, 122, 102, 155, 226, 177, 209, 161, 243, 168, 123, 38, 223, 220, 219, 114, 239, 174, 73, 216, 223, 212, 173, 54, 89, 240, 49, 177, 26, 21], legacy_session_id: SessionId { l: 32, id: [253, 42, 158, 42, 58, 107, 134, 102, 84, 84, 161, 254, 118, 16, 30, 229, 114, 172, 193, 153, 181, 115, 174, 118, 101, 124, 113, 5, 219, 214, 85, 150] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 112, 220, 147, 215, 173, 77, 86, 101, 192, 194, 88, 25, 134, 109, 146, 151, 178, 175, 253, 3, 251, 202, 40, 247, 214, 98, 94, 61, 203, 56, 51] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [253, 42, 158, 42, 58, 107, 134, 102, 84, 84, 161, 254, 118, 16, 30, 229, 114, 172, 193, 153, 181, 115, 174, 118, 101, 124, 113, 5, 219, 214, 85, 150] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 25))
+[trace] KeyShareEntry: Ok((137, KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 237, 255, 235, 117, 220, 252, 26, 85, 178, 51, 65, 243, 132, 216, 17, 67, 106, 35, 40, 112, 44, 85, 109, 46, 123, 184, 2, 113, 4, 91, 248, 185, 107, 191, 3, 111, 50, 250, 187, 220, 83, 137, 10, 172, 165, 200, 73, 254, 134, 247, 107, 6, 184, 236, 91, 92, 16, 236, 68, 197, 240, 70, 234, 139, 41, 1, 142, 137, 219, 247, 150, 233, 153, 64, 166, 163, 135, 14, 175, 222, 206, 237, 127, 211, 130, 11, 148, 100, 164, 183, 242, 157, 16, 154, 53, 192, 110, 231, 85, 201, 163, 19, 133, 215, 0, 247, 193, 66, 90, 132, 79, 99, 134, 181, 102, 194, 154, 182, 94, 80, 170, 20, 205, 191, 253, 40, 67, 177, 27, 85, 205] }))
+[trace] KeyShareClientHello: Ok((139, KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 237, 255, 235, 117, 220, 252, 26, 85, 178, 51, 65, 243, 132, 216, 17, 67, 106, 35, 40, 112, 44, 85, 109, 46, 123, 184, 2, 113, 4, 91, 248, 185, 107, 191, 3, 111, 50, 250, 187, 220, 83, 137, 10, 172, 165, 200, 73, 254, 134, 247, 107, 6, 184, 236, 91, 92, 16, 236, 68, 197, 240, 70, 234, 139, 41, 1, 142, 137, 219, 247, 150, 233, 153, 64, 166, 163, 135, 14, 175, 222, 206, 237, 127, 211, 130, 11, 148, 100, 164, 183, 242, 157, 16, 154, 53, 192, 110, 231, 85, 201, 163, 19, 133, 215, 0, 247, 193, 66, 90, 132, 79, 99, 134, 181, 102, 194, 154, 182, 94, 80, 170, 20, 205, 191, 253, 40, 67, 177, 27, 85, 205] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((139, KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 237, 255, 235, 117, 220, 252, 26, 85, 178, 51, 65, 243, 132, 216, 17, 67, 106, 35, 40, 112, 44, 85, 109, 46, 123, 184, 2, 113, 4, 91, 248, 185, 107, 191, 3, 111, 50, 250, 187, 220, 83, 137, 10, 172, 165, 200, 73, 254, 134, 247, 107, 6, 184, 236, 91, 92, 16, 236, 68, 197, 240, 70, 234, 139, 41, 1, 142, 137, 219, 247, 150, 233, 153, 64, 166, 163, 135, 14, 175, 222, 206, 237, 127, 211, 130, 11, 148, 100, 164, 183, 242, 157, 16, 154, 53, 192, 110, 231, 85, 201, 163, 19, 133, 215, 0, 247, 193, 66, 90, 132, 79, 99, 134, 181, 102, 194, 154, 182, 94, 80, 170, 20, 205, 191, 253, 40, 67, 177, 27, 85, 205] }]) })))
+[trace] ClientHelloExtension: Ok((143, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 237, 255, 235, 117, 220, 252, 26, 85, 178, 51, 65, 243, 132, 216, 17, 67, 106, 35, 40, 112, 44, 85, 109, 46, 123, 184, 2, 113, 4, 91, 248, 185, 107, 191, 3, 111, 50, 250, 187, 220, 83, 137, 10, 172, 165, 200, 73, 254, 134, 247, 107, 6, 184, 236, 91, 92, 16, 236, 68, 197, 240, 70, 234, 139, 41, 1, 142, 137, 219, 247, 150, 233, 153, 64, 166, 163, 135, 14, 175, 222, 206, 237, 127, 211, 130, 11, 148, 100, 164, 183, 242, 157, 16, 154, 53, 192, 110, 231, 85, 201, 163, 19, 133, 215, 0, 247, 193, 66, 90, 132, 79, 99, 134, 181, 102, 194, 154, 182, 94, 80, 170, 20, 205, 191, 253, 40, 67, 177, 27, 85, 205] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((120, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((120, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((124, ClientHelloExtension { extension_type: 21, ext_len: 120, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 237, 255, 235, 117, 220, 252, 26, 85, 178, 51, 65, 243, 132, 216, 17, 67, 106, 35, 40, 112, 44, 85, 109, 46, 123, 184, 2, 113, 4, 91, 248, 185, 107, 191, 3, 111, 50, 250, 187, 220, 83, 137, 10, 172, 165, 200, 73, 254, 134, 247, 107, 6, 184, 236, 91, 92, 16, 236, 68, 197, 240, 70, 234, 139, 41, 1, 142, 137, 219, 247, 150, 233, 153, 64, 166, 163, 135, 14, 175, 222, 206, 237, 127, 211, 130, 11, 148, 100, 164, 183, 242, 157, 16, 154, 53, 192, 110, 231, 85, 201, 163, 19, 133, 215, 0, 247, 193, 66, 90, 132, 79, 99, 134, 181, 102, 194, 154, 182, 94, 80, 170, 20, 205, 191, 253, 40, 67, 177, 27, 85, 205] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 120, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [6, 236, 41, 122, 102, 155, 226, 177, 209, 161, 243, 168, 123, 38, 223, 220, 219, 114, 239, 174, 73, 216, 223, 212, 173, 54, 89, 240, 49, 177, 26, 21], legacy_session_id: SessionId { l: 32, id: [253, 42, 158, 42, 58, 107, 134, 102, 84, 84, 161, 254, 118, 16, 30, 229, 114, 172, 193, 153, 181, 115, 174, 118, 101, 124, 113, 5, 219, 214, 85, 150] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 237, 255, 235, 117, 220, 252, 26, 85, 178, 51, 65, 243, 132, 216, 17, 67, 106, 35, 40, 112, 44, 85, 109, 46, 123, 184, 2, 113, 4, 91, 248, 185, 107, 191, 3, 111, 50, 250, 187, 220, 83, 137, 10, 172, 165, 200, 73, 254, 134, 247, 107, 6, 184, 236, 91, 92, 16, 236, 68, 197, 240, 70, 234, 139, 41, 1, 142, 137, 219, 247, 150, 233, 153, 64, 166, 163, 135, 14, 175, 222, 206, 237, 127, 211, 130, 11, 148, 100, 164, 183, 242, 157, 16, 154, 53, 192, 110, 231, 85, 201, 163, 19, 133, 215, 0, 247, 193, 66, 90, 132, 79, 99, 134, 181, 102, 194, 154, 182, 94, 80, 170, 20, 205, 191, 253, 40, 67, 177, 27, 85, 205] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 120, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [6, 236, 41, 122, 102, 155, 226, 177, 209, 161, 243, 168, 123, 38, 223, 220, 219, 114, 239, 174, 73, 216, 223, 212, 173, 54, 89, 240, 49, 177, 26, 21], legacy_session_id: SessionId { l: 32, id: [253, 42, 158, 42, 58, 107, 134, 102, 84, 84, 161, 254, 118, 16, 30, 229, 114, 172, 193, 153, 181, 115, 174, 118, 101, 124, 113, 5, 219, 214, 85, 150] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 237, 255, 235, 117, 220, 252, 26, 85, 178, 51, 65, 243, 132, 216, 17, 67, 106, 35, 40, 112, 44, 85, 109, 46, 123, 184, 2, 113, 4, 91, 248, 185, 107, 191, 3, 111, 50, 250, 187, 220, 83, 137, 10, 172, 165, 200, 73, 254, 134, 247, 107, 6, 184, 236, 91, 92, 16, 236, 68, 197, 240, 70, 234, 139, 41, 1, 142, 137, 219, 247, 150, 233, 153, 64, 166, 163, 135, 14, 175, 222, 206, 237, 127, 211, 130, 11, 148, 100, 164, 183, 242, 157, 16, 154, 53, 192, 110, 231, 85, 201, 163, 19, 133, 215, 0, 247, 193, 66, 90, 132, 79, 99, 134, 181, 102, 194, 154, 182, 94, 80, 170, 20, 205, 191, 253, 40, 67, 177, 27, 85, 205] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 120, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [6, 236, 41, 122, 102, 155, 226, 177, 209, 161, 243, 168, 123, 38, 223, 220, 219, 114, 239, 174, 73, 216, 223, 212, 173, 54, 89, 240, 49, 177, 26, 21], legacy_session_id: SessionId { l: 32, id: [253, 42, 158, 42, 58, 107, 134, 102, 84, 84, 161, 254, 118, 16, 30, 229, 114, 172, 193, 153, 181, 115, 174, 118, 101, 124, 113, 5, 219, 214, 85, 150] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [111, 102, 102, 105, 99, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 237, 255, 235, 117, 220, 252, 26, 85, 178, 51, 65, 243, 132, 216, 17, 67, 106, 35, 40, 112, 44, 85, 109, 46, 123, 184, 2, 113, 4, 91, 248, 185, 107, 191, 3, 111, 50, 250, 187, 220, 83, 137, 10, 172, 165, 200, 73, 254, 134, 247, 107, 6, 184, 236, 91, 92, 16, 236, 68, 197, 240, 70, 234, 139, 41, 1, 142, 137, 219, 247, 150, 233, 153, 64, 166, 163, 135, 14, 175, 222, 206, 237, 127, 211, 130, 11, 148, 100, 164, 183, 242, 157, 16, 154, 53, 192, 110, 231, 85, 201, 163, 19, 133, 215, 0, 247, 193, 66, 90, 132, 79, 99, 134, 181, 102, 194, 154, 182, 94, 80, 170, 20, 205, 191, 253, 40, 67, 177, 27, 85, 205] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 120, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: live.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [152, 24, 248, 83, 102, 239, 36, 67, 171, 197, 94, 157, 28, 117, 95, 190, 120, 2, 232, 178, 160, 26, 86, 227, 34, 90, 79, 181, 6, 12, 229, 211] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((10, Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }))
+[trace] HostName: Ok((10, Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((10, HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((11, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((13, ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((13, ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((17, ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [182, 127, 150, 249, 138, 44, 199, 131, 239, 29, 72, 116, 82, 50, 0, 17, 88, 55, 222, 79, 190, 128, 254, 188, 158, 55, 111, 228, 78, 38, 156, 42] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 127, 150, 249, 138, 44, 199, 131, 239, 29, 72, 116, 82, 50, 0, 17, 88, 55, 222, 79, 190, 128, 254, 188, 158, 55, 111, 228, 78, 38, 156, 42] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 127, 150, 249, 138, 44, 199, 131, 239, 29, 72, 116, 82, 50, 0, 17, 88, 55, 222, 79, 190, 128, 254, 188, 158, 55, 111, 228, 78, 38, 156, 42] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 127, 150, 249, 138, 44, 199, 131, 239, 29, 72, 116, 82, 50, 0, 17, 88, 55, 222, 79, 190, 128, 254, 188, 158, 55, 111, 228, 78, 38, 156, 42] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((223, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((223, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((227, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 127, 150, 249, 138, 44, 199, 131, 239, 29, 72, 116, 82, 50, 0, 17, 88, 55, 222, 79, 190, 128, 254, 188, 158, 55, 111, 228, 78, 38, 156, 42] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [255, 132, 204, 237, 145, 45, 198, 228, 174, 7, 56, 115, 54, 129, 175, 166, 248, 123, 49, 214, 207, 0, 113, 188, 23, 222, 185, 176, 182, 37, 80, 227], legacy_session_id: SessionId { l: 32, id: [152, 24, 248, 83, 102, 239, 36, 67, 171, 197, 94, 157, 28, 117, 95, 190, 120, 2, 232, 178, 160, 26, 86, 227, 34, 90, 79, 181, 6, 12, 229, 211] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 127, 150, 249, 138, 44, 199, 131, 239, 29, 72, 116, 82, 50, 0, 17, 88, 55, 222, 79, 190, 128, 254, 188, 158, 55, 111, 228, 78, 38, 156, 42] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [255, 132, 204, 237, 145, 45, 198, 228, 174, 7, 56, 115, 54, 129, 175, 166, 248, 123, 49, 214, 207, 0, 113, 188, 23, 222, 185, 176, 182, 37, 80, 227], legacy_session_id: SessionId { l: 32, id: [152, 24, 248, 83, 102, 239, 36, 67, 171, 197, 94, 157, 28, 117, 95, 190, 120, 2, 232, 178, 160, 26, 86, 227, 34, 90, 79, 181, 6, 12, 229, 211] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 127, 150, 249, 138, 44, 199, 131, 239, 29, 72, 116, 82, 50, 0, 17, 88, 55, 222, 79, 190, 128, 254, 188, 158, 55, 111, 228, 78, 38, 156, 42] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [255, 132, 204, 237, 145, 45, 198, 228, 174, 7, 56, 115, 54, 129, 175, 166, 248, 123, 49, 214, 207, 0, 113, 188, 23, 222, 185, 176, 182, 37, 80, 227], legacy_session_id: SessionId { l: 32, id: [152, 24, 248, 83, 102, 239, 36, 67, 171, 197, 94, 157, 28, 117, 95, 190, 120, 2, 232, 178, 160, 26, 86, 227, 34, 90, 79, 181, 6, 12, 229, 211] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 127, 150, 249, 138, 44, 199, 131, 239, 29, 72, 116, 82, 50, 0, 17, 88, 55, 222, 79, 190, 128, 254, 188, 158, 55, 111, 228, 78, 38, 156, 42] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [152, 24, 248, 83, 102, 239, 36, 67, 171, 197, 94, 157, 28, 117, 95, 190, 120, 2, 232, 178, 160, 26, 86, 227, 34, 90, 79, 181, 6, 12, 229, 211] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((10, Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }))
+[trace] HostName: Ok((10, Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((10, HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((11, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((13, ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((13, ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((17, ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 25))
+[trace] KeyShareEntry: Ok((137, KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 216, 26, 140, 77, 125, 11, 4, 62, 127, 255, 99, 45, 234, 139, 192, 231, 12, 51, 206, 123, 240, 25, 150, 109, 113, 189, 52, 144, 231, 31, 243, 134, 235, 153, 53, 250, 170, 97, 76, 140, 37, 185, 24, 38, 242, 27, 117, 211, 103, 192, 28, 129, 11, 49, 224, 33, 150, 138, 114, 193, 48, 75, 149, 152, 140, 1, 67, 47, 43, 190, 28, 33, 119, 221, 20, 120, 155, 208, 216, 73, 210, 202, 171, 215, 169, 17, 38, 133, 95, 182, 112, 156, 57, 162, 180, 211, 37, 219, 127, 75, 35, 107, 74, 176, 1, 236, 97, 214, 245, 229, 231, 80, 169, 204, 153, 242, 4, 13, 38, 87, 90, 20, 193, 32, 73, 140, 101, 180, 157, 53, 244] }))
+[trace] KeyShareClientHello: Ok((139, KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 216, 26, 140, 77, 125, 11, 4, 62, 127, 255, 99, 45, 234, 139, 192, 231, 12, 51, 206, 123, 240, 25, 150, 109, 113, 189, 52, 144, 231, 31, 243, 134, 235, 153, 53, 250, 170, 97, 76, 140, 37, 185, 24, 38, 242, 27, 117, 211, 103, 192, 28, 129, 11, 49, 224, 33, 150, 138, 114, 193, 48, 75, 149, 152, 140, 1, 67, 47, 43, 190, 28, 33, 119, 221, 20, 120, 155, 208, 216, 73, 210, 202, 171, 215, 169, 17, 38, 133, 95, 182, 112, 156, 57, 162, 180, 211, 37, 219, 127, 75, 35, 107, 74, 176, 1, 236, 97, 214, 245, 229, 231, 80, 169, 204, 153, 242, 4, 13, 38, 87, 90, 20, 193, 32, 73, 140, 101, 180, 157, 53, 244] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((139, KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 216, 26, 140, 77, 125, 11, 4, 62, 127, 255, 99, 45, 234, 139, 192, 231, 12, 51, 206, 123, 240, 25, 150, 109, 113, 189, 52, 144, 231, 31, 243, 134, 235, 153, 53, 250, 170, 97, 76, 140, 37, 185, 24, 38, 242, 27, 117, 211, 103, 192, 28, 129, 11, 49, 224, 33, 150, 138, 114, 193, 48, 75, 149, 152, 140, 1, 67, 47, 43, 190, 28, 33, 119, 221, 20, 120, 155, 208, 216, 73, 210, 202, 171, 215, 169, 17, 38, 133, 95, 182, 112, 156, 57, 162, 180, 211, 37, 219, 127, 75, 35, 107, 74, 176, 1, 236, 97, 214, 245, 229, 231, 80, 169, 204, 153, 242, 4, 13, 38, 87, 90, 20, 193, 32, 73, 140, 101, 180, 157, 53, 244] }]) })))
+[trace] ClientHelloExtension: Ok((143, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 216, 26, 140, 77, 125, 11, 4, 62, 127, 255, 99, 45, 234, 139, 192, 231, 12, 51, 206, 123, 240, 25, 150, 109, 113, 189, 52, 144, 231, 31, 243, 134, 235, 153, 53, 250, 170, 97, 76, 140, 37, 185, 24, 38, 242, 27, 117, 211, 103, 192, 28, 129, 11, 49, 224, 33, 150, 138, 114, 193, 48, 75, 149, 152, 140, 1, 67, 47, 43, 190, 28, 33, 119, 221, 20, 120, 155, 208, 216, 73, 210, 202, 171, 215, 169, 17, 38, 133, 95, 182, 112, 156, 57, 162, 180, 211, 37, 219, 127, 75, 35, 107, 74, 176, 1, 236, 97, 214, 245, 229, 231, 80, 169, 204, 153, 242, 4, 13, 38, 87, 90, 20, 193, 32, 73, 140, 101, 180, 157, 53, 244] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((122, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((122, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((126, ClientHelloExtension { extension_type: 21, ext_len: 122, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 216, 26, 140, 77, 125, 11, 4, 62, 127, 255, 99, 45, 234, 139, 192, 231, 12, 51, 206, 123, 240, 25, 150, 109, 113, 189, 52, 144, 231, 31, 243, 134, 235, 153, 53, 250, 170, 97, 76, 140, 37, 185, 24, 38, 242, 27, 117, 211, 103, 192, 28, 129, 11, 49, 224, 33, 150, 138, 114, 193, 48, 75, 149, 152, 140, 1, 67, 47, 43, 190, 28, 33, 119, 221, 20, 120, 155, 208, 216, 73, 210, 202, 171, 215, 169, 17, 38, 133, 95, 182, 112, 156, 57, 162, 180, 211, 37, 219, 127, 75, 35, 107, 74, 176, 1, 236, 97, 214, 245, 229, 231, 80, 169, 204, 153, 242, 4, 13, 38, 87, 90, 20, 193, 32, 73, 140, 101, 180, 157, 53, 244] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 122, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [255, 132, 204, 237, 145, 45, 198, 228, 174, 7, 56, 115, 54, 129, 175, 166, 248, 123, 49, 214, 207, 0, 113, 188, 23, 222, 185, 176, 182, 37, 80, 227], legacy_session_id: SessionId { l: 32, id: [152, 24, 248, 83, 102, 239, 36, 67, 171, 197, 94, 157, 28, 117, 95, 190, 120, 2, 232, 178, 160, 26, 86, 227, 34, 90, 79, 181, 6, 12, 229, 211] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 216, 26, 140, 77, 125, 11, 4, 62, 127, 255, 99, 45, 234, 139, 192, 231, 12, 51, 206, 123, 240, 25, 150, 109, 113, 189, 52, 144, 231, 31, 243, 134, 235, 153, 53, 250, 170, 97, 76, 140, 37, 185, 24, 38, 242, 27, 117, 211, 103, 192, 28, 129, 11, 49, 224, 33, 150, 138, 114, 193, 48, 75, 149, 152, 140, 1, 67, 47, 43, 190, 28, 33, 119, 221, 20, 120, 155, 208, 216, 73, 210, 202, 171, 215, 169, 17, 38, 133, 95, 182, 112, 156, 57, 162, 180, 211, 37, 219, 127, 75, 35, 107, 74, 176, 1, 236, 97, 214, 245, 229, 231, 80, 169, 204, 153, 242, 4, 13, 38, 87, 90, 20, 193, 32, 73, 140, 101, 180, 157, 53, 244] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 122, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [255, 132, 204, 237, 145, 45, 198, 228, 174, 7, 56, 115, 54, 129, 175, 166, 248, 123, 49, 214, 207, 0, 113, 188, 23, 222, 185, 176, 182, 37, 80, 227], legacy_session_id: SessionId { l: 32, id: [152, 24, 248, 83, 102, 239, 36, 67, 171, 197, 94, 157, 28, 117, 95, 190, 120, 2, 232, 178, 160, 26, 86, 227, 34, 90, 79, 181, 6, 12, 229, 211] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 216, 26, 140, 77, 125, 11, 4, 62, 127, 255, 99, 45, 234, 139, 192, 231, 12, 51, 206, 123, 240, 25, 150, 109, 113, 189, 52, 144, 231, 31, 243, 134, 235, 153, 53, 250, 170, 97, 76, 140, 37, 185, 24, 38, 242, 27, 117, 211, 103, 192, 28, 129, 11, 49, 224, 33, 150, 138, 114, 193, 48, 75, 149, 152, 140, 1, 67, 47, 43, 190, 28, 33, 119, 221, 20, 120, 155, 208, 216, 73, 210, 202, 171, 215, 169, 17, 38, 133, 95, 182, 112, 156, 57, 162, 180, 211, 37, 219, 127, 75, 35, 107, 74, 176, 1, 236, 97, 214, 245, 229, 231, 80, 169, 204, 153, 242, 4, 13, 38, 87, 90, 20, 193, 32, 73, 140, 101, 180, 157, 53, 244] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 122, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [255, 132, 204, 237, 145, 45, 198, 228, 174, 7, 56, 115, 54, 129, 175, 166, 248, 123, 49, 214, 207, 0, 113, 188, 23, 222, 185, 176, 182, 37, 80, 227], legacy_session_id: SessionId { l: 32, id: [152, 24, 248, 83, 102, 239, 36, 67, 171, 197, 94, 157, 28, 117, 95, 190, 120, 2, 232, 178, 160, 26, 86, 227, 34, 90, 79, 181, 6, 12, 229, 211] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [108, 105, 118, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 216, 26, 140, 77, 125, 11, 4, 62, 127, 255, 99, 45, 234, 139, 192, 231, 12, 51, 206, 123, 240, 25, 150, 109, 113, 189, 52, 144, 231, 31, 243, 134, 235, 153, 53, 250, 170, 97, 76, 140, 37, 185, 24, 38, 242, 27, 117, 211, 103, 192, 28, 129, 11, 49, 224, 33, 150, 138, 114, 193, 48, 75, 149, 152, 140, 1, 67, 47, 43, 190, 28, 33, 119, 221, 20, 120, 155, 208, 216, 73, 210, 202, 171, 215, 169, 17, 38, 133, 95, 182, 112, 156, 57, 162, 180, 211, 37, 219, 127, 75, 35, 107, 74, 176, 1, 236, 97, 214, 245, 229, 231, 80, 169, 204, 153, 242, 4, 13, 38, 87, 90, 20, 193, 32, 73, 140, 101, 180, 157, 53, 244] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 122, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: amazon.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [14, 42, 56, 213, 63, 69, 56, 178, 22, 41, 205, 7, 210, 222, 111, 102, 206, 247, 209, 81, 40, 145, 42, 139, 94, 83, 45, 217, 69, 117, 73, 166] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [97, 109, 97, 122, 111, 110, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [97, 109, 97, 122, 111, 110, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [97, 109, 97, 122, 111, 110, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 109, 97, 122, 111, 110, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 109, 97, 122, 111, 110, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 109, 97, 122, 111, 110, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 109, 97, 122, 111, 110, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [48, 54, 10, 12, 211, 18, 73, 189, 39, 168, 97, 238, 110, 109, 152, 90, 253, 104, 217, 46, 148, 132, 158, 154, 62, 43, 237, 16, 251, 90, 216, 42] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [48, 54, 10, 12, 211, 18, 73, 189, 39, 168, 97, 238, 110, 109, 152, 90, 253, 104, 217, 46, 148, 132, 158, 154, 62, 43, 237, 16, 251, 90, 216, 42] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [48, 54, 10, 12, 211, 18, 73, 189, 39, 168, 97, 238, 110, 109, 152, 90, 253, 104, 217, 46, 148, 132, 158, 154, 62, 43, 237, 16, 251, 90, 216, 42] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [48, 54, 10, 12, 211, 18, 73, 189, 39, 168, 97, 238, 110, 109, 152, 90, 253, 104, 217, 46, 148, 132, 158, 154, 62, 43, 237, 16, 251, 90, 216, 42] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 109, 97, 122, 111, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [48, 54, 10, 12, 211, 18, 73, 189, 39, 168, 97, 238, 110, 109, 152, 90, 253, 104, 217, 46, 148, 132, 158, 154, 62, 43, 237, 16, 251, 90, 216, 42] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [250, 208, 190, 225, 82, 114, 77, 125, 3, 163, 63, 217, 176, 177, 248, 178, 145, 74, 174, 212, 9, 107, 248, 45, 48, 211, 17, 188, 96, 136, 83, 149], legacy_session_id: SessionId { l: 32, id: [14, 42, 56, 213, 63, 69, 56, 178, 22, 41, 205, 7, 210, 222, 111, 102, 206, 247, 209, 81, 40, 145, 42, 139, 94, 83, 45, 217, 69, 117, 73, 166] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 109, 97, 122, 111, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [48, 54, 10, 12, 211, 18, 73, 189, 39, 168, 97, 238, 110, 109, 152, 90, 253, 104, 217, 46, 148, 132, 158, 154, 62, 43, 237, 16, 251, 90, 216, 42] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [250, 208, 190, 225, 82, 114, 77, 125, 3, 163, 63, 217, 176, 177, 248, 178, 145, 74, 174, 212, 9, 107, 248, 45, 48, 211, 17, 188, 96, 136, 83, 149], legacy_session_id: SessionId { l: 32, id: [14, 42, 56, 213, 63, 69, 56, 178, 22, 41, 205, 7, 210, 222, 111, 102, 206, 247, 209, 81, 40, 145, 42, 139, 94, 83, 45, 217, 69, 117, 73, 166] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 109, 97, 122, 111, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [48, 54, 10, 12, 211, 18, 73, 189, 39, 168, 97, 238, 110, 109, 152, 90, 253, 104, 217, 46, 148, 132, 158, 154, 62, 43, 237, 16, 251, 90, 216, 42] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [250, 208, 190, 225, 82, 114, 77, 125, 3, 163, 63, 217, 176, 177, 248, 178, 145, 74, 174, 212, 9, 107, 248, 45, 48, 211, 17, 188, 96, 136, 83, 149], legacy_session_id: SessionId { l: 32, id: [14, 42, 56, 213, 63, 69, 56, 178, 22, 41, 205, 7, 210, 222, 111, 102, 206, 247, 209, 81, 40, 145, 42, 139, 94, 83, 45, 217, 69, 117, 73, 166] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 109, 97, 122, 111, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [48, 54, 10, 12, 211, 18, 73, 189, 39, 168, 97, 238, 110, 109, 152, 90, 253, 104, 217, 46, 148, 132, 158, 154, 62, 43, 237, 16, 251, 90, 216, 42] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: googletagmanager.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [233, 62, 226, 114, 120, 129, 222, 223, 48, 250, 142, 120, 137, 59, 236, 134, 93, 134, 182, 156, 247, 157, 122, 203, 255, 166, 150, 146, 15, 179, 208, 62] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((22, Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 116, 97, 103, 109, 97, 110, 97, 103, 101, 114, 46, 99, 111, 109] }))
+[trace] HostName: Ok((22, Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 116, 97, 103, 109, 97, 110, 97, 103, 101, 114, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((22, HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 116, 97, 103, 109, 97, 110, 97, 103, 101, 114, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((23, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 116, 97, 103, 109, 97, 110, 97, 103, 101, 114, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((25, ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 116, 97, 103, 109, 97, 110, 97, 103, 101, 114, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((25, ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 116, 97, 103, 109, 97, 110, 97, 103, 101, 114, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((29, ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 116, 97, 103, 109, 97, 110, 97, 103, 101, 114, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [62, 121, 227, 115, 130, 156, 207, 36, 73, 220, 230, 158, 246, 180, 153, 157, 234, 65, 187, 170, 19, 58, 105, 49, 247, 155, 21, 132, 243, 43, 102, 54] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [62, 121, 227, 115, 130, 156, 207, 36, 73, 220, 230, 158, 246, 180, 153, 157, 234, 65, 187, 170, 19, 58, 105, 49, 247, 155, 21, 132, 243, 43, 102, 54] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [62, 121, 227, 115, 130, 156, 207, 36, 73, 220, 230, 158, 246, 180, 153, 157, 234, 65, 187, 170, 19, 58, 105, 49, 247, 155, 21, 132, 243, 43, 102, 54] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [62, 121, 227, 115, 130, 156, 207, 36, 73, 220, 230, 158, 246, 180, 153, 157, 234, 65, 187, 170, 19, 58, 105, 49, 247, 155, 21, 132, 243, 43, 102, 54] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((211, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((211, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((215, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 116, 97, 103, 109, 97, 110, 97, 103, 101, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [62, 121, 227, 115, 130, 156, 207, 36, 73, 220, 230, 158, 246, 180, 153, 157, 234, 65, 187, 170, 19, 58, 105, 49, 247, 155, 21, 132, 243, 43, 102, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [111, 50, 236, 131, 218, 76, 115, 57, 48, 139, 240, 145, 135, 119, 149, 10, 106, 40, 45, 102, 170, 111, 115, 51, 251, 120, 4, 176, 189, 105, 152, 149], legacy_session_id: SessionId { l: 32, id: [233, 62, 226, 114, 120, 129, 222, 223, 48, 250, 142, 120, 137, 59, 236, 134, 93, 134, 182, 156, 247, 157, 122, 203, 255, 166, 150, 146, 15, 179, 208, 62] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 116, 97, 103, 109, 97, 110, 97, 103, 101, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [62, 121, 227, 115, 130, 156, 207, 36, 73, 220, 230, 158, 246, 180, 153, 157, 234, 65, 187, 170, 19, 58, 105, 49, 247, 155, 21, 132, 243, 43, 102, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [111, 50, 236, 131, 218, 76, 115, 57, 48, 139, 240, 145, 135, 119, 149, 10, 106, 40, 45, 102, 170, 111, 115, 51, 251, 120, 4, 176, 189, 105, 152, 149], legacy_session_id: SessionId { l: 32, id: [233, 62, 226, 114, 120, 129, 222, 223, 48, 250, 142, 120, 137, 59, 236, 134, 93, 134, 182, 156, 247, 157, 122, 203, 255, 166, 150, 146, 15, 179, 208, 62] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 116, 97, 103, 109, 97, 110, 97, 103, 101, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [62, 121, 227, 115, 130, 156, 207, 36, 73, 220, 230, 158, 246, 180, 153, 157, 234, 65, 187, 170, 19, 58, 105, 49, 247, 155, 21, 132, 243, 43, 102, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [111, 50, 236, 131, 218, 76, 115, 57, 48, 139, 240, 145, 135, 119, 149, 10, 106, 40, 45, 102, 170, 111, 115, 51, 251, 120, 4, 176, 189, 105, 152, 149], legacy_session_id: SessionId { l: 32, id: [233, 62, 226, 114, 120, 129, 222, 223, 48, 250, 142, 120, 137, 59, 236, 134, 93, 134, 182, 156, 247, 157, 122, 203, 255, 166, 150, 146, 15, 179, 208, 62] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 116, 97, 103, 109, 97, 110, 97, 103, 101, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [62, 121, 227, 115, 130, 156, 207, 36, 73, 220, 230, 158, 246, 180, 153, 157, 234, 65, 187, 170, 19, 58, 105, 49, 247, 155, 21, 132, 243, 43, 102, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: fbcdn.net
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [250, 176, 77, 2, 186, 88, 144, 68, 224, 23, 165, 162, 98, 212, 218, 248, 178, 203, 5, 117, 243, 75, 138, 203, 154, 140, 156, 206, 99, 56, 133, 226] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [102, 98, 99, 100, 110, 46, 110, 101, 116] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [102, 98, 99, 100, 110, 46, 110, 101, 116] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [102, 98, 99, 100, 110, 46, 110, 101, 116] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [102, 98, 99, 100, 110, 46, 110, 101, 116] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [102, 98, 99, 100, 110, 46, 110, 101, 116] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [102, 98, 99, 100, 110, 46, 110, 101, 116] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [102, 98, 99, 100, 110, 46, 110, 101, 116] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [191, 55, 67, 91, 169, 6, 214, 11, 13, 51, 245, 63, 238, 86, 11, 143, 41, 47, 58, 162, 54, 5, 180, 167, 162, 253, 70, 251, 104, 90, 112, 98] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [191, 55, 67, 91, 169, 6, 214, 11, 13, 51, 245, 63, 238, 86, 11, 143, 41, 47, 58, 162, 54, 5, 180, 167, 162, 253, 70, 251, 104, 90, 112, 98] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [191, 55, 67, 91, 169, 6, 214, 11, 13, 51, 245, 63, 238, 86, 11, 143, 41, 47, 58, 162, 54, 5, 180, 167, 162, 253, 70, 251, 104, 90, 112, 98] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [191, 55, 67, 91, 169, 6, 214, 11, 13, 51, 245, 63, 238, 86, 11, 143, 41, 47, 58, 162, 54, 5, 180, 167, 162, 253, 70, 251, 104, 90, 112, 98] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [102, 98, 99, 100, 110, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [191, 55, 67, 91, 169, 6, 214, 11, 13, 51, 245, 63, 238, 86, 11, 143, 41, 47, 58, 162, 54, 5, 180, 167, 162, 253, 70, 251, 104, 90, 112, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [115, 219, 188, 92, 32, 34, 69, 192, 108, 109, 50, 134, 87, 6, 47, 167, 107, 12, 6, 203, 42, 1, 204, 31, 171, 151, 126, 177, 128, 9, 68, 223], legacy_session_id: SessionId { l: 32, id: [250, 176, 77, 2, 186, 88, 144, 68, 224, 23, 165, 162, 98, 212, 218, 248, 178, 203, 5, 117, 243, 75, 138, 203, 154, 140, 156, 206, 99, 56, 133, 226] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [102, 98, 99, 100, 110, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [191, 55, 67, 91, 169, 6, 214, 11, 13, 51, 245, 63, 238, 86, 11, 143, 41, 47, 58, 162, 54, 5, 180, 167, 162, 253, 70, 251, 104, 90, 112, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [115, 219, 188, 92, 32, 34, 69, 192, 108, 109, 50, 134, 87, 6, 47, 167, 107, 12, 6, 203, 42, 1, 204, 31, 171, 151, 126, 177, 128, 9, 68, 223], legacy_session_id: SessionId { l: 32, id: [250, 176, 77, 2, 186, 88, 144, 68, 224, 23, 165, 162, 98, 212, 218, 248, 178, 203, 5, 117, 243, 75, 138, 203, 154, 140, 156, 206, 99, 56, 133, 226] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [102, 98, 99, 100, 110, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [191, 55, 67, 91, 169, 6, 214, 11, 13, 51, 245, 63, 238, 86, 11, 143, 41, 47, 58, 162, 54, 5, 180, 167, 162, 253, 70, 251, 104, 90, 112, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [115, 219, 188, 92, 32, 34, 69, 192, 108, 109, 50, 134, 87, 6, 47, 167, 107, 12, 6, 203, 42, 1, 204, 31, 171, 151, 126, 177, 128, 9, 68, 223], legacy_session_id: SessionId { l: 32, id: [250, 176, 77, 2, 186, 88, 144, 68, 224, 23, 165, 162, 98, 212, 218, 248, 178, 203, 5, 117, 243, 75, 138, 203, 154, 140, 156, 206, 99, 56, 133, 226] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [102, 98, 99, 100, 110, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [191, 55, 67, 91, 169, 6, 214, 11, 13, 51, 245, 63, 238, 86, 11, 143, 41, 47, 58, 162, 54, 5, 180, 167, 162, 253, 70, 251, 104, 90, 112, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: workers.dev
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [127, 5, 60, 171, 125, 238, 92, 23, 85, 162, 94, 101, 242, 205, 108, 198, 0, 249, 50, 157, 218, 121, 182, 218, 120, 77, 156, 110, 76, 91, 89, 25] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [119, 111, 114, 107, 101, 114, 115, 46, 100, 101, 118] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [119, 111, 114, 107, 101, 114, 115, 46, 100, 101, 118] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [119, 111, 114, 107, 101, 114, 115, 46, 100, 101, 118] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 111, 114, 107, 101, 114, 115, 46, 100, 101, 118] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 111, 114, 107, 101, 114, 115, 46, 100, 101, 118] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 111, 114, 107, 101, 114, 115, 46, 100, 101, 118] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 111, 114, 107, 101, 114, 115, 46, 100, 101, 118] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [131, 163, 122, 138, 29, 234, 54, 22, 178, 192, 171, 107, 175, 2, 195, 70, 182, 116, 219, 146, 135, 55, 73, 82, 236, 2, 185, 11, 59, 162, 139, 12] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [131, 163, 122, 138, 29, 234, 54, 22, 178, 192, 171, 107, 175, 2, 195, 70, 182, 116, 219, 146, 135, 55, 73, 82, 236, 2, 185, 11, 59, 162, 139, 12] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [131, 163, 122, 138, 29, 234, 54, 22, 178, 192, 171, 107, 175, 2, 195, 70, 182, 116, 219, 146, 135, 55, 73, 82, 236, 2, 185, 11, 59, 162, 139, 12] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [131, 163, 122, 138, 29, 234, 54, 22, 178, 192, 171, 107, 175, 2, 195, 70, 182, 116, 219, 146, 135, 55, 73, 82, 236, 2, 185, 11, 59, 162, 139, 12] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 111, 114, 107, 101, 114, 115, 46, 100, 101, 118] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [131, 163, 122, 138, 29, 234, 54, 22, 178, 192, 171, 107, 175, 2, 195, 70, 182, 116, 219, 146, 135, 55, 73, 82, 236, 2, 185, 11, 59, 162, 139, 12] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [215, 122, 215, 158, 147, 43, 179, 61, 230, 170, 191, 22, 184, 193, 98, 71, 232, 195, 157, 80, 0, 99, 1, 237, 23, 225, 175, 22, 190, 101, 202, 1], legacy_session_id: SessionId { l: 32, id: [127, 5, 60, 171, 125, 238, 92, 23, 85, 162, 94, 101, 242, 205, 108, 198, 0, 249, 50, 157, 218, 121, 182, 218, 120, 77, 156, 110, 76, 91, 89, 25] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 111, 114, 107, 101, 114, 115, 46, 100, 101, 118] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [131, 163, 122, 138, 29, 234, 54, 22, 178, 192, 171, 107, 175, 2, 195, 70, 182, 116, 219, 146, 135, 55, 73, 82, 236, 2, 185, 11, 59, 162, 139, 12] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [215, 122, 215, 158, 147, 43, 179, 61, 230, 170, 191, 22, 184, 193, 98, 71, 232, 195, 157, 80, 0, 99, 1, 237, 23, 225, 175, 22, 190, 101, 202, 1], legacy_session_id: SessionId { l: 32, id: [127, 5, 60, 171, 125, 238, 92, 23, 85, 162, 94, 101, 242, 205, 108, 198, 0, 249, 50, 157, 218, 121, 182, 218, 120, 77, 156, 110, 76, 91, 89, 25] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 111, 114, 107, 101, 114, 115, 46, 100, 101, 118] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [131, 163, 122, 138, 29, 234, 54, 22, 178, 192, 171, 107, 175, 2, 195, 70, 182, 116, 219, 146, 135, 55, 73, 82, 236, 2, 185, 11, 59, 162, 139, 12] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [215, 122, 215, 158, 147, 43, 179, 61, 230, 170, 191, 22, 184, 193, 98, 71, 232, 195, 157, 80, 0, 99, 1, 237, 23, 225, 175, 22, 190, 101, 202, 1], legacy_session_id: SessionId { l: 32, id: [127, 5, 60, 171, 125, 238, 92, 23, 85, 162, 94, 101, 242, 205, 108, 198, 0, 249, 50, 157, 218, 121, 182, 218, 120, 77, 156, 110, 76, 91, 89, 25] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 111, 114, 107, 101, 114, 115, 46, 100, 101, 118] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [131, 163, 122, 138, 29, 234, 54, 22, 178, 192, 171, 107, 175, 2, 195, 70, 182, 116, 219, 146, 135, 55, 73, 82, 236, 2, 185, 11, 59, 162, 139, 12] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: wikipedia.org
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [1, 14, 35, 41, 92, 221, 1, 169, 5, 26, 42, 185, 123, 34, 14, 2, 86, 90, 201, 58, 130, 157, 169, 113, 179, 150, 175, 5, 62, 200, 107, 222] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((15, Opaque1Ffff { l: 13, data: [119, 105, 107, 105, 112, 101, 100, 105, 97, 46, 111, 114, 103] }))
+[trace] HostName: Ok((15, Opaque1Ffff { l: 13, data: [119, 105, 107, 105, 112, 101, 100, 105, 97, 46, 111, 114, 103] }))
+[trace] ServerNameName: Ok((15, HostName(Opaque1Ffff { l: 13, data: [119, 105, 107, 105, 112, 101, 100, 105, 97, 46, 111, 114, 103] })))
+[trace] ServerName: Ok((16, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 105, 107, 105, 112, 101, 100, 105, 97, 46, 111, 114, 103] }) }))
+[trace] ServerNameList: Ok((18, ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 105, 107, 105, 112, 101, 100, 105, 97, 46, 111, 114, 103] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((18, ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 105, 107, 105, 112, 101, 100, 105, 97, 46, 111, 114, 103] }) }]) })))
+[trace] ClientHelloExtension: Ok((22, ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 105, 107, 105, 112, 101, 100, 105, 97, 46, 111, 114, 103] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [87, 131, 90, 53, 187, 153, 148, 17, 248, 46, 130, 22, 165, 37, 104, 199, 54, 246, 114, 182, 102, 18, 229, 105, 172, 199, 93, 80, 221, 179, 12, 43] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [87, 131, 90, 53, 187, 153, 148, 17, 248, 46, 130, 22, 165, 37, 104, 199, 54, 246, 114, 182, 102, 18, 229, 105, 172, 199, 93, 80, 221, 179, 12, 43] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [87, 131, 90, 53, 187, 153, 148, 17, 248, 46, 130, 22, 165, 37, 104, 199, 54, 246, 114, 182, 102, 18, 229, 105, 172, 199, 93, 80, 221, 179, 12, 43] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [87, 131, 90, 53, 187, 153, 148, 17, 248, 46, 130, 22, 165, 37, 104, 199, 54, 246, 114, 182, 102, 18, 229, 105, 172, 199, 93, 80, 221, 179, 12, 43] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((218, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((218, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((222, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 105, 107, 105, 112, 101, 100, 105, 97, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [87, 131, 90, 53, 187, 153, 148, 17, 248, 46, 130, 22, 165, 37, 104, 199, 54, 246, 114, 182, 102, 18, 229, 105, 172, 199, 93, 80, 221, 179, 12, 43] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [155, 39, 192, 198, 98, 105, 65, 173, 236, 143, 138, 140, 96, 109, 145, 155, 241, 128, 71, 31, 49, 182, 118, 55, 225, 188, 63, 134, 72, 168, 147, 36], legacy_session_id: SessionId { l: 32, id: [1, 14, 35, 41, 92, 221, 1, 169, 5, 26, 42, 185, 123, 34, 14, 2, 86, 90, 201, 58, 130, 157, 169, 113, 179, 150, 175, 5, 62, 200, 107, 222] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 105, 107, 105, 112, 101, 100, 105, 97, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [87, 131, 90, 53, 187, 153, 148, 17, 248, 46, 130, 22, 165, 37, 104, 199, 54, 246, 114, 182, 102, 18, 229, 105, 172, 199, 93, 80, 221, 179, 12, 43] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [155, 39, 192, 198, 98, 105, 65, 173, 236, 143, 138, 140, 96, 109, 145, 155, 241, 128, 71, 31, 49, 182, 118, 55, 225, 188, 63, 134, 72, 168, 147, 36], legacy_session_id: SessionId { l: 32, id: [1, 14, 35, 41, 92, 221, 1, 169, 5, 26, 42, 185, 123, 34, 14, 2, 86, 90, 201, 58, 130, 157, 169, 113, 179, 150, 175, 5, 62, 200, 107, 222] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 105, 107, 105, 112, 101, 100, 105, 97, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [87, 131, 90, 53, 187, 153, 148, 17, 248, 46, 130, 22, 165, 37, 104, 199, 54, 246, 114, 182, 102, 18, 229, 105, 172, 199, 93, 80, 221, 179, 12, 43] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [155, 39, 192, 198, 98, 105, 65, 173, 236, 143, 138, 140, 96, 109, 145, 155, 241, 128, 71, 31, 49, 182, 118, 55, 225, 188, 63, 134, 72, 168, 147, 36], legacy_session_id: SessionId { l: 32, id: [1, 14, 35, 41, 92, 221, 1, 169, 5, 26, 42, 185, 123, 34, 14, 2, 86, 90, 201, 58, 130, 157, 169, 113, 179, 150, 175, 5, 62, 200, 107, 222] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 105, 107, 105, 112, 101, 100, 105, 97, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [87, 131, 90, 53, 187, 153, 148, 17, 248, 46, 130, 22, 165, 37, 104, 199, 54, 246, 114, 182, 102, 18, 229, 105, 172, 199, 93, 80, 221, 179, 12, 43] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: doubleclick.net
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [128, 24, 168, 16, 37, 121, 216, 198, 148, 118, 118, 51, 187, 208, 109, 234, 73, 93, 146, 224, 80, 50, 80, 40, 92, 92, 140, 145, 236, 192, 207, 103] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((17, Opaque1Ffff { l: 15, data: [100, 111, 117, 98, 108, 101, 99, 108, 105, 99, 107, 46, 110, 101, 116] }))
+[trace] HostName: Ok((17, Opaque1Ffff { l: 15, data: [100, 111, 117, 98, 108, 101, 99, 108, 105, 99, 107, 46, 110, 101, 116] }))
+[trace] ServerNameName: Ok((17, HostName(Opaque1Ffff { l: 15, data: [100, 111, 117, 98, 108, 101, 99, 108, 105, 99, 107, 46, 110, 101, 116] })))
+[trace] ServerName: Ok((18, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 15, data: [100, 111, 117, 98, 108, 101, 99, 108, 105, 99, 107, 46, 110, 101, 116] }) }))
+[trace] ServerNameList: Ok((20, ServerNameList { l: 18, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 15, data: [100, 111, 117, 98, 108, 101, 99, 108, 105, 99, 107, 46, 110, 101, 116] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((20, ServerName(ServerNameList { l: 18, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 15, data: [100, 111, 117, 98, 108, 101, 99, 108, 105, 99, 107, 46, 110, 101, 116] }) }]) })))
+[trace] ClientHelloExtension: Ok((24, ClientHelloExtension { extension_type: 0, ext_len: 20, extension_data: ServerName(ServerNameList { l: 18, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 15, data: [100, 111, 117, 98, 108, 101, 99, 108, 105, 99, 107, 46, 110, 101, 116] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [139, 153, 47, 178, 54, 150, 88, 102, 61, 25, 230, 133, 119, 201, 61, 200, 5, 252, 109, 191, 157, 201, 220, 95, 78, 178, 205, 0, 236, 192, 213, 54] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 153, 47, 178, 54, 150, 88, 102, 61, 25, 230, 133, 119, 201, 61, 200, 5, 252, 109, 191, 157, 201, 220, 95, 78, 178, 205, 0, 236, 192, 213, 54] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 153, 47, 178, 54, 150, 88, 102, 61, 25, 230, 133, 119, 201, 61, 200, 5, 252, 109, 191, 157, 201, 220, 95, 78, 178, 205, 0, 236, 192, 213, 54] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 153, 47, 178, 54, 150, 88, 102, 61, 25, 230, 133, 119, 201, 61, 200, 5, 252, 109, 191, 157, 201, 220, 95, 78, 178, 205, 0, 236, 192, 213, 54] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((216, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((216, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((220, ClientHelloExtension { extension_type: 21, ext_len: 216, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 20, extension_data: ServerName(ServerNameList { l: 18, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 15, data: [100, 111, 117, 98, 108, 101, 99, 108, 105, 99, 107, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 153, 47, 178, 54, 150, 88, 102, 61, 25, 230, 133, 119, 201, 61, 200, 5, 252, 109, 191, 157, 201, 220, 95, 78, 178, 205, 0, 236, 192, 213, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 216, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [173, 33, 221, 217, 103, 174, 119, 83, 197, 120, 178, 209, 223, 116, 112, 203, 24, 173, 169, 24, 224, 194, 18, 251, 37, 218, 41, 158, 173, 40, 168, 118], legacy_session_id: SessionId { l: 32, id: [128, 24, 168, 16, 37, 121, 216, 198, 148, 118, 118, 51, 187, 208, 109, 234, 73, 93, 146, 224, 80, 50, 80, 40, 92, 92, 140, 145, 236, 192, 207, 103] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 20, extension_data: ServerName(ServerNameList { l: 18, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 15, data: [100, 111, 117, 98, 108, 101, 99, 108, 105, 99, 107, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 153, 47, 178, 54, 150, 88, 102, 61, 25, 230, 133, 119, 201, 61, 200, 5, 252, 109, 191, 157, 201, 220, 95, 78, 178, 205, 0, 236, 192, 213, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 216, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [173, 33, 221, 217, 103, 174, 119, 83, 197, 120, 178, 209, 223, 116, 112, 203, 24, 173, 169, 24, 224, 194, 18, 251, 37, 218, 41, 158, 173, 40, 168, 118], legacy_session_id: SessionId { l: 32, id: [128, 24, 168, 16, 37, 121, 216, 198, 148, 118, 118, 51, 187, 208, 109, 234, 73, 93, 146, 224, 80, 50, 80, 40, 92, 92, 140, 145, 236, 192, 207, 103] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 20, extension_data: ServerName(ServerNameList { l: 18, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 15, data: [100, 111, 117, 98, 108, 101, 99, 108, 105, 99, 107, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 153, 47, 178, 54, 150, 88, 102, 61, 25, 230, 133, 119, 201, 61, 200, 5, 252, 109, 191, 157, 201, 220, 95, 78, 178, 205, 0, 236, 192, 213, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 216, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [173, 33, 221, 217, 103, 174, 119, 83, 197, 120, 178, 209, 223, 116, 112, 203, 24, 173, 169, 24, 224, 194, 18, 251, 37, 218, 41, 158, 173, 40, 168, 118], legacy_session_id: SessionId { l: 32, id: [128, 24, 168, 16, 37, 121, 216, 198, 148, 118, 118, 51, 187, 208, 109, 234, 73, 93, 146, 224, 80, 50, 80, 40, 92, 92, 140, 145, 236, 192, 207, 103] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 20, extension_data: ServerName(ServerNameList { l: 18, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 15, data: [100, 111, 117, 98, 108, 101, 99, 108, 105, 99, 107, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 153, 47, 178, 54, 150, 88, 102, 61, 25, 230, 133, 119, 201, 61, 200, 5, 252, 109, 191, 157, 201, 220, 95, 78, 178, 205, 0, 236, 192, 213, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 216, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: googleusercontent.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [205, 29, 139, 153, 40, 217, 191, 103, 45, 151, 2, 134, 97, 110, 147, 91, 233, 7, 33, 51, 150, 168, 72, 128, 116, 117, 231, 16, 44, 164, 178, 191] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((23, Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 117, 115, 101, 114, 99, 111, 110, 116, 101, 110, 116, 46, 99, 111, 109] }))
+[trace] HostName: Ok((23, Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 117, 115, 101, 114, 99, 111, 110, 116, 101, 110, 116, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((23, HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 117, 115, 101, 114, 99, 111, 110, 116, 101, 110, 116, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((24, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 117, 115, 101, 114, 99, 111, 110, 116, 101, 110, 116, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((26, ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 117, 115, 101, 114, 99, 111, 110, 116, 101, 110, 116, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((26, ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 117, 115, 101, 114, 99, 111, 110, 116, 101, 110, 116, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((30, ClientHelloExtension { extension_type: 0, ext_len: 26, extension_data: ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 117, 115, 101, 114, 99, 111, 110, 116, 101, 110, 116, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [204, 117, 48, 72, 116, 47, 47, 13, 77, 104, 106, 53, 132, 48, 198, 74, 232, 71, 236, 199, 165, 140, 10, 116, 150, 178, 9, 1, 14, 243, 254, 19] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 117, 48, 72, 116, 47, 47, 13, 77, 104, 106, 53, 132, 48, 198, 74, 232, 71, 236, 199, 165, 140, 10, 116, 150, 178, 9, 1, 14, 243, 254, 19] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 117, 48, 72, 116, 47, 47, 13, 77, 104, 106, 53, 132, 48, 198, 74, 232, 71, 236, 199, 165, 140, 10, 116, 150, 178, 9, 1, 14, 243, 254, 19] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 117, 48, 72, 116, 47, 47, 13, 77, 104, 106, 53, 132, 48, 198, 74, 232, 71, 236, 199, 165, 140, 10, 116, 150, 178, 9, 1, 14, 243, 254, 19] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((210, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((210, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((214, ClientHelloExtension { extension_type: 21, ext_len: 210, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 26, extension_data: ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 117, 115, 101, 114, 99, 111, 110, 116, 101, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 117, 48, 72, 116, 47, 47, 13, 77, 104, 106, 53, 132, 48, 198, 74, 232, 71, 236, 199, 165, 140, 10, 116, 150, 178, 9, 1, 14, 243, 254, 19] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 210, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [97, 36, 172, 128, 212, 73, 161, 62, 173, 107, 233, 11, 200, 203, 205, 206, 249, 117, 99, 17, 51, 255, 5, 96, 61, 186, 27, 131, 11, 101, 235, 77], legacy_session_id: SessionId { l: 32, id: [205, 29, 139, 153, 40, 217, 191, 103, 45, 151, 2, 134, 97, 110, 147, 91, 233, 7, 33, 51, 150, 168, 72, 128, 116, 117, 231, 16, 44, 164, 178, 191] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 26, extension_data: ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 117, 115, 101, 114, 99, 111, 110, 116, 101, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 117, 48, 72, 116, 47, 47, 13, 77, 104, 106, 53, 132, 48, 198, 74, 232, 71, 236, 199, 165, 140, 10, 116, 150, 178, 9, 1, 14, 243, 254, 19] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 210, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [97, 36, 172, 128, 212, 73, 161, 62, 173, 107, 233, 11, 200, 203, 205, 206, 249, 117, 99, 17, 51, 255, 5, 96, 61, 186, 27, 131, 11, 101, 235, 77], legacy_session_id: SessionId { l: 32, id: [205, 29, 139, 153, 40, 217, 191, 103, 45, 151, 2, 134, 97, 110, 147, 91, 233, 7, 33, 51, 150, 168, 72, 128, 116, 117, 231, 16, 44, 164, 178, 191] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 26, extension_data: ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 117, 115, 101, 114, 99, 111, 110, 116, 101, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 117, 48, 72, 116, 47, 47, 13, 77, 104, 106, 53, 132, 48, 198, 74, 232, 71, 236, 199, 165, 140, 10, 116, 150, 178, 9, 1, 14, 243, 254, 19] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 210, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [97, 36, 172, 128, 212, 73, 161, 62, 173, 107, 233, 11, 200, 203, 205, 206, 249, 117, 99, 17, 51, 255, 5, 96, 61, 186, 27, 131, 11, 101, 235, 77], legacy_session_id: SessionId { l: 32, id: [205, 29, 139, 153, 40, 217, 191, 103, 45, 151, 2, 134, 97, 110, 147, 91, 233, 7, 33, 51, 150, 168, 72, 128, 116, 117, 231, 16, 44, 164, 178, 191] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 26, extension_data: ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 117, 115, 101, 114, 99, 111, 110, 116, 101, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 117, 48, 72, 116, 47, 47, 13, 77, 104, 106, 53, 132, 48, 198, 74, 232, 71, 236, 199, 165, 140, 10, 116, 150, 178, 9, 1, 14, 243, 254, 19] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 210, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: bing.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [22, 95, 148, 77, 28, 40, 143, 191, 1, 119, 255, 80, 24, 76, 250, 29, 98, 224, 193, 0, 3, 229, 71, 182, 230, 169, 246, 54, 93, 116, 231, 254] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((10, Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }))
+[trace] HostName: Ok((10, Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((10, HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((11, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((13, ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((13, ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((17, ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [80, 197, 90, 45, 195, 255, 96, 192, 169, 3, 133, 32, 165, 117, 71, 102, 212, 162, 40, 255, 124, 154, 254, 36, 17, 6, 56, 33, 33, 199, 97, 23] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [80, 197, 90, 45, 195, 255, 96, 192, 169, 3, 133, 32, 165, 117, 71, 102, 212, 162, 40, 255, 124, 154, 254, 36, 17, 6, 56, 33, 33, 199, 97, 23] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [80, 197, 90, 45, 195, 255, 96, 192, 169, 3, 133, 32, 165, 117, 71, 102, 212, 162, 40, 255, 124, 154, 254, 36, 17, 6, 56, 33, 33, 199, 97, 23] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [80, 197, 90, 45, 195, 255, 96, 192, 169, 3, 133, 32, 165, 117, 71, 102, 212, 162, 40, 255, 124, 154, 254, 36, 17, 6, 56, 33, 33, 199, 97, 23] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((223, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((223, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((227, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [80, 197, 90, 45, 195, 255, 96, 192, 169, 3, 133, 32, 165, 117, 71, 102, 212, 162, 40, 255, 124, 154, 254, 36, 17, 6, 56, 33, 33, 199, 97, 23] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [118, 203, 96, 172, 193, 174, 144, 229, 185, 229, 17, 65, 231, 246, 128, 51, 87, 195, 240, 136, 7, 129, 255, 15, 165, 241, 27, 117, 219, 19, 177, 100], legacy_session_id: SessionId { l: 32, id: [22, 95, 148, 77, 28, 40, 143, 191, 1, 119, 255, 80, 24, 76, 250, 29, 98, 224, 193, 0, 3, 229, 71, 182, 230, 169, 246, 54, 93, 116, 231, 254] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [80, 197, 90, 45, 195, 255, 96, 192, 169, 3, 133, 32, 165, 117, 71, 102, 212, 162, 40, 255, 124, 154, 254, 36, 17, 6, 56, 33, 33, 199, 97, 23] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [118, 203, 96, 172, 193, 174, 144, 229, 185, 229, 17, 65, 231, 246, 128, 51, 87, 195, 240, 136, 7, 129, 255, 15, 165, 241, 27, 117, 219, 19, 177, 100], legacy_session_id: SessionId { l: 32, id: [22, 95, 148, 77, 28, 40, 143, 191, 1, 119, 255, 80, 24, 76, 250, 29, 98, 224, 193, 0, 3, 229, 71, 182, 230, 169, 246, 54, 93, 116, 231, 254] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [80, 197, 90, 45, 195, 255, 96, 192, 169, 3, 133, 32, 165, 117, 71, 102, 212, 162, 40, 255, 124, 154, 254, 36, 17, 6, 56, 33, 33, 199, 97, 23] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [118, 203, 96, 172, 193, 174, 144, 229, 185, 229, 17, 65, 231, 246, 128, 51, 87, 195, 240, 136, 7, 129, 255, 15, 165, 241, 27, 117, 219, 19, 177, 100], legacy_session_id: SessionId { l: 32, id: [22, 95, 148, 77, 28, 40, 143, 191, 1, 119, 255, 80, 24, 76, 250, 29, 98, 224, 193, 0, 3, 229, 71, 182, 230, 169, 246, 54, 93, 116, 231, 254] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [80, 197, 90, 45, 195, 255, 96, 192, 169, 3, 133, 32, 165, 117, 71, 102, 212, 162, 40, 255, 124, 154, 254, 36, 17, 6, 56, 33, 33, 199, 97, 23] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [22, 95, 148, 77, 28, 40, 143, 191, 1, 119, 255, 80, 24, 76, 250, 29, 98, 224, 193, 0, 3, 229, 71, 182, 230, 169, 246, 54, 93, 116, 231, 254] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((10, Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }))
+[trace] HostName: Ok((10, Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((10, HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((11, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((13, ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((13, ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((17, ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 25))
+[trace] KeyShareEntry: Ok((137, KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 179, 90, 69, 103, 156, 204, 76, 4, 145, 154, 229, 177, 223, 59, 184, 236, 110, 163, 213, 27, 26, 127, 174, 72, 92, 206, 93, 186, 139, 19, 237, 136, 103, 40, 75, 139, 185, 162, 11, 158, 47, 212, 236, 212, 19, 190, 49, 80, 165, 186, 250, 240, 56, 111, 110, 14, 103, 108, 47, 223, 77, 226, 24, 79, 219, 0, 60, 212, 139, 5, 21, 191, 63, 226, 45, 183, 171, 222, 243, 13, 170, 120, 245, 87, 50, 17, 3, 76, 241, 102, 27, 241, 36, 214, 64, 137, 203, 91, 20, 116, 143, 214, 174, 85, 187, 122, 110, 9, 24, 99, 209, 152, 209, 142, 248, 236, 238, 226, 13, 37, 115, 164, 84, 228, 91, 66, 123, 157, 26, 77, 72] }))
+[trace] KeyShareClientHello: Ok((139, KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 179, 90, 69, 103, 156, 204, 76, 4, 145, 154, 229, 177, 223, 59, 184, 236, 110, 163, 213, 27, 26, 127, 174, 72, 92, 206, 93, 186, 139, 19, 237, 136, 103, 40, 75, 139, 185, 162, 11, 158, 47, 212, 236, 212, 19, 190, 49, 80, 165, 186, 250, 240, 56, 111, 110, 14, 103, 108, 47, 223, 77, 226, 24, 79, 219, 0, 60, 212, 139, 5, 21, 191, 63, 226, 45, 183, 171, 222, 243, 13, 170, 120, 245, 87, 50, 17, 3, 76, 241, 102, 27, 241, 36, 214, 64, 137, 203, 91, 20, 116, 143, 214, 174, 85, 187, 122, 110, 9, 24, 99, 209, 152, 209, 142, 248, 236, 238, 226, 13, 37, 115, 164, 84, 228, 91, 66, 123, 157, 26, 77, 72] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((139, KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 179, 90, 69, 103, 156, 204, 76, 4, 145, 154, 229, 177, 223, 59, 184, 236, 110, 163, 213, 27, 26, 127, 174, 72, 92, 206, 93, 186, 139, 19, 237, 136, 103, 40, 75, 139, 185, 162, 11, 158, 47, 212, 236, 212, 19, 190, 49, 80, 165, 186, 250, 240, 56, 111, 110, 14, 103, 108, 47, 223, 77, 226, 24, 79, 219, 0, 60, 212, 139, 5, 21, 191, 63, 226, 45, 183, 171, 222, 243, 13, 170, 120, 245, 87, 50, 17, 3, 76, 241, 102, 27, 241, 36, 214, 64, 137, 203, 91, 20, 116, 143, 214, 174, 85, 187, 122, 110, 9, 24, 99, 209, 152, 209, 142, 248, 236, 238, 226, 13, 37, 115, 164, 84, 228, 91, 66, 123, 157, 26, 77, 72] }]) })))
+[trace] ClientHelloExtension: Ok((143, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 179, 90, 69, 103, 156, 204, 76, 4, 145, 154, 229, 177, 223, 59, 184, 236, 110, 163, 213, 27, 26, 127, 174, 72, 92, 206, 93, 186, 139, 19, 237, 136, 103, 40, 75, 139, 185, 162, 11, 158, 47, 212, 236, 212, 19, 190, 49, 80, 165, 186, 250, 240, 56, 111, 110, 14, 103, 108, 47, 223, 77, 226, 24, 79, 219, 0, 60, 212, 139, 5, 21, 191, 63, 226, 45, 183, 171, 222, 243, 13, 170, 120, 245, 87, 50, 17, 3, 76, 241, 102, 27, 241, 36, 214, 64, 137, 203, 91, 20, 116, 143, 214, 174, 85, 187, 122, 110, 9, 24, 99, 209, 152, 209, 142, 248, 236, 238, 226, 13, 37, 115, 164, 84, 228, 91, 66, 123, 157, 26, 77, 72] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((122, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((122, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((126, ClientHelloExtension { extension_type: 21, ext_len: 122, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 179, 90, 69, 103, 156, 204, 76, 4, 145, 154, 229, 177, 223, 59, 184, 236, 110, 163, 213, 27, 26, 127, 174, 72, 92, 206, 93, 186, 139, 19, 237, 136, 103, 40, 75, 139, 185, 162, 11, 158, 47, 212, 236, 212, 19, 190, 49, 80, 165, 186, 250, 240, 56, 111, 110, 14, 103, 108, 47, 223, 77, 226, 24, 79, 219, 0, 60, 212, 139, 5, 21, 191, 63, 226, 45, 183, 171, 222, 243, 13, 170, 120, 245, 87, 50, 17, 3, 76, 241, 102, 27, 241, 36, 214, 64, 137, 203, 91, 20, 116, 143, 214, 174, 85, 187, 122, 110, 9, 24, 99, 209, 152, 209, 142, 248, 236, 238, 226, 13, 37, 115, 164, 84, 228, 91, 66, 123, 157, 26, 77, 72] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 122, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [118, 203, 96, 172, 193, 174, 144, 229, 185, 229, 17, 65, 231, 246, 128, 51, 87, 195, 240, 136, 7, 129, 255, 15, 165, 241, 27, 117, 219, 19, 177, 100], legacy_session_id: SessionId { l: 32, id: [22, 95, 148, 77, 28, 40, 143, 191, 1, 119, 255, 80, 24, 76, 250, 29, 98, 224, 193, 0, 3, 229, 71, 182, 230, 169, 246, 54, 93, 116, 231, 254] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 179, 90, 69, 103, 156, 204, 76, 4, 145, 154, 229, 177, 223, 59, 184, 236, 110, 163, 213, 27, 26, 127, 174, 72, 92, 206, 93, 186, 139, 19, 237, 136, 103, 40, 75, 139, 185, 162, 11, 158, 47, 212, 236, 212, 19, 190, 49, 80, 165, 186, 250, 240, 56, 111, 110, 14, 103, 108, 47, 223, 77, 226, 24, 79, 219, 0, 60, 212, 139, 5, 21, 191, 63, 226, 45, 183, 171, 222, 243, 13, 170, 120, 245, 87, 50, 17, 3, 76, 241, 102, 27, 241, 36, 214, 64, 137, 203, 91, 20, 116, 143, 214, 174, 85, 187, 122, 110, 9, 24, 99, 209, 152, 209, 142, 248, 236, 238, 226, 13, 37, 115, 164, 84, 228, 91, 66, 123, 157, 26, 77, 72] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 122, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [118, 203, 96, 172, 193, 174, 144, 229, 185, 229, 17, 65, 231, 246, 128, 51, 87, 195, 240, 136, 7, 129, 255, 15, 165, 241, 27, 117, 219, 19, 177, 100], legacy_session_id: SessionId { l: 32, id: [22, 95, 148, 77, 28, 40, 143, 191, 1, 119, 255, 80, 24, 76, 250, 29, 98, 224, 193, 0, 3, 229, 71, 182, 230, 169, 246, 54, 93, 116, 231, 254] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 179, 90, 69, 103, 156, 204, 76, 4, 145, 154, 229, 177, 223, 59, 184, 236, 110, 163, 213, 27, 26, 127, 174, 72, 92, 206, 93, 186, 139, 19, 237, 136, 103, 40, 75, 139, 185, 162, 11, 158, 47, 212, 236, 212, 19, 190, 49, 80, 165, 186, 250, 240, 56, 111, 110, 14, 103, 108, 47, 223, 77, 226, 24, 79, 219, 0, 60, 212, 139, 5, 21, 191, 63, 226, 45, 183, 171, 222, 243, 13, 170, 120, 245, 87, 50, 17, 3, 76, 241, 102, 27, 241, 36, 214, 64, 137, 203, 91, 20, 116, 143, 214, 174, 85, 187, 122, 110, 9, 24, 99, 209, 152, 209, 142, 248, 236, 238, 226, 13, 37, 115, 164, 84, 228, 91, 66, 123, 157, 26, 77, 72] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 122, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [118, 203, 96, 172, 193, 174, 144, 229, 185, 229, 17, 65, 231, 246, 128, 51, 87, 195, 240, 136, 7, 129, 255, 15, 165, 241, 27, 117, 219, 19, 177, 100], legacy_session_id: SessionId { l: 32, id: [22, 95, 148, 77, 28, 40, 143, 191, 1, 119, 255, 80, 24, 76, 250, 29, 98, 224, 193, 0, 3, 229, 71, 182, 230, 169, 246, 54, 93, 116, 231, 254] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [98, 105, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 1, 179, 90, 69, 103, 156, 204, 76, 4, 145, 154, 229, 177, 223, 59, 184, 236, 110, 163, 213, 27, 26, 127, 174, 72, 92, 206, 93, 186, 139, 19, 237, 136, 103, 40, 75, 139, 185, 162, 11, 158, 47, 212, 236, 212, 19, 190, 49, 80, 165, 186, 250, 240, 56, 111, 110, 14, 103, 108, 47, 223, 77, 226, 24, 79, 219, 0, 60, 212, 139, 5, 21, 191, 63, 226, 45, 183, 171, 222, 243, 13, 170, 120, 245, 87, 50, 17, 3, 76, 241, 102, 27, 241, 36, 214, 64, 137, 203, 91, 20, 116, 143, 214, 174, 85, 187, 122, 110, 9, 24, 99, 209, 152, 209, 142, 248, 236, 238, 226, 13, 37, 115, 164, 84, 228, 91, 66, 123, 157, 26, 77, 72] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 122, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: github.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [42, 112, 251, 22, 194, 107, 173, 123, 202, 244, 148, 120, 115, 146, 61, 69, 55, 56, 41, 112, 145, 49, 120, 183, 25, 63, 96, 196, 184, 61, 101, 235] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [103, 105, 116, 104, 117, 98, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [103, 105, 116, 104, 117, 98, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [103, 105, 116, 104, 117, 98, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 105, 116, 104, 117, 98, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 105, 116, 104, 117, 98, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 105, 116, 104, 117, 98, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 105, 116, 104, 117, 98, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [83, 102, 211, 207, 229, 151, 121, 108, 77, 88, 10, 123, 55, 2, 225, 185, 106, 138, 115, 56, 176, 66, 164, 169, 180, 158, 117, 188, 29, 114, 159, 100] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [83, 102, 211, 207, 229, 151, 121, 108, 77, 88, 10, 123, 55, 2, 225, 185, 106, 138, 115, 56, 176, 66, 164, 169, 180, 158, 117, 188, 29, 114, 159, 100] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [83, 102, 211, 207, 229, 151, 121, 108, 77, 88, 10, 123, 55, 2, 225, 185, 106, 138, 115, 56, 176, 66, 164, 169, 180, 158, 117, 188, 29, 114, 159, 100] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [83, 102, 211, 207, 229, 151, 121, 108, 77, 88, 10, 123, 55, 2, 225, 185, 106, 138, 115, 56, 176, 66, 164, 169, 180, 158, 117, 188, 29, 114, 159, 100] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 105, 116, 104, 117, 98, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [83, 102, 211, 207, 229, 151, 121, 108, 77, 88, 10, 123, 55, 2, 225, 185, 106, 138, 115, 56, 176, 66, 164, 169, 180, 158, 117, 188, 29, 114, 159, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [234, 53, 155, 24, 231, 70, 86, 71, 102, 96, 116, 65, 226, 45, 227, 53, 148, 68, 113, 75, 207, 11, 66, 15, 169, 72, 149, 46, 24, 229, 87, 120], legacy_session_id: SessionId { l: 32, id: [42, 112, 251, 22, 194, 107, 173, 123, 202, 244, 148, 120, 115, 146, 61, 69, 55, 56, 41, 112, 145, 49, 120, 183, 25, 63, 96, 196, 184, 61, 101, 235] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 105, 116, 104, 117, 98, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [83, 102, 211, 207, 229, 151, 121, 108, 77, 88, 10, 123, 55, 2, 225, 185, 106, 138, 115, 56, 176, 66, 164, 169, 180, 158, 117, 188, 29, 114, 159, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [234, 53, 155, 24, 231, 70, 86, 71, 102, 96, 116, 65, 226, 45, 227, 53, 148, 68, 113, 75, 207, 11, 66, 15, 169, 72, 149, 46, 24, 229, 87, 120], legacy_session_id: SessionId { l: 32, id: [42, 112, 251, 22, 194, 107, 173, 123, 202, 244, 148, 120, 115, 146, 61, 69, 55, 56, 41, 112, 145, 49, 120, 183, 25, 63, 96, 196, 184, 61, 101, 235] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 105, 116, 104, 117, 98, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [83, 102, 211, 207, 229, 151, 121, 108, 77, 88, 10, 123, 55, 2, 225, 185, 106, 138, 115, 56, 176, 66, 164, 169, 180, 158, 117, 188, 29, 114, 159, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [234, 53, 155, 24, 231, 70, 86, 71, 102, 96, 116, 65, 226, 45, 227, 53, 148, 68, 113, 75, 207, 11, 66, 15, 169, 72, 149, 46, 24, 229, 87, 120], legacy_session_id: SessionId { l: 32, id: [42, 112, 251, 22, 194, 107, 173, 123, 202, 244, 148, 120, 115, 146, 61, 69, 55, 56, 41, 112, 145, 49, 120, 183, 25, 63, 96, 196, 184, 61, 101, 235] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [103, 105, 116, 104, 117, 98, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [83, 102, 211, 207, 229, 151, 121, 108, 77, 88, 10, 123, 55, 2, 225, 185, 106, 138, 115, 56, 176, 66, 164, 169, 180, 158, 117, 188, 29, 114, 159, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: wordpress.org
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [155, 235, 1, 10, 72, 147, 17, 246, 20, 113, 164, 27, 185, 137, 35, 7, 182, 109, 176, 94, 246, 36, 49, 23, 120, 139, 229, 70, 134, 66, 111, 143] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((15, Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 111, 114, 103] }))
+[trace] HostName: Ok((15, Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 111, 114, 103] }))
+[trace] ServerNameName: Ok((15, HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 111, 114, 103] })))
+[trace] ServerName: Ok((16, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 111, 114, 103] }) }))
+[trace] ServerNameList: Ok((18, ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 111, 114, 103] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((18, ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 111, 114, 103] }) }]) })))
+[trace] ClientHelloExtension: Ok((22, ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 111, 114, 103] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [184, 226, 42, 116, 169, 50, 110, 168, 135, 253, 97, 228, 76, 168, 38, 7, 222, 255, 137, 192, 132, 236, 8, 252, 203, 22, 190, 11, 172, 130, 204, 68] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [184, 226, 42, 116, 169, 50, 110, 168, 135, 253, 97, 228, 76, 168, 38, 7, 222, 255, 137, 192, 132, 236, 8, 252, 203, 22, 190, 11, 172, 130, 204, 68] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [184, 226, 42, 116, 169, 50, 110, 168, 135, 253, 97, 228, 76, 168, 38, 7, 222, 255, 137, 192, 132, 236, 8, 252, 203, 22, 190, 11, 172, 130, 204, 68] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [184, 226, 42, 116, 169, 50, 110, 168, 135, 253, 97, 228, 76, 168, 38, 7, 222, 255, 137, 192, 132, 236, 8, 252, 203, 22, 190, 11, 172, 130, 204, 68] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((218, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((218, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((222, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [184, 226, 42, 116, 169, 50, 110, 168, 135, 253, 97, 228, 76, 168, 38, 7, 222, 255, 137, 192, 132, 236, 8, 252, 203, 22, 190, 11, 172, 130, 204, 68] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [34, 95, 184, 177, 10, 85, 58, 167, 166, 191, 141, 222, 67, 108, 63, 7, 67, 222, 141, 167, 90, 48, 36, 106, 157, 44, 140, 106, 172, 215, 138, 89], legacy_session_id: SessionId { l: 32, id: [155, 235, 1, 10, 72, 147, 17, 246, 20, 113, 164, 27, 185, 137, 35, 7, 182, 109, 176, 94, 246, 36, 49, 23, 120, 139, 229, 70, 134, 66, 111, 143] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [184, 226, 42, 116, 169, 50, 110, 168, 135, 253, 97, 228, 76, 168, 38, 7, 222, 255, 137, 192, 132, 236, 8, 252, 203, 22, 190, 11, 172, 130, 204, 68] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [34, 95, 184, 177, 10, 85, 58, 167, 166, 191, 141, 222, 67, 108, 63, 7, 67, 222, 141, 167, 90, 48, 36, 106, 157, 44, 140, 106, 172, 215, 138, 89], legacy_session_id: SessionId { l: 32, id: [155, 235, 1, 10, 72, 147, 17, 246, 20, 113, 164, 27, 185, 137, 35, 7, 182, 109, 176, 94, 246, 36, 49, 23, 120, 139, 229, 70, 134, 66, 111, 143] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [184, 226, 42, 116, 169, 50, 110, 168, 135, 253, 97, 228, 76, 168, 38, 7, 222, 255, 137, 192, 132, 236, 8, 252, 203, 22, 190, 11, 172, 130, 204, 68] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [34, 95, 184, 177, 10, 85, 58, 167, 166, 191, 141, 222, 67, 108, 63, 7, 67, 222, 141, 167, 90, 48, 36, 106, 157, 44, 140, 106, 172, 215, 138, 89], legacy_session_id: SessionId { l: 32, id: [155, 235, 1, 10, 72, 147, 17, 246, 20, 113, 164, 27, 185, 137, 35, 7, 182, 109, 176, 94, 246, 36, 49, 23, 120, 139, 229, 70, 134, 66, 111, 143] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [184, 226, 42, 116, 169, 50, 110, 168, 135, 253, 97, 228, 76, 168, 38, 7, 222, 255, 137, 192, 132, 236, 8, 252, 203, 22, 190, 11, 172, 130, 204, 68] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: fastly.net
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [80, 146, 206, 125, 154, 254, 115, 166, 150, 131, 163, 240, 238, 47, 195, 243, 152, 161, 61, 19, 29, 86, 38, 15, 127, 43, 228, 196, 138, 243, 211, 34] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [102, 97, 115, 116, 108, 121, 46, 110, 101, 116] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [102, 97, 115, 116, 108, 121, 46, 110, 101, 116] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [102, 97, 115, 116, 108, 121, 46, 110, 101, 116] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [102, 97, 115, 116, 108, 121, 46, 110, 101, 116] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [102, 97, 115, 116, 108, 121, 46, 110, 101, 116] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [102, 97, 115, 116, 108, 121, 46, 110, 101, 116] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [102, 97, 115, 116, 108, 121, 46, 110, 101, 116] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [181, 8, 220, 65, 210, 183, 136, 227, 123, 34, 96, 135, 157, 177, 218, 134, 225, 41, 144, 230, 5, 203, 129, 202, 154, 169, 2, 251, 138, 190, 154, 72] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 8, 220, 65, 210, 183, 136, 227, 123, 34, 96, 135, 157, 177, 218, 134, 225, 41, 144, 230, 5, 203, 129, 202, 154, 169, 2, 251, 138, 190, 154, 72] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 8, 220, 65, 210, 183, 136, 227, 123, 34, 96, 135, 157, 177, 218, 134, 225, 41, 144, 230, 5, 203, 129, 202, 154, 169, 2, 251, 138, 190, 154, 72] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 8, 220, 65, 210, 183, 136, 227, 123, 34, 96, 135, 157, 177, 218, 134, 225, 41, 144, 230, 5, 203, 129, 202, 154, 169, 2, 251, 138, 190, 154, 72] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [102, 97, 115, 116, 108, 121, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 8, 220, 65, 210, 183, 136, 227, 123, 34, 96, 135, 157, 177, 218, 134, 225, 41, 144, 230, 5, 203, 129, 202, 154, 169, 2, 251, 138, 190, 154, 72] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [204, 79, 170, 87, 34, 197, 131, 149, 205, 93, 172, 7, 80, 121, 9, 76, 204, 186, 55, 181, 147, 241, 250, 95, 139, 21, 130, 100, 88, 127, 118, 105], legacy_session_id: SessionId { l: 32, id: [80, 146, 206, 125, 154, 254, 115, 166, 150, 131, 163, 240, 238, 47, 195, 243, 152, 161, 61, 19, 29, 86, 38, 15, 127, 43, 228, 196, 138, 243, 211, 34] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [102, 97, 115, 116, 108, 121, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 8, 220, 65, 210, 183, 136, 227, 123, 34, 96, 135, 157, 177, 218, 134, 225, 41, 144, 230, 5, 203, 129, 202, 154, 169, 2, 251, 138, 190, 154, 72] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [204, 79, 170, 87, 34, 197, 131, 149, 205, 93, 172, 7, 80, 121, 9, 76, 204, 186, 55, 181, 147, 241, 250, 95, 139, 21, 130, 100, 88, 127, 118, 105], legacy_session_id: SessionId { l: 32, id: [80, 146, 206, 125, 154, 254, 115, 166, 150, 131, 163, 240, 238, 47, 195, 243, 152, 161, 61, 19, 29, 86, 38, 15, 127, 43, 228, 196, 138, 243, 211, 34] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [102, 97, 115, 116, 108, 121, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 8, 220, 65, 210, 183, 136, 227, 123, 34, 96, 135, 157, 177, 218, 134, 225, 41, 144, 230, 5, 203, 129, 202, 154, 169, 2, 251, 138, 190, 154, 72] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [204, 79, 170, 87, 34, 197, 131, 149, 205, 93, 172, 7, 80, 121, 9, 76, 204, 186, 55, 181, 147, 241, 250, 95, 139, 21, 130, 100, 88, 127, 118, 105], legacy_session_id: SessionId { l: 32, id: [80, 146, 206, 125, 154, 254, 115, 166, 150, 131, 163, 240, 238, 47, 195, 243, 152, 161, 61, 19, 29, 86, 38, 15, 127, 43, 228, 196, 138, 243, 211, 34] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [102, 97, 115, 116, 108, 121, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 8, 220, 65, 210, 183, 136, 227, 123, 34, 96, 135, 157, 177, 218, 134, 225, 41, 144, 230, 5, 203, 129, 202, 154, 169, 2, 251, 138, 190, 154, 72] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(20fffd5a4fbcbdf84ac8fa9f7038c4a9bd6b097acf1b0269e99c2d75de89164c6a) }, encoded: 1000002120fffd5a4fbcbdf84ac8fa9f7038c4a9bd6b097acf1b0269e99c2d75de89164c6a }
+=====================================
+domain: netflix.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [117, 140, 74, 159, 38, 214, 87, 175, 149, 102, 42, 147, 247, 42, 252, 137, 200, 124, 126, 164, 86, 98, 15, 131, 117, 146, 143, 23, 242, 227, 208, 54] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [110, 101, 116, 102, 108, 105, 120, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [110, 101, 116, 102, 108, 105, 120, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [110, 101, 116, 102, 108, 105, 120, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [110, 101, 116, 102, 108, 105, 120, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [110, 101, 116, 102, 108, 105, 120, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [110, 101, 116, 102, 108, 105, 120, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [110, 101, 116, 102, 108, 105, 120, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [217, 187, 190, 39, 35, 22, 94, 117, 166, 170, 229, 220, 138, 142, 32, 20, 4, 202, 204, 79, 61, 5, 235, 72, 37, 31, 232, 14, 23, 122, 160, 7] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 187, 190, 39, 35, 22, 94, 117, 166, 170, 229, 220, 138, 142, 32, 20, 4, 202, 204, 79, 61, 5, 235, 72, 37, 31, 232, 14, 23, 122, 160, 7] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 187, 190, 39, 35, 22, 94, 117, 166, 170, 229, 220, 138, 142, 32, 20, 4, 202, 204, 79, 61, 5, 235, 72, 37, 31, 232, 14, 23, 122, 160, 7] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 187, 190, 39, 35, 22, 94, 117, 166, 170, 229, 220, 138, 142, 32, 20, 4, 202, 204, 79, 61, 5, 235, 72, 37, 31, 232, 14, 23, 122, 160, 7] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [110, 101, 116, 102, 108, 105, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 187, 190, 39, 35, 22, 94, 117, 166, 170, 229, 220, 138, 142, 32, 20, 4, 202, 204, 79, 61, 5, 235, 72, 37, 31, 232, 14, 23, 122, 160, 7] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [143, 27, 168, 73, 108, 10, 227, 29, 59, 137, 227, 243, 153, 179, 212, 72, 122, 146, 36, 125, 241, 16, 112, 184, 135, 20, 13, 50, 10, 99, 10, 92], legacy_session_id: SessionId { l: 32, id: [117, 140, 74, 159, 38, 214, 87, 175, 149, 102, 42, 147, 247, 42, 252, 137, 200, 124, 126, 164, 86, 98, 15, 131, 117, 146, 143, 23, 242, 227, 208, 54] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [110, 101, 116, 102, 108, 105, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 187, 190, 39, 35, 22, 94, 117, 166, 170, 229, 220, 138, 142, 32, 20, 4, 202, 204, 79, 61, 5, 235, 72, 37, 31, 232, 14, 23, 122, 160, 7] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [143, 27, 168, 73, 108, 10, 227, 29, 59, 137, 227, 243, 153, 179, 212, 72, 122, 146, 36, 125, 241, 16, 112, 184, 135, 20, 13, 50, 10, 99, 10, 92], legacy_session_id: SessionId { l: 32, id: [117, 140, 74, 159, 38, 214, 87, 175, 149, 102, 42, 147, 247, 42, 252, 137, 200, 124, 126, 164, 86, 98, 15, 131, 117, 146, 143, 23, 242, 227, 208, 54] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [110, 101, 116, 102, 108, 105, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 187, 190, 39, 35, 22, 94, 117, 166, 170, 229, 220, 138, 142, 32, 20, 4, 202, 204, 79, 61, 5, 235, 72, 37, 31, 232, 14, 23, 122, 160, 7] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [143, 27, 168, 73, 108, 10, 227, 29, 59, 137, 227, 243, 153, 179, 212, 72, 122, 146, 36, 125, 241, 16, 112, 184, 135, 20, 13, 50, 10, 99, 10, 92], legacy_session_id: SessionId { l: 32, id: [117, 140, 74, 159, 38, 214, 87, 175, 149, 102, 42, 147, 247, 42, 252, 137, 200, 124, 126, 164, 86, 98, 15, 131, 117, 146, 143, 23, 242, 227, 208, 54] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [110, 101, 116, 102, 108, 105, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 187, 190, 39, 35, 22, 94, 117, 166, 170, 229, 220, 138, 142, 32, 20, 4, 202, 204, 79, 61, 5, 235, 72, 37, 31, 232, 14, 23, 122, 160, 7] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: googlesyndication.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [198, 114, 28, 101, 74, 169, 82, 162, 5, 209, 120, 52, 99, 239, 188, 188, 130, 191, 182, 236, 51, 6, 65, 67, 28, 234, 203, 107, 183, 232, 93, 218] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((23, Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 115, 121, 110, 100, 105, 99, 97, 116, 105, 111, 110, 46, 99, 111, 109] }))
+[trace] HostName: Ok((23, Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 115, 121, 110, 100, 105, 99, 97, 116, 105, 111, 110, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((23, HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 115, 121, 110, 100, 105, 99, 97, 116, 105, 111, 110, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((24, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 115, 121, 110, 100, 105, 99, 97, 116, 105, 111, 110, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((26, ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 115, 121, 110, 100, 105, 99, 97, 116, 105, 111, 110, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((26, ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 115, 121, 110, 100, 105, 99, 97, 116, 105, 111, 110, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((30, ClientHelloExtension { extension_type: 0, ext_len: 26, extension_data: ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 115, 121, 110, 100, 105, 99, 97, 116, 105, 111, 110, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [182, 224, 113, 176, 51, 122, 203, 203, 210, 251, 128, 232, 93, 19, 60, 67, 244, 135, 46, 175, 28, 71, 44, 43, 119, 22, 179, 171, 19, 34, 87, 2] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 224, 113, 176, 51, 122, 203, 203, 210, 251, 128, 232, 93, 19, 60, 67, 244, 135, 46, 175, 28, 71, 44, 43, 119, 22, 179, 171, 19, 34, 87, 2] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 224, 113, 176, 51, 122, 203, 203, 210, 251, 128, 232, 93, 19, 60, 67, 244, 135, 46, 175, 28, 71, 44, 43, 119, 22, 179, 171, 19, 34, 87, 2] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 224, 113, 176, 51, 122, 203, 203, 210, 251, 128, 232, 93, 19, 60, 67, 244, 135, 46, 175, 28, 71, 44, 43, 119, 22, 179, 171, 19, 34, 87, 2] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((210, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((210, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((214, ClientHelloExtension { extension_type: 21, ext_len: 210, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 26, extension_data: ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 115, 121, 110, 100, 105, 99, 97, 116, 105, 111, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 224, 113, 176, 51, 122, 203, 203, 210, 251, 128, 232, 93, 19, 60, 67, 244, 135, 46, 175, 28, 71, 44, 43, 119, 22, 179, 171, 19, 34, 87, 2] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 210, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [246, 37, 148, 233, 243, 164, 91, 234, 136, 107, 232, 150, 204, 11, 126, 251, 159, 54, 236, 194, 180, 167, 147, 29, 190, 44, 166, 7, 140, 153, 164, 32], legacy_session_id: SessionId { l: 32, id: [198, 114, 28, 101, 74, 169, 82, 162, 5, 209, 120, 52, 99, 239, 188, 188, 130, 191, 182, 236, 51, 6, 65, 67, 28, 234, 203, 107, 183, 232, 93, 218] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 26, extension_data: ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 115, 121, 110, 100, 105, 99, 97, 116, 105, 111, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 224, 113, 176, 51, 122, 203, 203, 210, 251, 128, 232, 93, 19, 60, 67, 244, 135, 46, 175, 28, 71, 44, 43, 119, 22, 179, 171, 19, 34, 87, 2] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 210, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [246, 37, 148, 233, 243, 164, 91, 234, 136, 107, 232, 150, 204, 11, 126, 251, 159, 54, 236, 194, 180, 167, 147, 29, 190, 44, 166, 7, 140, 153, 164, 32], legacy_session_id: SessionId { l: 32, id: [198, 114, 28, 101, 74, 169, 82, 162, 5, 209, 120, 52, 99, 239, 188, 188, 130, 191, 182, 236, 51, 6, 65, 67, 28, 234, 203, 107, 183, 232, 93, 218] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 26, extension_data: ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 115, 121, 110, 100, 105, 99, 97, 116, 105, 111, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 224, 113, 176, 51, 122, 203, 203, 210, 251, 128, 232, 93, 19, 60, 67, 244, 135, 46, 175, 28, 71, 44, 43, 119, 22, 179, 171, 19, 34, 87, 2] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 210, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [246, 37, 148, 233, 243, 164, 91, 234, 136, 107, 232, 150, 204, 11, 126, 251, 159, 54, 236, 194, 180, 167, 147, 29, 190, 44, 166, 7, 140, 153, 164, 32], legacy_session_id: SessionId { l: 32, id: [198, 114, 28, 101, 74, 169, 82, 162, 5, 209, 120, 52, 99, 239, 188, 188, 130, 191, 182, 236, 51, 6, 65, 67, 28, 234, 203, 107, 183, 232, 93, 218] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 26, extension_data: ServerName(ServerNameList { l: 24, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 21, data: [103, 111, 111, 103, 108, 101, 115, 121, 110, 100, 105, 99, 97, 116, 105, 111, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 224, 113, 176, 51, 122, 203, 203, 210, 251, 128, 232, 93, 19, 60, 67, 244, 135, 46, 175, 28, 71, 44, 43, 119, 22, 179, 171, 19, 34, 87, 2] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 210, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: whatsapp.net
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [218, 77, 106, 209, 244, 74, 1, 26, 182, 239, 180, 65, 155, 109, 20, 174, 99, 248, 89, 196, 102, 171, 78, 189, 138, 157, 183, 90, 85, 28, 25, 44] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((14, Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 110, 101, 116] }))
+[trace] HostName: Ok((14, Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 110, 101, 116] }))
+[trace] ServerNameName: Ok((14, HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 110, 101, 116] })))
+[trace] ServerName: Ok((15, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 110, 101, 116] }) }))
+[trace] ServerNameList: Ok((17, ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 110, 101, 116] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((17, ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 110, 101, 116] }) }]) })))
+[trace] ClientHelloExtension: Ok((21, ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 110, 101, 116] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [182, 52, 97, 160, 130, 119, 104, 56, 162, 184, 62, 57, 9, 76, 206, 221, 153, 0, 210, 92, 91, 115, 144, 205, 6, 96, 29, 7, 41, 79, 18, 36] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 52, 97, 160, 130, 119, 104, 56, 162, 184, 62, 57, 9, 76, 206, 221, 153, 0, 210, 92, 91, 115, 144, 205, 6, 96, 29, 7, 41, 79, 18, 36] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 52, 97, 160, 130, 119, 104, 56, 162, 184, 62, 57, 9, 76, 206, 221, 153, 0, 210, 92, 91, 115, 144, 205, 6, 96, 29, 7, 41, 79, 18, 36] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 52, 97, 160, 130, 119, 104, 56, 162, 184, 62, 57, 9, 76, 206, 221, 153, 0, 210, 92, 91, 115, 144, 205, 6, 96, 29, 7, 41, 79, 18, 36] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((219, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((219, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((223, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 52, 97, 160, 130, 119, 104, 56, 162, 184, 62, 57, 9, 76, 206, 221, 153, 0, 210, 92, 91, 115, 144, 205, 6, 96, 29, 7, 41, 79, 18, 36] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [58, 106, 192, 171, 2, 100, 46, 82, 206, 146, 53, 34, 29, 141, 55, 62, 134, 145, 206, 9, 255, 3, 28, 233, 205, 99, 177, 19, 134, 216, 54, 79], legacy_session_id: SessionId { l: 32, id: [218, 77, 106, 209, 244, 74, 1, 26, 182, 239, 180, 65, 155, 109, 20, 174, 99, 248, 89, 196, 102, 171, 78, 189, 138, 157, 183, 90, 85, 28, 25, 44] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 52, 97, 160, 130, 119, 104, 56, 162, 184, 62, 57, 9, 76, 206, 221, 153, 0, 210, 92, 91, 115, 144, 205, 6, 96, 29, 7, 41, 79, 18, 36] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [58, 106, 192, 171, 2, 100, 46, 82, 206, 146, 53, 34, 29, 141, 55, 62, 134, 145, 206, 9, 255, 3, 28, 233, 205, 99, 177, 19, 134, 216, 54, 79], legacy_session_id: SessionId { l: 32, id: [218, 77, 106, 209, 244, 74, 1, 26, 182, 239, 180, 65, 155, 109, 20, 174, 99, 248, 89, 196, 102, 171, 78, 189, 138, 157, 183, 90, 85, 28, 25, 44] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 52, 97, 160, 130, 119, 104, 56, 162, 184, 62, 57, 9, 76, 206, 221, 153, 0, 210, 92, 91, 115, 144, 205, 6, 96, 29, 7, 41, 79, 18, 36] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [58, 106, 192, 171, 2, 100, 46, 82, 206, 146, 53, 34, 29, 141, 55, 62, 134, 145, 206, 9, 255, 3, 28, 233, 205, 99, 177, 19, 134, 216, 54, 79], legacy_session_id: SessionId { l: 32, id: [218, 77, 106, 209, 244, 74, 1, 26, 182, 239, 180, 65, 155, 109, 20, 174, 99, 248, 89, 196, 102, 171, 78, 189, 138, 157, 183, 90, 85, 28, 25, 44] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [182, 52, 97, 160, 130, 119, 104, 56, 162, 184, 62, 57, 9, 76, 206, 221, 153, 0, 210, 92, 91, 115, 144, 205, 6, 96, 29, 7, 41, 79, 18, 36] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: 3ona.co
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [22, 6, 45, 49, 181, 231, 33, 231, 146, 107, 230, 163, 108, 6, 212, 1, 15, 109, 231, 67, 198, 149, 155, 241, 40, 89, 51, 121, 30, 136, 9, 221] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((9, Opaque1Ffff { l: 7, data: [51, 111, 110, 97, 46, 99, 111] }))
+[trace] HostName: Ok((9, Opaque1Ffff { l: 7, data: [51, 111, 110, 97, 46, 99, 111] }))
+[trace] ServerNameName: Ok((9, HostName(Opaque1Ffff { l: 7, data: [51, 111, 110, 97, 46, 99, 111] })))
+[trace] ServerName: Ok((10, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [51, 111, 110, 97, 46, 99, 111] }) }))
+[trace] ServerNameList: Ok((12, ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [51, 111, 110, 97, 46, 99, 111] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((12, ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [51, 111, 110, 97, 46, 99, 111] }) }]) })))
+[trace] ClientHelloExtension: Ok((16, ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [51, 111, 110, 97, 46, 99, 111] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [46, 157, 189, 32, 242, 218, 77, 173, 32, 213, 6, 140, 255, 5, 92, 112, 241, 207, 249, 183, 97, 146, 234, 8, 118, 135, 201, 173, 19, 236, 230, 30] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [46, 157, 189, 32, 242, 218, 77, 173, 32, 213, 6, 140, 255, 5, 92, 112, 241, 207, 249, 183, 97, 146, 234, 8, 118, 135, 201, 173, 19, 236, 230, 30] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [46, 157, 189, 32, 242, 218, 77, 173, 32, 213, 6, 140, 255, 5, 92, 112, 241, 207, 249, 183, 97, 146, 234, 8, 118, 135, 201, 173, 19, 236, 230, 30] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [46, 157, 189, 32, 242, 218, 77, 173, 32, 213, 6, 140, 255, 5, 92, 112, 241, 207, 249, 183, 97, 146, 234, 8, 118, 135, 201, 173, 19, 236, 230, 30] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((224, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((224, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((228, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [51, 111, 110, 97, 46, 99, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [46, 157, 189, 32, 242, 218, 77, 173, 32, 213, 6, 140, 255, 5, 92, 112, 241, 207, 249, 183, 97, 146, 234, 8, 118, 135, 201, 173, 19, 236, 230, 30] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [139, 190, 18, 117, 142, 33, 39, 255, 175, 41, 25, 57, 252, 111, 170, 121, 50, 130, 132, 239, 4, 149, 172, 239, 89, 176, 238, 168, 252, 23, 99, 14], legacy_session_id: SessionId { l: 32, id: [22, 6, 45, 49, 181, 231, 33, 231, 146, 107, 230, 163, 108, 6, 212, 1, 15, 109, 231, 67, 198, 149, 155, 241, 40, 89, 51, 121, 30, 136, 9, 221] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [51, 111, 110, 97, 46, 99, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [46, 157, 189, 32, 242, 218, 77, 173, 32, 213, 6, 140, 255, 5, 92, 112, 241, 207, 249, 183, 97, 146, 234, 8, 118, 135, 201, 173, 19, 236, 230, 30] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [139, 190, 18, 117, 142, 33, 39, 255, 175, 41, 25, 57, 252, 111, 170, 121, 50, 130, 132, 239, 4, 149, 172, 239, 89, 176, 238, 168, 252, 23, 99, 14], legacy_session_id: SessionId { l: 32, id: [22, 6, 45, 49, 181, 231, 33, 231, 146, 107, 230, 163, 108, 6, 212, 1, 15, 109, 231, 67, 198, 149, 155, 241, 40, 89, 51, 121, 30, 136, 9, 221] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [51, 111, 110, 97, 46, 99, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [46, 157, 189, 32, 242, 218, 77, 173, 32, 213, 6, 140, 255, 5, 92, 112, 241, 207, 249, 183, 97, 146, 234, 8, 118, 135, 201, 173, 19, 236, 230, 30] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [139, 190, 18, 117, 142, 33, 39, 255, 175, 41, 25, 57, 252, 111, 170, 121, 50, 130, 132, 239, 4, 149, 172, 239, 89, 176, 238, 168, 252, 23, 99, 14], legacy_session_id: SessionId { l: 32, id: [22, 6, 45, 49, 181, 231, 33, 231, 146, 107, 230, 163, 108, 6, 212, 1, 15, 109, 231, 67, 198, 149, 155, 241, 40, 89, 51, 121, 30, 136, 9, 221] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [51, 111, 110, 97, 46, 99, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [46, 157, 189, 32, 242, 218, 77, 173, 32, 213, 6, 140, 255, 5, 92, 112, 241, 207, 249, 183, 97, 146, 234, 8, 118, 135, 201, 173, 19, 236, 230, 30] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: youtu.be
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [254, 49, 197, 4, 255, 52, 11, 184, 171, 117, 68, 170, 76, 106, 255, 98, 169, 157, 65, 173, 159, 49, 136, 168, 116, 119, 104, 26, 225, 227, 93, 186] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((10, Opaque1Ffff { l: 8, data: [121, 111, 117, 116, 117, 46, 98, 101] }))
+[trace] HostName: Ok((10, Opaque1Ffff { l: 8, data: [121, 111, 117, 116, 117, 46, 98, 101] }))
+[trace] ServerNameName: Ok((10, HostName(Opaque1Ffff { l: 8, data: [121, 111, 117, 116, 117, 46, 98, 101] })))
+[trace] ServerName: Ok((11, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [121, 111, 117, 116, 117, 46, 98, 101] }) }))
+[trace] ServerNameList: Ok((13, ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [121, 111, 117, 116, 117, 46, 98, 101] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((13, ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [121, 111, 117, 116, 117, 46, 98, 101] }) }]) })))
+[trace] ClientHelloExtension: Ok((17, ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [121, 111, 117, 116, 117, 46, 98, 101] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [54, 88, 103, 185, 158, 39, 18, 249, 203, 233, 14, 63, 145, 181, 123, 198, 22, 12, 186, 232, 115, 14, 69, 59, 65, 129, 209, 84, 44, 219, 184, 98] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [54, 88, 103, 185, 158, 39, 18, 249, 203, 233, 14, 63, 145, 181, 123, 198, 22, 12, 186, 232, 115, 14, 69, 59, 65, 129, 209, 84, 44, 219, 184, 98] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [54, 88, 103, 185, 158, 39, 18, 249, 203, 233, 14, 63, 145, 181, 123, 198, 22, 12, 186, 232, 115, 14, 69, 59, 65, 129, 209, 84, 44, 219, 184, 98] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [54, 88, 103, 185, 158, 39, 18, 249, 203, 233, 14, 63, 145, 181, 123, 198, 22, 12, 186, 232, 115, 14, 69, 59, 65, 129, 209, 84, 44, 219, 184, 98] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((223, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((223, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((227, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [121, 111, 117, 116, 117, 46, 98, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [54, 88, 103, 185, 158, 39, 18, 249, 203, 233, 14, 63, 145, 181, 123, 198, 22, 12, 186, 232, 115, 14, 69, 59, 65, 129, 209, 84, 44, 219, 184, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [143, 138, 229, 103, 181, 222, 133, 221, 94, 197, 189, 129, 201, 188, 133, 88, 42, 126, 110, 54, 69, 37, 175, 168, 90, 149, 125, 199, 37, 77, 231, 35], legacy_session_id: SessionId { l: 32, id: [254, 49, 197, 4, 255, 52, 11, 184, 171, 117, 68, 170, 76, 106, 255, 98, 169, 157, 65, 173, 159, 49, 136, 168, 116, 119, 104, 26, 225, 227, 93, 186] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [121, 111, 117, 116, 117, 46, 98, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [54, 88, 103, 185, 158, 39, 18, 249, 203, 233, 14, 63, 145, 181, 123, 198, 22, 12, 186, 232, 115, 14, 69, 59, 65, 129, 209, 84, 44, 219, 184, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [143, 138, 229, 103, 181, 222, 133, 221, 94, 197, 189, 129, 201, 188, 133, 88, 42, 126, 110, 54, 69, 37, 175, 168, 90, 149, 125, 199, 37, 77, 231, 35], legacy_session_id: SessionId { l: 32, id: [254, 49, 197, 4, 255, 52, 11, 184, 171, 117, 68, 170, 76, 106, 255, 98, 169, 157, 65, 173, 159, 49, 136, 168, 116, 119, 104, 26, 225, 227, 93, 186] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [121, 111, 117, 116, 117, 46, 98, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [54, 88, 103, 185, 158, 39, 18, 249, 203, 233, 14, 63, 145, 181, 123, 198, 22, 12, 186, 232, 115, 14, 69, 59, 65, 129, 209, 84, 44, 219, 184, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [143, 138, 229, 103, 181, 222, 133, 221, 94, 197, 189, 129, 201, 188, 133, 88, 42, 126, 110, 54, 69, 37, 175, 168, 90, 149, 125, 199, 37, 77, 231, 35], legacy_session_id: SessionId { l: 32, id: [254, 49, 197, 4, 255, 52, 11, 184, 171, 117, 68, 170, 76, 106, 255, 98, 169, 157, 65, 173, 159, 49, 136, 168, 116, 119, 104, 26, 225, 227, 93, 186] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [121, 111, 117, 116, 117, 46, 98, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [54, 88, 103, 185, 158, 39, 18, 249, 203, 233, 14, 63, 145, 181, 123, 198, 22, 12, 186, 232, 115, 14, 69, 59, 65, 129, 209, 84, 44, 219, 184, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: digicert.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [148, 88, 9, 253, 164, 214, 224, 37, 211, 125, 50, 115, 245, 134, 198, 78, 153, 74, 192, 24, 5, 250, 246, 36, 97, 40, 69, 16, 224, 181, 40, 98] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((14, Opaque1Ffff { l: 12, data: [100, 105, 103, 105, 99, 101, 114, 116, 46, 99, 111, 109] }))
+[trace] HostName: Ok((14, Opaque1Ffff { l: 12, data: [100, 105, 103, 105, 99, 101, 114, 116, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((14, HostName(Opaque1Ffff { l: 12, data: [100, 105, 103, 105, 99, 101, 114, 116, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((15, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [100, 105, 103, 105, 99, 101, 114, 116, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((17, ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [100, 105, 103, 105, 99, 101, 114, 116, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((17, ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [100, 105, 103, 105, 99, 101, 114, 116, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((21, ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [100, 105, 103, 105, 99, 101, 114, 116, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [220, 240, 8, 158, 11, 111, 115, 110, 173, 110, 226, 10, 223, 10, 27, 238, 156, 82, 74, 129, 240, 209, 253, 59, 160, 162, 170, 249, 92, 52, 22, 94] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [220, 240, 8, 158, 11, 111, 115, 110, 173, 110, 226, 10, 223, 10, 27, 238, 156, 82, 74, 129, 240, 209, 253, 59, 160, 162, 170, 249, 92, 52, 22, 94] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [220, 240, 8, 158, 11, 111, 115, 110, 173, 110, 226, 10, 223, 10, 27, 238, 156, 82, 74, 129, 240, 209, 253, 59, 160, 162, 170, 249, 92, 52, 22, 94] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [220, 240, 8, 158, 11, 111, 115, 110, 173, 110, 226, 10, 223, 10, 27, 238, 156, 82, 74, 129, 240, 209, 253, 59, 160, 162, 170, 249, 92, 52, 22, 94] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((219, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((219, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((223, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [100, 105, 103, 105, 99, 101, 114, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [220, 240, 8, 158, 11, 111, 115, 110, 173, 110, 226, 10, 223, 10, 27, 238, 156, 82, 74, 129, 240, 209, 253, 59, 160, 162, 170, 249, 92, 52, 22, 94] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [0, 183, 205, 50, 206, 97, 17, 3, 176, 158, 234, 161, 246, 223, 254, 69, 177, 45, 43, 252, 56, 120, 111, 2, 139, 13, 69, 104, 229, 85, 185, 47], legacy_session_id: SessionId { l: 32, id: [148, 88, 9, 253, 164, 214, 224, 37, 211, 125, 50, 115, 245, 134, 198, 78, 153, 74, 192, 24, 5, 250, 246, 36, 97, 40, 69, 16, 224, 181, 40, 98] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [100, 105, 103, 105, 99, 101, 114, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [220, 240, 8, 158, 11, 111, 115, 110, 173, 110, 226, 10, 223, 10, 27, 238, 156, 82, 74, 129, 240, 209, 253, 59, 160, 162, 170, 249, 92, 52, 22, 94] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [0, 183, 205, 50, 206, 97, 17, 3, 176, 158, 234, 161, 246, 223, 254, 69, 177, 45, 43, 252, 56, 120, 111, 2, 139, 13, 69, 104, 229, 85, 185, 47], legacy_session_id: SessionId { l: 32, id: [148, 88, 9, 253, 164, 214, 224, 37, 211, 125, 50, 115, 245, 134, 198, 78, 153, 74, 192, 24, 5, 250, 246, 36, 97, 40, 69, 16, 224, 181, 40, 98] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [100, 105, 103, 105, 99, 101, 114, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [220, 240, 8, 158, 11, 111, 115, 110, 173, 110, 226, 10, 223, 10, 27, 238, 156, 82, 74, 129, 240, 209, 253, 59, 160, 162, 170, 249, 92, 52, 22, 94] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [0, 183, 205, 50, 206, 97, 17, 3, 176, 158, 234, 161, 246, 223, 254, 69, 177, 45, 43, 252, 56, 120, 111, 2, 139, 13, 69, 104, 229, 85, 185, 47], legacy_session_id: SessionId { l: 32, id: [148, 88, 9, 253, 164, 214, 224, 37, 211, 125, 50, 115, 245, 134, 198, 78, 153, 74, 192, 24, 5, 250, 246, 36, 97, 40, 69, 16, 224, 181, 40, 98] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [100, 105, 103, 105, 99, 101, 114, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [220, 240, 8, 158, 11, 111, 115, 110, 173, 110, 226, 10, 223, 10, 27, 238, 156, 82, 74, 129, 240, 209, 253, 59, 160, 162, 170, 249, 92, 52, 22, 94] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: pinterest.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [146, 66, 101, 140, 106, 144, 46, 185, 247, 30, 169, 252, 73, 149, 25, 60, 49, 32, 142, 190, 249, 240, 253, 254, 198, 115, 24, 136, 146, 190, 166, 47] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((15, Opaque1Ffff { l: 13, data: [112, 105, 110, 116, 101, 114, 101, 115, 116, 46, 99, 111, 109] }))
+[trace] HostName: Ok((15, Opaque1Ffff { l: 13, data: [112, 105, 110, 116, 101, 114, 101, 115, 116, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((15, HostName(Opaque1Ffff { l: 13, data: [112, 105, 110, 116, 101, 114, 101, 115, 116, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((16, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [112, 105, 110, 116, 101, 114, 101, 115, 116, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((18, ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [112, 105, 110, 116, 101, 114, 101, 115, 116, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((18, ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [112, 105, 110, 116, 101, 114, 101, 115, 116, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((22, ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [112, 105, 110, 116, 101, 114, 101, 115, 116, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [237, 44, 251, 126, 34, 111, 53, 50, 226, 112, 193, 65, 112, 190, 113, 88, 75, 180, 1, 209, 228, 248, 218, 185, 203, 0, 254, 19, 133, 15, 231, 109] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 44, 251, 126, 34, 111, 53, 50, 226, 112, 193, 65, 112, 190, 113, 88, 75, 180, 1, 209, 228, 248, 218, 185, 203, 0, 254, 19, 133, 15, 231, 109] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 44, 251, 126, 34, 111, 53, 50, 226, 112, 193, 65, 112, 190, 113, 88, 75, 180, 1, 209, 228, 248, 218, 185, 203, 0, 254, 19, 133, 15, 231, 109] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 44, 251, 126, 34, 111, 53, 50, 226, 112, 193, 65, 112, 190, 113, 88, 75, 180, 1, 209, 228, 248, 218, 185, 203, 0, 254, 19, 133, 15, 231, 109] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((218, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((218, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((222, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [112, 105, 110, 116, 101, 114, 101, 115, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 44, 251, 126, 34, 111, 53, 50, 226, 112, 193, 65, 112, 190, 113, 88, 75, 180, 1, 209, 228, 248, 218, 185, 203, 0, 254, 19, 133, 15, 231, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [201, 237, 237, 109, 53, 152, 16, 43, 64, 165, 181, 116, 136, 63, 195, 97, 219, 153, 58, 102, 38, 128, 87, 12, 43, 92, 172, 137, 210, 122, 55, 28], legacy_session_id: SessionId { l: 32, id: [146, 66, 101, 140, 106, 144, 46, 185, 247, 30, 169, 252, 73, 149, 25, 60, 49, 32, 142, 190, 249, 240, 253, 254, 198, 115, 24, 136, 146, 190, 166, 47] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [112, 105, 110, 116, 101, 114, 101, 115, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 44, 251, 126, 34, 111, 53, 50, 226, 112, 193, 65, 112, 190, 113, 88, 75, 180, 1, 209, 228, 248, 218, 185, 203, 0, 254, 19, 133, 15, 231, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [201, 237, 237, 109, 53, 152, 16, 43, 64, 165, 181, 116, 136, 63, 195, 97, 219, 153, 58, 102, 38, 128, 87, 12, 43, 92, 172, 137, 210, 122, 55, 28], legacy_session_id: SessionId { l: 32, id: [146, 66, 101, 140, 106, 144, 46, 185, 247, 30, 169, 252, 73, 149, 25, 60, 49, 32, 142, 190, 249, 240, 253, 254, 198, 115, 24, 136, 146, 190, 166, 47] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [112, 105, 110, 116, 101, 114, 101, 115, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 44, 251, 126, 34, 111, 53, 50, 226, 112, 193, 65, 112, 190, 113, 88, 75, 180, 1, 209, 228, 248, 218, 185, 203, 0, 254, 19, 133, 15, 231, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [201, 237, 237, 109, 53, 152, 16, 43, 64, 165, 181, 116, 136, 63, 195, 97, 219, 153, 58, 102, 38, 128, 87, 12, 43, 92, 172, 137, 210, 122, 55, 28], legacy_session_id: SessionId { l: 32, id: [146, 66, 101, 140, 106, 144, 46, 185, 247, 30, 169, 252, 73, 149, 25, 60, 49, 32, 142, 190, 249, 240, 253, 254, 198, 115, 24, 136, 146, 190, 166, 47] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [112, 105, 110, 116, 101, 114, 101, 115, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 44, 251, 126, 34, 111, 53, 50, 226, 112, 193, 65, 112, 190, 113, 88, 75, 180, 1, 209, 228, 248, 218, 185, 203, 0, 254, 19, 133, 15, 231, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: icloud.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [149, 156, 72, 217, 122, 143, 209, 17, 46, 140, 217, 51, 195, 161, 160, 122, 89, 53, 168, 238, 44, 218, 242, 246, 218, 199, 112, 127, 181, 34, 101, 101] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [105, 99, 108, 111, 117, 100, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [105, 99, 108, 111, 117, 100, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [105, 99, 108, 111, 117, 100, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 99, 108, 111, 117, 100, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 99, 108, 111, 117, 100, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 99, 108, 111, 117, 100, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 99, 108, 111, 117, 100, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [128, 221, 67, 208, 35, 128, 171, 208, 123, 203, 228, 215, 30, 234, 1, 157, 52, 24, 78, 129, 149, 136, 100, 246, 204, 102, 97, 116, 237, 210, 190, 74] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [128, 221, 67, 208, 35, 128, 171, 208, 123, 203, 228, 215, 30, 234, 1, 157, 52, 24, 78, 129, 149, 136, 100, 246, 204, 102, 97, 116, 237, 210, 190, 74] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [128, 221, 67, 208, 35, 128, 171, 208, 123, 203, 228, 215, 30, 234, 1, 157, 52, 24, 78, 129, 149, 136, 100, 246, 204, 102, 97, 116, 237, 210, 190, 74] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [128, 221, 67, 208, 35, 128, 171, 208, 123, 203, 228, 215, 30, 234, 1, 157, 52, 24, 78, 129, 149, 136, 100, 246, 204, 102, 97, 116, 237, 210, 190, 74] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 99, 108, 111, 117, 100, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [128, 221, 67, 208, 35, 128, 171, 208, 123, 203, 228, 215, 30, 234, 1, 157, 52, 24, 78, 129, 149, 136, 100, 246, 204, 102, 97, 116, 237, 210, 190, 74] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [12, 113, 170, 242, 117, 30, 177, 226, 232, 85, 242, 132, 253, 43, 144, 65, 171, 75, 205, 113, 123, 5, 152, 170, 50, 138, 113, 29, 182, 28, 5, 15], legacy_session_id: SessionId { l: 32, id: [149, 156, 72, 217, 122, 143, 209, 17, 46, 140, 217, 51, 195, 161, 160, 122, 89, 53, 168, 238, 44, 218, 242, 246, 218, 199, 112, 127, 181, 34, 101, 101] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 99, 108, 111, 117, 100, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [128, 221, 67, 208, 35, 128, 171, 208, 123, 203, 228, 215, 30, 234, 1, 157, 52, 24, 78, 129, 149, 136, 100, 246, 204, 102, 97, 116, 237, 210, 190, 74] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [12, 113, 170, 242, 117, 30, 177, 226, 232, 85, 242, 132, 253, 43, 144, 65, 171, 75, 205, 113, 123, 5, 152, 170, 50, 138, 113, 29, 182, 28, 5, 15], legacy_session_id: SessionId { l: 32, id: [149, 156, 72, 217, 122, 143, 209, 17, 46, 140, 217, 51, 195, 161, 160, 122, 89, 53, 168, 238, 44, 218, 242, 246, 218, 199, 112, 127, 181, 34, 101, 101] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 99, 108, 111, 117, 100, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [128, 221, 67, 208, 35, 128, 171, 208, 123, 203, 228, 215, 30, 234, 1, 157, 52, 24, 78, 129, 149, 136, 100, 246, 204, 102, 97, 116, 237, 210, 190, 74] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [12, 113, 170, 242, 117, 30, 177, 226, 232, 85, 242, 132, 253, 43, 144, 65, 171, 75, 205, 113, 123, 5, 152, 170, 50, 138, 113, 29, 182, 28, 5, 15], legacy_session_id: SessionId { l: 32, id: [149, 156, 72, 217, 122, 143, 209, 17, 46, 140, 217, 51, 195, 161, 160, 122, 89, 53, 168, 238, 44, 218, 242, 246, 218, 199, 112, 127, 181, 34, 101, 101] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 99, 108, 111, 117, 100, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [128, 221, 67, 208, 35, 128, 171, 208, 123, 203, 228, 215, 30, 234, 1, 157, 52, 24, 78, 129, 149, 136, 100, 246, 204, 102, 97, 116, 237, 210, 190, 74] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: yahoo.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [83, 67, 46, 132, 7, 246, 81, 16, 46, 111, 45, 64, 216, 206, 150, 137, 130, 223, 199, 204, 217, 94, 5, 114, 64, 165, 211, 135, 98, 201, 57, 13] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [121, 97, 104, 111, 111, 46, 99, 111, 109] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [121, 97, 104, 111, 111, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [121, 97, 104, 111, 111, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [121, 97, 104, 111, 111, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [121, 97, 104, 111, 111, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [121, 97, 104, 111, 111, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [121, 97, 104, 111, 111, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [105, 144, 143, 106, 248, 195, 123, 12, 120, 126, 210, 222, 168, 1, 191, 48, 217, 238, 219, 48, 18, 49, 23, 138, 225, 137, 170, 2, 227, 153, 125, 8] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [105, 144, 143, 106, 248, 195, 123, 12, 120, 126, 210, 222, 168, 1, 191, 48, 217, 238, 219, 48, 18, 49, 23, 138, 225, 137, 170, 2, 227, 153, 125, 8] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [105, 144, 143, 106, 248, 195, 123, 12, 120, 126, 210, 222, 168, 1, 191, 48, 217, 238, 219, 48, 18, 49, 23, 138, 225, 137, 170, 2, 227, 153, 125, 8] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [105, 144, 143, 106, 248, 195, 123, 12, 120, 126, 210, 222, 168, 1, 191, 48, 217, 238, 219, 48, 18, 49, 23, 138, 225, 137, 170, 2, 227, 153, 125, 8] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [121, 97, 104, 111, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [105, 144, 143, 106, 248, 195, 123, 12, 120, 126, 210, 222, 168, 1, 191, 48, 217, 238, 219, 48, 18, 49, 23, 138, 225, 137, 170, 2, 227, 153, 125, 8] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [251, 18, 148, 11, 7, 220, 224, 59, 5, 214, 101, 143, 178, 190, 30, 66, 188, 114, 195, 51, 62, 88, 46, 185, 86, 182, 209, 64, 204, 81, 18, 134], legacy_session_id: SessionId { l: 32, id: [83, 67, 46, 132, 7, 246, 81, 16, 46, 111, 45, 64, 216, 206, 150, 137, 130, 223, 199, 204, 217, 94, 5, 114, 64, 165, 211, 135, 98, 201, 57, 13] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [121, 97, 104, 111, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [105, 144, 143, 106, 248, 195, 123, 12, 120, 126, 210, 222, 168, 1, 191, 48, 217, 238, 219, 48, 18, 49, 23, 138, 225, 137, 170, 2, 227, 153, 125, 8] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [251, 18, 148, 11, 7, 220, 224, 59, 5, 214, 101, 143, 178, 190, 30, 66, 188, 114, 195, 51, 62, 88, 46, 185, 86, 182, 209, 64, 204, 81, 18, 134], legacy_session_id: SessionId { l: 32, id: [83, 67, 46, 132, 7, 246, 81, 16, 46, 111, 45, 64, 216, 206, 150, 137, 130, 223, 199, 204, 217, 94, 5, 114, 64, 165, 211, 135, 98, 201, 57, 13] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [121, 97, 104, 111, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [105, 144, 143, 106, 248, 195, 123, 12, 120, 126, 210, 222, 168, 1, 191, 48, 217, 238, 219, 48, 18, 49, 23, 138, 225, 137, 170, 2, 227, 153, 125, 8] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [251, 18, 148, 11, 7, 220, 224, 59, 5, 214, 101, 143, 178, 190, 30, 66, 188, 114, 195, 51, 62, 88, 46, 185, 86, 182, 209, 64, 204, 81, 18, 134], legacy_session_id: SessionId { l: 32, id: [83, 67, 46, 132, 7, 246, 81, 16, 46, 111, 45, 64, 216, 206, 150, 137, 130, 223, 199, 204, 217, 94, 5, 114, 64, 165, 211, 135, 98, 201, 57, 13] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [121, 97, 104, 111, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [105, 144, 143, 106, 248, 195, 123, 12, 120, 126, 210, 222, 168, 1, 191, 48, 217, 238, 219, 48, 18, 49, 23, 138, 225, 137, 170, 2, 227, 153, 125, 8] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: appsflyersdk.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [244, 101, 70, 141, 241, 246, 127, 72, 93, 63, 121, 6, 185, 98, 189, 163, 170, 42, 86, 89, 206, 234, 157, 139, 252, 162, 72, 194, 203, 122, 147, 87] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((18, Opaque1Ffff { l: 16, data: [97, 112, 112, 115, 102, 108, 121, 101, 114, 115, 100, 107, 46, 99, 111, 109] }))
+[trace] HostName: Ok((18, Opaque1Ffff { l: 16, data: [97, 112, 112, 115, 102, 108, 121, 101, 114, 115, 100, 107, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((18, HostName(Opaque1Ffff { l: 16, data: [97, 112, 112, 115, 102, 108, 121, 101, 114, 115, 100, 107, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((19, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 16, data: [97, 112, 112, 115, 102, 108, 121, 101, 114, 115, 100, 107, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((21, ServerNameList { l: 19, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 16, data: [97, 112, 112, 115, 102, 108, 121, 101, 114, 115, 100, 107, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((21, ServerName(ServerNameList { l: 19, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 16, data: [97, 112, 112, 115, 102, 108, 121, 101, 114, 115, 100, 107, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((25, ClientHelloExtension { extension_type: 0, ext_len: 21, extension_data: ServerName(ServerNameList { l: 19, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 16, data: [97, 112, 112, 115, 102, 108, 121, 101, 114, 115, 100, 107, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [85, 74, 102, 160, 210, 210, 195, 125, 132, 147, 240, 175, 42, 52, 65, 79, 150, 17, 153, 72, 135, 135, 58, 101, 21, 87, 230, 88, 58, 221, 105, 27] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 74, 102, 160, 210, 210, 195, 125, 132, 147, 240, 175, 42, 52, 65, 79, 150, 17, 153, 72, 135, 135, 58, 101, 21, 87, 230, 88, 58, 221, 105, 27] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 74, 102, 160, 210, 210, 195, 125, 132, 147, 240, 175, 42, 52, 65, 79, 150, 17, 153, 72, 135, 135, 58, 101, 21, 87, 230, 88, 58, 221, 105, 27] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 74, 102, 160, 210, 210, 195, 125, 132, 147, 240, 175, 42, 52, 65, 79, 150, 17, 153, 72, 135, 135, 58, 101, 21, 87, 230, 88, 58, 221, 105, 27] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((215, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((215, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((219, ClientHelloExtension { extension_type: 21, ext_len: 215, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 21, extension_data: ServerName(ServerNameList { l: 19, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 16, data: [97, 112, 112, 115, 102, 108, 121, 101, 114, 115, 100, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 74, 102, 160, 210, 210, 195, 125, 132, 147, 240, 175, 42, 52, 65, 79, 150, 17, 153, 72, 135, 135, 58, 101, 21, 87, 230, 88, 58, 221, 105, 27] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 215, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [28, 240, 179, 90, 58, 54, 194, 14, 5, 28, 61, 18, 11, 121, 100, 164, 108, 227, 7, 114, 192, 247, 136, 160, 203, 104, 26, 179, 77, 221, 236, 65], legacy_session_id: SessionId { l: 32, id: [244, 101, 70, 141, 241, 246, 127, 72, 93, 63, 121, 6, 185, 98, 189, 163, 170, 42, 86, 89, 206, 234, 157, 139, 252, 162, 72, 194, 203, 122, 147, 87] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 21, extension_data: ServerName(ServerNameList { l: 19, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 16, data: [97, 112, 112, 115, 102, 108, 121, 101, 114, 115, 100, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 74, 102, 160, 210, 210, 195, 125, 132, 147, 240, 175, 42, 52, 65, 79, 150, 17, 153, 72, 135, 135, 58, 101, 21, 87, 230, 88, 58, 221, 105, 27] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 215, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [28, 240, 179, 90, 58, 54, 194, 14, 5, 28, 61, 18, 11, 121, 100, 164, 108, 227, 7, 114, 192, 247, 136, 160, 203, 104, 26, 179, 77, 221, 236, 65], legacy_session_id: SessionId { l: 32, id: [244, 101, 70, 141, 241, 246, 127, 72, 93, 63, 121, 6, 185, 98, 189, 163, 170, 42, 86, 89, 206, 234, 157, 139, 252, 162, 72, 194, 203, 122, 147, 87] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 21, extension_data: ServerName(ServerNameList { l: 19, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 16, data: [97, 112, 112, 115, 102, 108, 121, 101, 114, 115, 100, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 74, 102, 160, 210, 210, 195, 125, 132, 147, 240, 175, 42, 52, 65, 79, 150, 17, 153, 72, 135, 135, 58, 101, 21, 87, 230, 88, 58, 221, 105, 27] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 215, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [28, 240, 179, 90, 58, 54, 194, 14, 5, 28, 61, 18, 11, 121, 100, 164, 108, 227, 7, 114, 192, 247, 136, 160, 203, 104, 26, 179, 77, 221, 236, 65], legacy_session_id: SessionId { l: 32, id: [244, 101, 70, 141, 241, 246, 127, 72, 93, 63, 121, 6, 185, 98, 189, 163, 170, 42, 86, 89, 206, 234, 157, 139, 252, 162, 72, 194, 203, 122, 147, 87] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 21, extension_data: ServerName(ServerNameList { l: 19, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 16, data: [97, 112, 112, 115, 102, 108, 121, 101, 114, 115, 100, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 74, 102, 160, 210, 210, 195, 125, 132, 147, 240, 175, 42, 52, 65, 79, 150, 17, 153, 72, 135, 135, 58, 101, 21, 87, 230, 88, 58, 221, 105, 27] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 215, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: sharepoint.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [237, 177, 9, 148, 235, 175, 169, 55, 148, 31, 187, 202, 82, 203, 30, 23, 77, 22, 195, 131, 25, 35, 157, 209, 26, 11, 139, 79, 110, 145, 218, 61] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((16, Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }))
+[trace] HostName: Ok((16, Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((16, HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((17, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((19, ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((19, ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((23, ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [183, 146, 227, 29, 5, 227, 145, 166, 67, 59, 240, 107, 109, 162, 23, 200, 4, 195, 154, 18, 49, 213, 107, 120, 62, 38, 12, 139, 80, 227, 46, 47] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [183, 146, 227, 29, 5, 227, 145, 166, 67, 59, 240, 107, 109, 162, 23, 200, 4, 195, 154, 18, 49, 213, 107, 120, 62, 38, 12, 139, 80, 227, 46, 47] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [183, 146, 227, 29, 5, 227, 145, 166, 67, 59, 240, 107, 109, 162, 23, 200, 4, 195, 154, 18, 49, 213, 107, 120, 62, 38, 12, 139, 80, 227, 46, 47] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [183, 146, 227, 29, 5, 227, 145, 166, 67, 59, 240, 107, 109, 162, 23, 200, 4, 195, 154, 18, 49, 213, 107, 120, 62, 38, 12, 139, 80, 227, 46, 47] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((217, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((217, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((221, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [183, 146, 227, 29, 5, 227, 145, 166, 67, 59, 240, 107, 109, 162, 23, 200, 4, 195, 154, 18, 49, 213, 107, 120, 62, 38, 12, 139, 80, 227, 46, 47] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [131, 134, 128, 114, 240, 132, 184, 161, 73, 46, 131, 250, 127, 250, 167, 118, 194, 62, 95, 90, 197, 132, 246, 81, 168, 164, 83, 167, 118, 195, 243, 167], legacy_session_id: SessionId { l: 32, id: [237, 177, 9, 148, 235, 175, 169, 55, 148, 31, 187, 202, 82, 203, 30, 23, 77, 22, 195, 131, 25, 35, 157, 209, 26, 11, 139, 79, 110, 145, 218, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [183, 146, 227, 29, 5, 227, 145, 166, 67, 59, 240, 107, 109, 162, 23, 200, 4, 195, 154, 18, 49, 213, 107, 120, 62, 38, 12, 139, 80, 227, 46, 47] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [131, 134, 128, 114, 240, 132, 184, 161, 73, 46, 131, 250, 127, 250, 167, 118, 194, 62, 95, 90, 197, 132, 246, 81, 168, 164, 83, 167, 118, 195, 243, 167], legacy_session_id: SessionId { l: 32, id: [237, 177, 9, 148, 235, 175, 169, 55, 148, 31, 187, 202, 82, 203, 30, 23, 77, 22, 195, 131, 25, 35, 157, 209, 26, 11, 139, 79, 110, 145, 218, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [183, 146, 227, 29, 5, 227, 145, 166, 67, 59, 240, 107, 109, 162, 23, 200, 4, 195, 154, 18, 49, 213, 107, 120, 62, 38, 12, 139, 80, 227, 46, 47] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [131, 134, 128, 114, 240, 132, 184, 161, 73, 46, 131, 250, 127, 250, 167, 118, 194, 62, 95, 90, 197, 132, 246, 81, 168, 164, 83, 167, 118, 195, 243, 167], legacy_session_id: SessionId { l: 32, id: [237, 177, 9, 148, 235, 175, 169, 55, 148, 31, 187, 202, 82, 203, 30, 23, 77, 22, 195, 131, 25, 35, 157, 209, 26, 11, 139, 79, 110, 145, 218, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [183, 146, 227, 29, 5, 227, 145, 166, 67, 59, 240, 107, 109, 162, 23, 200, 4, 195, 154, 18, 49, 213, 107, 120, 62, 38, 12, 139, 80, 227, 46, 47] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [237, 177, 9, 148, 235, 175, 169, 55, 148, 31, 187, 202, 82, 203, 30, 23, 77, 22, 195, 131, 25, 35, 157, 209, 26, 11, 139, 79, 110, 145, 218, 61] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((16, Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }))
+[trace] HostName: Ok((16, Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((16, HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((17, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((19, ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((19, ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((23, ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 25))
+[trace] KeyShareEntry: Ok((137, KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 49, 110, 8, 162, 75, 216, 194, 39, 77, 33, 13, 173, 254, 240, 38, 167, 91, 160, 67, 71, 90, 153, 49, 35, 73, 208, 13, 47, 55, 122, 196, 90, 56, 161, 48, 115, 32, 7, 78, 232, 166, 11, 58, 100, 198, 216, 119, 206, 73, 148, 250, 222, 142, 191, 22, 45, 127, 33, 1, 254, 27, 156, 194, 92, 34, 1, 38, 185, 94, 245, 205, 3, 42, 123, 223, 43, 113, 113, 63, 54, 152, 115, 166, 103, 200, 236, 19, 225, 202, 71, 196, 233, 26, 176, 45, 117, 2, 92, 70, 216, 30, 225, 132, 192, 180, 226, 34, 18, 225, 10, 147, 122, 137, 188, 117, 203, 225, 25, 8, 221, 202, 13, 121, 87, 6, 146, 56, 49, 79, 196, 158] }))
+[trace] KeyShareClientHello: Ok((139, KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 49, 110, 8, 162, 75, 216, 194, 39, 77, 33, 13, 173, 254, 240, 38, 167, 91, 160, 67, 71, 90, 153, 49, 35, 73, 208, 13, 47, 55, 122, 196, 90, 56, 161, 48, 115, 32, 7, 78, 232, 166, 11, 58, 100, 198, 216, 119, 206, 73, 148, 250, 222, 142, 191, 22, 45, 127, 33, 1, 254, 27, 156, 194, 92, 34, 1, 38, 185, 94, 245, 205, 3, 42, 123, 223, 43, 113, 113, 63, 54, 152, 115, 166, 103, 200, 236, 19, 225, 202, 71, 196, 233, 26, 176, 45, 117, 2, 92, 70, 216, 30, 225, 132, 192, 180, 226, 34, 18, 225, 10, 147, 122, 137, 188, 117, 203, 225, 25, 8, 221, 202, 13, 121, 87, 6, 146, 56, 49, 79, 196, 158] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((139, KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 49, 110, 8, 162, 75, 216, 194, 39, 77, 33, 13, 173, 254, 240, 38, 167, 91, 160, 67, 71, 90, 153, 49, 35, 73, 208, 13, 47, 55, 122, 196, 90, 56, 161, 48, 115, 32, 7, 78, 232, 166, 11, 58, 100, 198, 216, 119, 206, 73, 148, 250, 222, 142, 191, 22, 45, 127, 33, 1, 254, 27, 156, 194, 92, 34, 1, 38, 185, 94, 245, 205, 3, 42, 123, 223, 43, 113, 113, 63, 54, 152, 115, 166, 103, 200, 236, 19, 225, 202, 71, 196, 233, 26, 176, 45, 117, 2, 92, 70, 216, 30, 225, 132, 192, 180, 226, 34, 18, 225, 10, 147, 122, 137, 188, 117, 203, 225, 25, 8, 221, 202, 13, 121, 87, 6, 146, 56, 49, 79, 196, 158] }]) })))
+[trace] ClientHelloExtension: Ok((143, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 49, 110, 8, 162, 75, 216, 194, 39, 77, 33, 13, 173, 254, 240, 38, 167, 91, 160, 67, 71, 90, 153, 49, 35, 73, 208, 13, 47, 55, 122, 196, 90, 56, 161, 48, 115, 32, 7, 78, 232, 166, 11, 58, 100, 198, 216, 119, 206, 73, 148, 250, 222, 142, 191, 22, 45, 127, 33, 1, 254, 27, 156, 194, 92, 34, 1, 38, 185, 94, 245, 205, 3, 42, 123, 223, 43, 113, 113, 63, 54, 152, 115, 166, 103, 200, 236, 19, 225, 202, 71, 196, 233, 26, 176, 45, 117, 2, 92, 70, 216, 30, 225, 132, 192, 180, 226, 34, 18, 225, 10, 147, 122, 137, 188, 117, 203, 225, 25, 8, 221, 202, 13, 121, 87, 6, 146, 56, 49, 79, 196, 158] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((116, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((116, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((120, ClientHelloExtension { extension_type: 21, ext_len: 116, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 49, 110, 8, 162, 75, 216, 194, 39, 77, 33, 13, 173, 254, 240, 38, 167, 91, 160, 67, 71, 90, 153, 49, 35, 73, 208, 13, 47, 55, 122, 196, 90, 56, 161, 48, 115, 32, 7, 78, 232, 166, 11, 58, 100, 198, 216, 119, 206, 73, 148, 250, 222, 142, 191, 22, 45, 127, 33, 1, 254, 27, 156, 194, 92, 34, 1, 38, 185, 94, 245, 205, 3, 42, 123, 223, 43, 113, 113, 63, 54, 152, 115, 166, 103, 200, 236, 19, 225, 202, 71, 196, 233, 26, 176, 45, 117, 2, 92, 70, 216, 30, 225, 132, 192, 180, 226, 34, 18, 225, 10, 147, 122, 137, 188, 117, 203, 225, 25, 8, 221, 202, 13, 121, 87, 6, 146, 56, 49, 79, 196, 158] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 116, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [131, 134, 128, 114, 240, 132, 184, 161, 73, 46, 131, 250, 127, 250, 167, 118, 194, 62, 95, 90, 197, 132, 246, 81, 168, 164, 83, 167, 118, 195, 243, 167], legacy_session_id: SessionId { l: 32, id: [237, 177, 9, 148, 235, 175, 169, 55, 148, 31, 187, 202, 82, 203, 30, 23, 77, 22, 195, 131, 25, 35, 157, 209, 26, 11, 139, 79, 110, 145, 218, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 49, 110, 8, 162, 75, 216, 194, 39, 77, 33, 13, 173, 254, 240, 38, 167, 91, 160, 67, 71, 90, 153, 49, 35, 73, 208, 13, 47, 55, 122, 196, 90, 56, 161, 48, 115, 32, 7, 78, 232, 166, 11, 58, 100, 198, 216, 119, 206, 73, 148, 250, 222, 142, 191, 22, 45, 127, 33, 1, 254, 27, 156, 194, 92, 34, 1, 38, 185, 94, 245, 205, 3, 42, 123, 223, 43, 113, 113, 63, 54, 152, 115, 166, 103, 200, 236, 19, 225, 202, 71, 196, 233, 26, 176, 45, 117, 2, 92, 70, 216, 30, 225, 132, 192, 180, 226, 34, 18, 225, 10, 147, 122, 137, 188, 117, 203, 225, 25, 8, 221, 202, 13, 121, 87, 6, 146, 56, 49, 79, 196, 158] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 116, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [131, 134, 128, 114, 240, 132, 184, 161, 73, 46, 131, 250, 127, 250, 167, 118, 194, 62, 95, 90, 197, 132, 246, 81, 168, 164, 83, 167, 118, 195, 243, 167], legacy_session_id: SessionId { l: 32, id: [237, 177, 9, 148, 235, 175, 169, 55, 148, 31, 187, 202, 82, 203, 30, 23, 77, 22, 195, 131, 25, 35, 157, 209, 26, 11, 139, 79, 110, 145, 218, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 49, 110, 8, 162, 75, 216, 194, 39, 77, 33, 13, 173, 254, 240, 38, 167, 91, 160, 67, 71, 90, 153, 49, 35, 73, 208, 13, 47, 55, 122, 196, 90, 56, 161, 48, 115, 32, 7, 78, 232, 166, 11, 58, 100, 198, 216, 119, 206, 73, 148, 250, 222, 142, 191, 22, 45, 127, 33, 1, 254, 27, 156, 194, 92, 34, 1, 38, 185, 94, 245, 205, 3, 42, 123, 223, 43, 113, 113, 63, 54, 152, 115, 166, 103, 200, 236, 19, 225, 202, 71, 196, 233, 26, 176, 45, 117, 2, 92, 70, 216, 30, 225, 132, 192, 180, 226, 34, 18, 225, 10, 147, 122, 137, 188, 117, 203, 225, 25, 8, 221, 202, 13, 121, 87, 6, 146, 56, 49, 79, 196, 158] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 116, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [131, 134, 128, 114, 240, 132, 184, 161, 73, 46, 131, 250, 127, 250, 167, 118, 194, 62, 95, 90, 197, 132, 246, 81, 168, 164, 83, 167, 118, 195, 243, 167], legacy_session_id: SessionId { l: 32, id: [237, 177, 9, 148, 235, 175, 169, 55, 148, 31, 187, 202, 82, 203, 30, 23, 77, 22, 195, 131, 25, 35, 157, 209, 26, 11, 139, 79, 110, 145, 218, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [115, 104, 97, 114, 101, 112, 111, 105, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 49, 110, 8, 162, 75, 216, 194, 39, 77, 33, 13, 173, 254, 240, 38, 167, 91, 160, 67, 71, 90, 153, 49, 35, 73, 208, 13, 47, 55, 122, 196, 90, 56, 161, 48, 115, 32, 7, 78, 232, 166, 11, 58, 100, 198, 216, 119, 206, 73, 148, 250, 222, 142, 191, 22, 45, 127, 33, 1, 254, 27, 156, 194, 92, 34, 1, 38, 185, 94, 245, 205, 3, 42, 123, 223, 43, 113, 113, 63, 54, 152, 115, 166, 103, 200, 236, 19, 225, 202, 71, 196, 233, 26, 176, 45, 117, 2, 92, 70, 216, 30, 225, 132, 192, 180, 226, 34, 18, 225, 10, 147, 122, 137, 188, 117, 203, 225, 25, 8, 221, 202, 13, 121, 87, 6, 146, 56, 49, 79, 196, 158] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 116, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: adobe.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [12, 103, 222, 170, 78, 20, 204, 19, 239, 75, 243, 227, 108, 14, 16, 165, 4, 82, 254, 244, 159, 180, 164, 147, 78, 24, 86, 204, 161, 54, 253, 203] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [97, 100, 111, 98, 101, 46, 99, 111, 109] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [97, 100, 111, 98, 101, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [97, 100, 111, 98, 101, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 100, 111, 98, 101, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 100, 111, 98, 101, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 100, 111, 98, 101, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 100, 111, 98, 101, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [139, 244, 178, 82, 111, 155, 202, 20, 28, 115, 1, 29, 204, 105, 235, 70, 24, 47, 218, 220, 66, 168, 14, 51, 229, 217, 213, 150, 164, 243, 162, 115] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 244, 178, 82, 111, 155, 202, 20, 28, 115, 1, 29, 204, 105, 235, 70, 24, 47, 218, 220, 66, 168, 14, 51, 229, 217, 213, 150, 164, 243, 162, 115] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 244, 178, 82, 111, 155, 202, 20, 28, 115, 1, 29, 204, 105, 235, 70, 24, 47, 218, 220, 66, 168, 14, 51, 229, 217, 213, 150, 164, 243, 162, 115] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 244, 178, 82, 111, 155, 202, 20, 28, 115, 1, 29, 204, 105, 235, 70, 24, 47, 218, 220, 66, 168, 14, 51, 229, 217, 213, 150, 164, 243, 162, 115] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 100, 111, 98, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 244, 178, 82, 111, 155, 202, 20, 28, 115, 1, 29, 204, 105, 235, 70, 24, 47, 218, 220, 66, 168, 14, 51, 229, 217, 213, 150, 164, 243, 162, 115] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [21, 227, 3, 34, 19, 71, 90, 35, 144, 222, 47, 163, 184, 168, 89, 137, 32, 1, 125, 114, 91, 211, 92, 196, 168, 23, 49, 74, 100, 201, 112, 202], legacy_session_id: SessionId { l: 32, id: [12, 103, 222, 170, 78, 20, 204, 19, 239, 75, 243, 227, 108, 14, 16, 165, 4, 82, 254, 244, 159, 180, 164, 147, 78, 24, 86, 204, 161, 54, 253, 203] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 100, 111, 98, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 244, 178, 82, 111, 155, 202, 20, 28, 115, 1, 29, 204, 105, 235, 70, 24, 47, 218, 220, 66, 168, 14, 51, 229, 217, 213, 150, 164, 243, 162, 115] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [21, 227, 3, 34, 19, 71, 90, 35, 144, 222, 47, 163, 184, 168, 89, 137, 32, 1, 125, 114, 91, 211, 92, 196, 168, 23, 49, 74, 100, 201, 112, 202], legacy_session_id: SessionId { l: 32, id: [12, 103, 222, 170, 78, 20, 204, 19, 239, 75, 243, 227, 108, 14, 16, 165, 4, 82, 254, 244, 159, 180, 164, 147, 78, 24, 86, 204, 161, 54, 253, 203] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 100, 111, 98, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 244, 178, 82, 111, 155, 202, 20, 28, 115, 1, 29, 204, 105, 235, 70, 24, 47, 218, 220, 66, 168, 14, 51, 229, 217, 213, 150, 164, 243, 162, 115] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [21, 227, 3, 34, 19, 71, 90, 35, 144, 222, 47, 163, 184, 168, 89, 137, 32, 1, 125, 114, 91, 211, 92, 196, 168, 23, 49, 74, 100, 201, 112, 202], legacy_session_id: SessionId { l: 32, id: [12, 103, 222, 170, 78, 20, 204, 19, 239, 75, 243, 227, 108, 14, 16, 165, 4, 82, 254, 244, 159, 180, 164, 147, 78, 24, 86, 204, 161, 54, 253, 203] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [97, 100, 111, 98, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [139, 244, 178, 82, 111, 155, 202, 20, 28, 115, 1, 29, 204, 105, 235, 70, 24, 47, 218, 220, 66, 168, 14, 51, 229, 217, 213, 150, 164, 243, 162, 115] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: goo.gl
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [63, 118, 143, 118, 45, 121, 7, 249, 172, 182, 51, 47, 13, 215, 39, 104, 148, 59, 74, 248, 8, 108, 114, 137, 23, 125, 136, 140, 31, 136, 105, 19] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((8, Opaque1Ffff { l: 6, data: [103, 111, 111, 46, 103, 108] }))
+[trace] HostName: Ok((8, Opaque1Ffff { l: 6, data: [103, 111, 111, 46, 103, 108] }))
+[trace] ServerNameName: Ok((8, HostName(Opaque1Ffff { l: 6, data: [103, 111, 111, 46, 103, 108] })))
+[trace] ServerName: Ok((9, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [103, 111, 111, 46, 103, 108] }) }))
+[trace] ServerNameList: Ok((11, ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [103, 111, 111, 46, 103, 108] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((11, ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [103, 111, 111, 46, 103, 108] }) }]) })))
+[trace] ClientHelloExtension: Ok((15, ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [103, 111, 111, 46, 103, 108] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [53, 2, 111, 1, 153, 6, 255, 160, 145, 119, 180, 85, 128, 222, 41, 183, 44, 57, 28, 71, 183, 242, 42, 222, 254, 228, 132, 28, 216, 160, 33, 49] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [53, 2, 111, 1, 153, 6, 255, 160, 145, 119, 180, 85, 128, 222, 41, 183, 44, 57, 28, 71, 183, 242, 42, 222, 254, 228, 132, 28, 216, 160, 33, 49] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [53, 2, 111, 1, 153, 6, 255, 160, 145, 119, 180, 85, 128, 222, 41, 183, 44, 57, 28, 71, 183, 242, 42, 222, 254, 228, 132, 28, 216, 160, 33, 49] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [53, 2, 111, 1, 153, 6, 255, 160, 145, 119, 180, 85, 128, 222, 41, 183, 44, 57, 28, 71, 183, 242, 42, 222, 254, 228, 132, 28, 216, 160, 33, 49] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((225, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((225, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((229, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [103, 111, 111, 46, 103, 108] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [53, 2, 111, 1, 153, 6, 255, 160, 145, 119, 180, 85, 128, 222, 41, 183, 44, 57, 28, 71, 183, 242, 42, 222, 254, 228, 132, 28, 216, 160, 33, 49] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [71, 4, 56, 56, 98, 21, 154, 145, 64, 63, 244, 120, 44, 67, 62, 108, 186, 12, 197, 127, 88, 163, 117, 113, 191, 108, 197, 105, 189, 166, 122, 143], legacy_session_id: SessionId { l: 32, id: [63, 118, 143, 118, 45, 121, 7, 249, 172, 182, 51, 47, 13, 215, 39, 104, 148, 59, 74, 248, 8, 108, 114, 137, 23, 125, 136, 140, 31, 136, 105, 19] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [103, 111, 111, 46, 103, 108] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [53, 2, 111, 1, 153, 6, 255, 160, 145, 119, 180, 85, 128, 222, 41, 183, 44, 57, 28, 71, 183, 242, 42, 222, 254, 228, 132, 28, 216, 160, 33, 49] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [71, 4, 56, 56, 98, 21, 154, 145, 64, 63, 244, 120, 44, 67, 62, 108, 186, 12, 197, 127, 88, 163, 117, 113, 191, 108, 197, 105, 189, 166, 122, 143], legacy_session_id: SessionId { l: 32, id: [63, 118, 143, 118, 45, 121, 7, 249, 172, 182, 51, 47, 13, 215, 39, 104, 148, 59, 74, 248, 8, 108, 114, 137, 23, 125, 136, 140, 31, 136, 105, 19] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [103, 111, 111, 46, 103, 108] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [53, 2, 111, 1, 153, 6, 255, 160, 145, 119, 180, 85, 128, 222, 41, 183, 44, 57, 28, 71, 183, 242, 42, 222, 254, 228, 132, 28, 216, 160, 33, 49] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [71, 4, 56, 56, 98, 21, 154, 145, 64, 63, 244, 120, 44, 67, 62, 108, 186, 12, 197, 127, 88, 163, 117, 113, 191, 108, 197, 105, 189, 166, 122, 143], legacy_session_id: SessionId { l: 32, id: [63, 118, 143, 118, 45, 121, 7, 249, 172, 182, 51, 47, 13, 215, 39, 104, 148, 59, 74, 248, 8, 108, 114, 137, 23, 125, 136, 140, 31, 136, 105, 19] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [103, 111, 111, 46, 103, 108] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [53, 2, 111, 1, 153, 6, 255, 160, 145, 119, 180, 85, 128, 222, 41, 183, 44, 57, 28, 71, 183, 242, 42, 222, 254, 228, 132, 28, 216, 160, 33, 49] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: skype.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [201, 175, 225, 1, 247, 155, 21, 192, 181, 115, 216, 75, 174, 115, 177, 20, 86, 93, 94, 248, 247, 236, 24, 216, 103, 198, 194, 55, 112, 218, 46, 147] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [115, 107, 121, 112, 101, 46, 99, 111, 109] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [115, 107, 121, 112, 101, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [115, 107, 121, 112, 101, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 107, 121, 112, 101, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 107, 121, 112, 101, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 107, 121, 112, 101, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 107, 121, 112, 101, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [179, 242, 209, 54, 143, 100, 47, 151, 206, 188, 81, 183, 110, 67, 74, 58, 46, 160, 47, 33, 24, 141, 94, 98, 182, 112, 204, 53, 192, 19, 148, 76] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 242, 209, 54, 143, 100, 47, 151, 206, 188, 81, 183, 110, 67, 74, 58, 46, 160, 47, 33, 24, 141, 94, 98, 182, 112, 204, 53, 192, 19, 148, 76] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 242, 209, 54, 143, 100, 47, 151, 206, 188, 81, 183, 110, 67, 74, 58, 46, 160, 47, 33, 24, 141, 94, 98, 182, 112, 204, 53, 192, 19, 148, 76] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 242, 209, 54, 143, 100, 47, 151, 206, 188, 81, 183, 110, 67, 74, 58, 46, 160, 47, 33, 24, 141, 94, 98, 182, 112, 204, 53, 192, 19, 148, 76] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 107, 121, 112, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 242, 209, 54, 143, 100, 47, 151, 206, 188, 81, 183, 110, 67, 74, 58, 46, 160, 47, 33, 24, 141, 94, 98, 182, 112, 204, 53, 192, 19, 148, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [68, 22, 132, 213, 207, 156, 24, 119, 231, 34, 52, 231, 31, 25, 43, 147, 5, 10, 152, 146, 1, 230, 250, 147, 168, 10, 232, 155, 150, 120, 0, 124], legacy_session_id: SessionId { l: 32, id: [201, 175, 225, 1, 247, 155, 21, 192, 181, 115, 216, 75, 174, 115, 177, 20, 86, 93, 94, 248, 247, 236, 24, 216, 103, 198, 194, 55, 112, 218, 46, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 107, 121, 112, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 242, 209, 54, 143, 100, 47, 151, 206, 188, 81, 183, 110, 67, 74, 58, 46, 160, 47, 33, 24, 141, 94, 98, 182, 112, 204, 53, 192, 19, 148, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [68, 22, 132, 213, 207, 156, 24, 119, 231, 34, 52, 231, 31, 25, 43, 147, 5, 10, 152, 146, 1, 230, 250, 147, 168, 10, 232, 155, 150, 120, 0, 124], legacy_session_id: SessionId { l: 32, id: [201, 175, 225, 1, 247, 155, 21, 192, 181, 115, 216, 75, 174, 115, 177, 20, 86, 93, 94, 248, 247, 236, 24, 216, 103, 198, 194, 55, 112, 218, 46, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 107, 121, 112, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 242, 209, 54, 143, 100, 47, 151, 206, 188, 81, 183, 110, 67, 74, 58, 46, 160, 47, 33, 24, 141, 94, 98, 182, 112, 204, 53, 192, 19, 148, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [68, 22, 132, 213, 207, 156, 24, 119, 231, 34, 52, 231, 31, 25, 43, 147, 5, 10, 152, 146, 1, 230, 250, 147, 168, 10, 232, 155, 150, 120, 0, 124], legacy_session_id: SessionId { l: 32, id: [201, 175, 225, 1, 247, 155, 21, 192, 181, 115, 216, 75, 174, 115, 177, 20, 86, 93, 94, 248, 247, 236, 24, 216, 103, 198, 194, 55, 112, 218, 46, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 107, 121, 112, 101, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 242, 209, 54, 143, 100, 47, 151, 206, 188, 81, 183, 110, 67, 74, 58, 46, 160, 47, 33, 24, 141, 94, 98, 182, 112, 204, 53, 192, 19, 148, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: whatsapp.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [1, 205, 194, 151, 169, 17, 141, 42, 146, 64, 232, 4, 131, 60, 178, 107, 36, 39, 223, 90, 57, 134, 243, 77, 11, 184, 129, 44, 175, 203, 92, 245] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((14, Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 99, 111, 109] }))
+[trace] HostName: Ok((14, Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((14, HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((15, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((17, ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((17, ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((21, ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [129, 182, 142, 60, 240, 180, 254, 208, 234, 236, 103, 87, 199, 73, 168, 191, 56, 100, 61, 160, 229, 25, 34, 239, 38, 245, 23, 75, 57, 237, 68, 120] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 182, 142, 60, 240, 180, 254, 208, 234, 236, 103, 87, 199, 73, 168, 191, 56, 100, 61, 160, 229, 25, 34, 239, 38, 245, 23, 75, 57, 237, 68, 120] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 182, 142, 60, 240, 180, 254, 208, 234, 236, 103, 87, 199, 73, 168, 191, 56, 100, 61, 160, 229, 25, 34, 239, 38, 245, 23, 75, 57, 237, 68, 120] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 182, 142, 60, 240, 180, 254, 208, 234, 236, 103, 87, 199, 73, 168, 191, 56, 100, 61, 160, 229, 25, 34, 239, 38, 245, 23, 75, 57, 237, 68, 120] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((219, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((219, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((223, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 182, 142, 60, 240, 180, 254, 208, 234, 236, 103, 87, 199, 73, 168, 191, 56, 100, 61, 160, 229, 25, 34, 239, 38, 245, 23, 75, 57, 237, 68, 120] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [90, 243, 7, 61, 206, 113, 62, 111, 40, 141, 149, 139, 47, 136, 68, 132, 141, 247, 166, 18, 239, 220, 80, 31, 172, 141, 217, 64, 143, 163, 135, 110], legacy_session_id: SessionId { l: 32, id: [1, 205, 194, 151, 169, 17, 141, 42, 146, 64, 232, 4, 131, 60, 178, 107, 36, 39, 223, 90, 57, 134, 243, 77, 11, 184, 129, 44, 175, 203, 92, 245] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 182, 142, 60, 240, 180, 254, 208, 234, 236, 103, 87, 199, 73, 168, 191, 56, 100, 61, 160, 229, 25, 34, 239, 38, 245, 23, 75, 57, 237, 68, 120] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [90, 243, 7, 61, 206, 113, 62, 111, 40, 141, 149, 139, 47, 136, 68, 132, 141, 247, 166, 18, 239, 220, 80, 31, 172, 141, 217, 64, 143, 163, 135, 110], legacy_session_id: SessionId { l: 32, id: [1, 205, 194, 151, 169, 17, 141, 42, 146, 64, 232, 4, 131, 60, 178, 107, 36, 39, 223, 90, 57, 134, 243, 77, 11, 184, 129, 44, 175, 203, 92, 245] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 182, 142, 60, 240, 180, 254, 208, 234, 236, 103, 87, 199, 73, 168, 191, 56, 100, 61, 160, 229, 25, 34, 239, 38, 245, 23, 75, 57, 237, 68, 120] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [90, 243, 7, 61, 206, 113, 62, 111, 40, 141, 149, 139, 47, 136, 68, 132, 141, 247, 166, 18, 239, 220, 80, 31, 172, 141, 217, 64, 143, 163, 135, 110], legacy_session_id: SessionId { l: 32, id: [1, 205, 194, 151, 169, 17, 141, 42, 146, 64, 232, 4, 131, 60, 178, 107, 36, 39, 223, 90, 57, 134, 243, 77, 11, 184, 129, 44, 175, 203, 92, 245] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [119, 104, 97, 116, 115, 97, 112, 112, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 182, 142, 60, 240, 180, 254, 208, 234, 236, 103, 87, 199, 73, 168, 191, 56, 100, 61, 160, 229, 25, 34, 239, 38, 245, 23, 75, 57, 237, 68, 120] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: vimeo.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [144, 144, 163, 136, 226, 193, 36, 37, 173, 243, 242, 43, 165, 45, 85, 16, 90, 46, 26, 61, 141, 19, 27, 189, 162, 62, 124, 61, 3, 166, 203, 44] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [118, 105, 109, 101, 111, 46, 99, 111, 109] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [118, 105, 109, 101, 111, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [118, 105, 109, 101, 111, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [118, 105, 109, 101, 111, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [118, 105, 109, 101, 111, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [118, 105, 109, 101, 111, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [118, 105, 109, 101, 111, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [44, 127, 30, 209, 51, 253, 11, 133, 239, 195, 96, 68, 188, 125, 245, 245, 99, 3, 0, 30, 14, 217, 138, 3, 25, 239, 114, 153, 16, 15, 171, 78] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 127, 30, 209, 51, 253, 11, 133, 239, 195, 96, 68, 188, 125, 245, 245, 99, 3, 0, 30, 14, 217, 138, 3, 25, 239, 114, 153, 16, 15, 171, 78] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 127, 30, 209, 51, 253, 11, 133, 239, 195, 96, 68, 188, 125, 245, 245, 99, 3, 0, 30, 14, 217, 138, 3, 25, 239, 114, 153, 16, 15, 171, 78] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 127, 30, 209, 51, 253, 11, 133, 239, 195, 96, 68, 188, 125, 245, 245, 99, 3, 0, 30, 14, 217, 138, 3, 25, 239, 114, 153, 16, 15, 171, 78] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [118, 105, 109, 101, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 127, 30, 209, 51, 253, 11, 133, 239, 195, 96, 68, 188, 125, 245, 245, 99, 3, 0, 30, 14, 217, 138, 3, 25, 239, 114, 153, 16, 15, 171, 78] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [157, 69, 17, 83, 203, 61, 200, 229, 184, 166, 13, 5, 99, 57, 99, 5, 214, 4, 71, 112, 128, 147, 21, 233, 127, 58, 84, 124, 146, 100, 28, 133], legacy_session_id: SessionId { l: 32, id: [144, 144, 163, 136, 226, 193, 36, 37, 173, 243, 242, 43, 165, 45, 85, 16, 90, 46, 26, 61, 141, 19, 27, 189, 162, 62, 124, 61, 3, 166, 203, 44] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [118, 105, 109, 101, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 127, 30, 209, 51, 253, 11, 133, 239, 195, 96, 68, 188, 125, 245, 245, 99, 3, 0, 30, 14, 217, 138, 3, 25, 239, 114, 153, 16, 15, 171, 78] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [157, 69, 17, 83, 203, 61, 200, 229, 184, 166, 13, 5, 99, 57, 99, 5, 214, 4, 71, 112, 128, 147, 21, 233, 127, 58, 84, 124, 146, 100, 28, 133], legacy_session_id: SessionId { l: 32, id: [144, 144, 163, 136, 226, 193, 36, 37, 173, 243, 242, 43, 165, 45, 85, 16, 90, 46, 26, 61, 141, 19, 27, 189, 162, 62, 124, 61, 3, 166, 203, 44] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [118, 105, 109, 101, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 127, 30, 209, 51, 253, 11, 133, 239, 195, 96, 68, 188, 125, 245, 245, 99, 3, 0, 30, 14, 217, 138, 3, 25, 239, 114, 153, 16, 15, 171, 78] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [157, 69, 17, 83, 203, 61, 200, 229, 184, 166, 13, 5, 99, 57, 99, 5, 214, 4, 71, 112, 128, 147, 21, 233, 127, 58, 84, 124, 146, 100, 28, 133], legacy_session_id: SessionId { l: 32, id: [144, 144, 163, 136, 226, 193, 36, 37, 173, 243, 242, 43, 165, 45, 85, 16, 90, 46, 26, 61, 141, 19, 27, 189, 162, 62, 124, 61, 3, 166, 203, 44] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [118, 105, 109, 101, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 127, 30, 209, 51, 253, 11, 133, 239, 195, 96, 68, 188, 125, 245, 245, 99, 3, 0, 30, 14, 217, 138, 3, 25, 239, 114, 153, 16, 15, 171, 78] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: spotify.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [201, 67, 148, 23, 60, 148, 72, 124, 17, 188, 55, 46, 168, 176, 174, 24, 36, 68, 55, 108, 72, 194, 130, 177, 140, 170, 133, 21, 228, 147, 222, 202] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [115, 112, 111, 116, 105, 102, 121, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [115, 112, 111, 116, 105, 102, 121, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [115, 112, 111, 116, 105, 102, 121, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 112, 111, 116, 105, 102, 121, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 112, 111, 116, 105, 102, 121, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 112, 111, 116, 105, 102, 121, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 112, 111, 116, 105, 102, 121, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [85, 35, 64, 83, 195, 90, 193, 43, 30, 101, 187, 34, 179, 79, 120, 72, 140, 7, 55, 61, 188, 165, 177, 40, 167, 12, 83, 169, 200, 69, 205, 100] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 35, 64, 83, 195, 90, 193, 43, 30, 101, 187, 34, 179, 79, 120, 72, 140, 7, 55, 61, 188, 165, 177, 40, 167, 12, 83, 169, 200, 69, 205, 100] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 35, 64, 83, 195, 90, 193, 43, 30, 101, 187, 34, 179, 79, 120, 72, 140, 7, 55, 61, 188, 165, 177, 40, 167, 12, 83, 169, 200, 69, 205, 100] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 35, 64, 83, 195, 90, 193, 43, 30, 101, 187, 34, 179, 79, 120, 72, 140, 7, 55, 61, 188, 165, 177, 40, 167, 12, 83, 169, 200, 69, 205, 100] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 112, 111, 116, 105, 102, 121, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 35, 64, 83, 195, 90, 193, 43, 30, 101, 187, 34, 179, 79, 120, 72, 140, 7, 55, 61, 188, 165, 177, 40, 167, 12, 83, 169, 200, 69, 205, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [22, 185, 93, 10, 253, 22, 141, 1, 251, 139, 118, 255, 3, 206, 247, 45, 216, 250, 50, 2, 250, 141, 167, 204, 0, 167, 66, 237, 101, 154, 45, 169], legacy_session_id: SessionId { l: 32, id: [201, 67, 148, 23, 60, 148, 72, 124, 17, 188, 55, 46, 168, 176, 174, 24, 36, 68, 55, 108, 72, 194, 130, 177, 140, 170, 133, 21, 228, 147, 222, 202] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 112, 111, 116, 105, 102, 121, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 35, 64, 83, 195, 90, 193, 43, 30, 101, 187, 34, 179, 79, 120, 72, 140, 7, 55, 61, 188, 165, 177, 40, 167, 12, 83, 169, 200, 69, 205, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [22, 185, 93, 10, 253, 22, 141, 1, 251, 139, 118, 255, 3, 206, 247, 45, 216, 250, 50, 2, 250, 141, 167, 204, 0, 167, 66, 237, 101, 154, 45, 169], legacy_session_id: SessionId { l: 32, id: [201, 67, 148, 23, 60, 148, 72, 124, 17, 188, 55, 46, 168, 176, 174, 24, 36, 68, 55, 108, 72, 194, 130, 177, 140, 170, 133, 21, 228, 147, 222, 202] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 112, 111, 116, 105, 102, 121, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 35, 64, 83, 195, 90, 193, 43, 30, 101, 187, 34, 179, 79, 120, 72, 140, 7, 55, 61, 188, 165, 177, 40, 167, 12, 83, 169, 200, 69, 205, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [22, 185, 93, 10, 253, 22, 141, 1, 251, 139, 118, 255, 3, 206, 247, 45, 216, 250, 50, 2, 250, 141, 167, 204, 0, 167, 66, 237, 101, 154, 45, 169], legacy_session_id: SessionId { l: 32, id: [201, 67, 148, 23, 60, 148, 72, 124, 17, 188, 55, 46, 168, 176, 174, 24, 36, 68, 55, 108, 72, 194, 130, 177, 140, 170, 133, 21, 228, 147, 222, 202] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 112, 111, 116, 105, 102, 121, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [85, 35, 64, 83, 195, 90, 193, 43, 30, 101, 187, 34, 179, 79, 120, 72, 140, 7, 55, 61, 188, 165, 177, 40, 167, 12, 83, 169, 200, 69, 205, 100] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: tiktokv.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [96, 149, 216, 15, 24, 69, 11, 86, 200, 102, 192, 164, 125, 120, 20, 16, 198, 169, 151, 162, 241, 76, 226, 251, 182, 110, 2, 201, 180, 74, 186, 177] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [116, 105, 107, 116, 111, 107, 118, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [116, 105, 107, 116, 111, 107, 118, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [116, 105, 107, 116, 111, 107, 118, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 105, 107, 116, 111, 107, 118, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 105, 107, 116, 111, 107, 118, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 105, 107, 116, 111, 107, 118, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 105, 107, 116, 111, 107, 118, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [44, 125, 3, 2, 128, 163, 97, 81, 88, 66, 235, 44, 250, 23, 38, 26, 137, 165, 188, 31, 217, 238, 111, 195, 240, 70, 16, 201, 139, 17, 237, 113] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 125, 3, 2, 128, 163, 97, 81, 88, 66, 235, 44, 250, 23, 38, 26, 137, 165, 188, 31, 217, 238, 111, 195, 240, 70, 16, 201, 139, 17, 237, 113] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 125, 3, 2, 128, 163, 97, 81, 88, 66, 235, 44, 250, 23, 38, 26, 137, 165, 188, 31, 217, 238, 111, 195, 240, 70, 16, 201, 139, 17, 237, 113] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 125, 3, 2, 128, 163, 97, 81, 88, 66, 235, 44, 250, 23, 38, 26, 137, 165, 188, 31, 217, 238, 111, 195, 240, 70, 16, 201, 139, 17, 237, 113] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 105, 107, 116, 111, 107, 118, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 125, 3, 2, 128, 163, 97, 81, 88, 66, 235, 44, 250, 23, 38, 26, 137, 165, 188, 31, 217, 238, 111, 195, 240, 70, 16, 201, 139, 17, 237, 113] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [212, 247, 69, 3, 20, 49, 215, 67, 173, 44, 30, 164, 112, 131, 157, 110, 68, 95, 39, 146, 62, 174, 218, 175, 133, 243, 81, 46, 45, 200, 104, 247], legacy_session_id: SessionId { l: 32, id: [96, 149, 216, 15, 24, 69, 11, 86, 200, 102, 192, 164, 125, 120, 20, 16, 198, 169, 151, 162, 241, 76, 226, 251, 182, 110, 2, 201, 180, 74, 186, 177] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 105, 107, 116, 111, 107, 118, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 125, 3, 2, 128, 163, 97, 81, 88, 66, 235, 44, 250, 23, 38, 26, 137, 165, 188, 31, 217, 238, 111, 195, 240, 70, 16, 201, 139, 17, 237, 113] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [212, 247, 69, 3, 20, 49, 215, 67, 173, 44, 30, 164, 112, 131, 157, 110, 68, 95, 39, 146, 62, 174, 218, 175, 133, 243, 81, 46, 45, 200, 104, 247], legacy_session_id: SessionId { l: 32, id: [96, 149, 216, 15, 24, 69, 11, 86, 200, 102, 192, 164, 125, 120, 20, 16, 198, 169, 151, 162, 241, 76, 226, 251, 182, 110, 2, 201, 180, 74, 186, 177] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 105, 107, 116, 111, 107, 118, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 125, 3, 2, 128, 163, 97, 81, 88, 66, 235, 44, 250, 23, 38, 26, 137, 165, 188, 31, 217, 238, 111, 195, 240, 70, 16, 201, 139, 17, 237, 113] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [212, 247, 69, 3, 20, 49, 215, 67, 173, 44, 30, 164, 112, 131, 157, 110, 68, 95, 39, 146, 62, 174, 218, 175, 133, 243, 81, 46, 45, 200, 104, 247], legacy_session_id: SessionId { l: 32, id: [96, 149, 216, 15, 24, 69, 11, 86, 200, 102, 192, 164, 125, 120, 20, 16, 198, 169, 151, 162, 241, 76, 226, 251, 182, 110, 2, 201, 180, 74, 186, 177] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 105, 107, 116, 111, 107, 118, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [44, 125, 3, 2, 128, 163, 97, 81, 88, 66, 235, 44, 250, 23, 38, 26, 137, 165, 188, 31, 217, 238, 111, 195, 240, 70, 16, 201, 139, 17, 237, 113] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: ntp.org
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [251, 3, 66, 36, 83, 109, 238, 199, 247, 111, 155, 134, 7, 216, 11, 1, 8, 128, 37, 158, 117, 58, 124, 255, 45, 246, 17, 74, 125, 16, 64, 249] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((9, Opaque1Ffff { l: 7, data: [110, 116, 112, 46, 111, 114, 103] }))
+[trace] HostName: Ok((9, Opaque1Ffff { l: 7, data: [110, 116, 112, 46, 111, 114, 103] }))
+[trace] ServerNameName: Ok((9, HostName(Opaque1Ffff { l: 7, data: [110, 116, 112, 46, 111, 114, 103] })))
+[trace] ServerName: Ok((10, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 116, 112, 46, 111, 114, 103] }) }))
+[trace] ServerNameList: Ok((12, ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 116, 112, 46, 111, 114, 103] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((12, ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 116, 112, 46, 111, 114, 103] }) }]) })))
+[trace] ClientHelloExtension: Ok((16, ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 116, 112, 46, 111, 114, 103] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [254, 165, 250, 232, 250, 136, 225, 70, 179, 114, 142, 2, 89, 11, 58, 113, 13, 55, 119, 211, 163, 144, 220, 151, 141, 46, 31, 4, 32, 187, 212, 29] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [254, 165, 250, 232, 250, 136, 225, 70, 179, 114, 142, 2, 89, 11, 58, 113, 13, 55, 119, 211, 163, 144, 220, 151, 141, 46, 31, 4, 32, 187, 212, 29] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [254, 165, 250, 232, 250, 136, 225, 70, 179, 114, 142, 2, 89, 11, 58, 113, 13, 55, 119, 211, 163, 144, 220, 151, 141, 46, 31, 4, 32, 187, 212, 29] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [254, 165, 250, 232, 250, 136, 225, 70, 179, 114, 142, 2, 89, 11, 58, 113, 13, 55, 119, 211, 163, 144, 220, 151, 141, 46, 31, 4, 32, 187, 212, 29] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((224, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((224, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((228, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 116, 112, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [254, 165, 250, 232, 250, 136, 225, 70, 179, 114, 142, 2, 89, 11, 58, 113, 13, 55, 119, 211, 163, 144, 220, 151, 141, 46, 31, 4, 32, 187, 212, 29] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [24, 68, 31, 225, 128, 2, 108, 229, 92, 51, 45, 48, 192, 91, 70, 164, 134, 204, 8, 222, 111, 23, 249, 2, 105, 99, 45, 105, 181, 26, 70, 145], legacy_session_id: SessionId { l: 32, id: [251, 3, 66, 36, 83, 109, 238, 199, 247, 111, 155, 134, 7, 216, 11, 1, 8, 128, 37, 158, 117, 58, 124, 255, 45, 246, 17, 74, 125, 16, 64, 249] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 116, 112, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [254, 165, 250, 232, 250, 136, 225, 70, 179, 114, 142, 2, 89, 11, 58, 113, 13, 55, 119, 211, 163, 144, 220, 151, 141, 46, 31, 4, 32, 187, 212, 29] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [24, 68, 31, 225, 128, 2, 108, 229, 92, 51, 45, 48, 192, 91, 70, 164, 134, 204, 8, 222, 111, 23, 249, 2, 105, 99, 45, 105, 181, 26, 70, 145], legacy_session_id: SessionId { l: 32, id: [251, 3, 66, 36, 83, 109, 238, 199, 247, 111, 155, 134, 7, 216, 11, 1, 8, 128, 37, 158, 117, 58, 124, 255, 45, 246, 17, 74, 125, 16, 64, 249] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 116, 112, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [254, 165, 250, 232, 250, 136, 225, 70, 179, 114, 142, 2, 89, 11, 58, 113, 13, 55, 119, 211, 163, 144, 220, 151, 141, 46, 31, 4, 32, 187, 212, 29] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [24, 68, 31, 225, 128, 2, 108, 229, 92, 51, 45, 48, 192, 91, 70, 164, 134, 204, 8, 222, 111, 23, 249, 2, 105, 99, 45, 105, 181, 26, 70, 145], legacy_session_id: SessionId { l: 32, id: [251, 3, 66, 36, 83, 109, 238, 199, 247, 111, 155, 134, 7, 216, 11, 1, 8, 128, 37, 158, 117, 58, 124, 255, 45, 246, 17, 74, 125, 16, 64, 249] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 116, 112, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [254, 165, 250, 232, 250, 136, 225, 70, 179, 114, 142, 2, 89, 11, 58, 113, 13, 55, 119, 211, 163, 144, 220, 151, 141, 46, 31, 4, 32, 187, 212, 29] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(4104b3920118220c721e7cf879fcc573a33f1aca561e4c554f243d906a4d5a3ac44d1a9d2caecd057f64feaf9ad17f531048478673aaa453988e74758ef7affe35ec) }, encoded: 100000424104b3920118220c721e7cf879fcc573a33f1aca561e4c554f243d906a4d5a3ac44d1a9d2caecd057f64feaf9ad17f531048478673aaa453988e74758ef7affe35ec }
+=====================================
+domain: roblox.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [129, 63, 239, 18, 9, 144, 97, 115, 23, 176, 79, 13, 199, 242, 223, 20, 123, 99, 111, 35, 97, 161, 29, 171, 189, 39, 213, 193, 205, 162, 201, 157] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [114, 111, 98, 108, 111, 120, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [114, 111, 98, 108, 111, 120, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [114, 111, 98, 108, 111, 120, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 111, 98, 108, 111, 120, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 111, 98, 108, 111, 120, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 111, 98, 108, 111, 120, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 111, 98, 108, 111, 120, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [144, 20, 240, 38, 71, 68, 16, 109, 138, 215, 233, 29, 143, 185, 154, 193, 232, 178, 98, 205, 134, 156, 30, 245, 103, 124, 189, 30, 65, 183, 197, 81] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [144, 20, 240, 38, 71, 68, 16, 109, 138, 215, 233, 29, 143, 185, 154, 193, 232, 178, 98, 205, 134, 156, 30, 245, 103, 124, 189, 30, 65, 183, 197, 81] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [144, 20, 240, 38, 71, 68, 16, 109, 138, 215, 233, 29, 143, 185, 154, 193, 232, 178, 98, 205, 134, 156, 30, 245, 103, 124, 189, 30, 65, 183, 197, 81] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [144, 20, 240, 38, 71, 68, 16, 109, 138, 215, 233, 29, 143, 185, 154, 193, 232, 178, 98, 205, 134, 156, 30, 245, 103, 124, 189, 30, 65, 183, 197, 81] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 111, 98, 108, 111, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [144, 20, 240, 38, 71, 68, 16, 109, 138, 215, 233, 29, 143, 185, 154, 193, 232, 178, 98, 205, 134, 156, 30, 245, 103, 124, 189, 30, 65, 183, 197, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [30, 45, 45, 231, 67, 86, 174, 158, 220, 255, 214, 149, 37, 24, 42, 205, 218, 193, 87, 56, 172, 137, 80, 64, 93, 163, 25, 145, 73, 174, 130, 57], legacy_session_id: SessionId { l: 32, id: [129, 63, 239, 18, 9, 144, 97, 115, 23, 176, 79, 13, 199, 242, 223, 20, 123, 99, 111, 35, 97, 161, 29, 171, 189, 39, 213, 193, 205, 162, 201, 157] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 111, 98, 108, 111, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [144, 20, 240, 38, 71, 68, 16, 109, 138, 215, 233, 29, 143, 185, 154, 193, 232, 178, 98, 205, 134, 156, 30, 245, 103, 124, 189, 30, 65, 183, 197, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [30, 45, 45, 231, 67, 86, 174, 158, 220, 255, 214, 149, 37, 24, 42, 205, 218, 193, 87, 56, 172, 137, 80, 64, 93, 163, 25, 145, 73, 174, 130, 57], legacy_session_id: SessionId { l: 32, id: [129, 63, 239, 18, 9, 144, 97, 115, 23, 176, 79, 13, 199, 242, 223, 20, 123, 99, 111, 35, 97, 161, 29, 171, 189, 39, 213, 193, 205, 162, 201, 157] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 111, 98, 108, 111, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [144, 20, 240, 38, 71, 68, 16, 109, 138, 215, 233, 29, 143, 185, 154, 193, 232, 178, 98, 205, 134, 156, 30, 245, 103, 124, 189, 30, 65, 183, 197, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [30, 45, 45, 231, 67, 86, 174, 158, 220, 255, 214, 149, 37, 24, 42, 205, 218, 193, 87, 56, 172, 137, 80, 64, 93, 163, 25, 145, 73, 174, 130, 57], legacy_session_id: SessionId { l: 32, id: [129, 63, 239, 18, 9, 144, 97, 115, 23, 176, 79, 13, 199, 242, 223, 20, 123, 99, 111, 35, 97, 161, 29, 171, 189, 39, 213, 193, 205, 162, 201, 157] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 111, 98, 108, 111, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [144, 20, 240, 38, 71, 68, 16, 109, 138, 215, 233, 29, 143, 185, 154, 193, 232, 178, 98, 205, 134, 156, 30, 245, 103, 124, 189, 30, 65, 183, 197, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: msn.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [196, 1, 32, 229, 175, 151, 106, 243, 45, 145, 96, 249, 55, 103, 253, 152, 189, 189, 52, 246, 227, 98, 53, 227, 32, 70, 138, 173, 134, 76, 165, 147] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((9, Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }))
+[trace] HostName: Ok((9, Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((9, HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((10, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((12, ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((12, ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((16, ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [11, 138, 8, 113, 101, 120, 62, 132, 8, 10, 52, 247, 144, 178, 89, 172, 147, 34, 23, 224, 229, 227, 137, 5, 214, 116, 209, 37, 169, 223, 236, 54] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [11, 138, 8, 113, 101, 120, 62, 132, 8, 10, 52, 247, 144, 178, 89, 172, 147, 34, 23, 224, 229, 227, 137, 5, 214, 116, 209, 37, 169, 223, 236, 54] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [11, 138, 8, 113, 101, 120, 62, 132, 8, 10, 52, 247, 144, 178, 89, 172, 147, 34, 23, 224, 229, 227, 137, 5, 214, 116, 209, 37, 169, 223, 236, 54] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [11, 138, 8, 113, 101, 120, 62, 132, 8, 10, 52, 247, 144, 178, 89, 172, 147, 34, 23, 224, 229, 227, 137, 5, 214, 116, 209, 37, 169, 223, 236, 54] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((224, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((224, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((228, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [11, 138, 8, 113, 101, 120, 62, 132, 8, 10, 52, 247, 144, 178, 89, 172, 147, 34, 23, 224, 229, 227, 137, 5, 214, 116, 209, 37, 169, 223, 236, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [58, 101, 129, 138, 79, 64, 121, 77, 206, 155, 13, 14, 242, 203, 15, 141, 67, 86, 170, 148, 56, 11, 111, 126, 72, 221, 121, 78, 193, 79, 238, 53], legacy_session_id: SessionId { l: 32, id: [196, 1, 32, 229, 175, 151, 106, 243, 45, 145, 96, 249, 55, 103, 253, 152, 189, 189, 52, 246, 227, 98, 53, 227, 32, 70, 138, 173, 134, 76, 165, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [11, 138, 8, 113, 101, 120, 62, 132, 8, 10, 52, 247, 144, 178, 89, 172, 147, 34, 23, 224, 229, 227, 137, 5, 214, 116, 209, 37, 169, 223, 236, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [58, 101, 129, 138, 79, 64, 121, 77, 206, 155, 13, 14, 242, 203, 15, 141, 67, 86, 170, 148, 56, 11, 111, 126, 72, 221, 121, 78, 193, 79, 238, 53], legacy_session_id: SessionId { l: 32, id: [196, 1, 32, 229, 175, 151, 106, 243, 45, 145, 96, 249, 55, 103, 253, 152, 189, 189, 52, 246, 227, 98, 53, 227, 32, 70, 138, 173, 134, 76, 165, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [11, 138, 8, 113, 101, 120, 62, 132, 8, 10, 52, 247, 144, 178, 89, 172, 147, 34, 23, 224, 229, 227, 137, 5, 214, 116, 209, 37, 169, 223, 236, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [58, 101, 129, 138, 79, 64, 121, 77, 206, 155, 13, 14, 242, 203, 15, 141, 67, 86, 170, 148, 56, 11, 111, 126, 72, 221, 121, 78, 193, 79, 238, 53], legacy_session_id: SessionId { l: 32, id: [196, 1, 32, 229, 175, 151, 106, 243, 45, 145, 96, 249, 55, 103, 253, 152, 189, 189, 52, 246, 227, 98, 53, 227, 32, 70, 138, 173, 134, 76, 165, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [11, 138, 8, 113, 101, 120, 62, 132, 8, 10, 52, 247, 144, 178, 89, 172, 147, 34, 23, 224, 229, 227, 137, 5, 214, 116, 209, 37, 169, 223, 236, 54] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [196, 1, 32, 229, 175, 151, 106, 243, 45, 145, 96, 249, 55, 103, 253, 152, 189, 189, 52, 246, 227, 98, 53, 227, 32, 70, 138, 173, 134, 76, 165, 147] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((9, Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }))
+[trace] HostName: Ok((9, Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((9, HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((10, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((12, ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((12, ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((16, ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 25))
+[trace] KeyShareEntry: Ok((137, KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 203, 145, 139, 177, 43, 75, 205, 194, 3, 190, 156, 255, 186, 242, 173, 69, 183, 85, 93, 217, 78, 240, 66, 234, 52, 116, 151, 84, 215, 145, 0, 56, 107, 28, 144, 127, 199, 62, 240, 151, 141, 211, 80, 198, 242, 221, 230, 63, 183, 185, 8, 206, 31, 71, 88, 165, 180, 174, 184, 254, 169, 105, 160, 3, 238, 1, 201, 37, 102, 83, 12, 243, 143, 233, 242, 172, 125, 247, 38, 161, 137, 252, 207, 52, 80, 48, 119, 119, 167, 149, 251, 99, 20, 179, 221, 19, 48, 241, 101, 179, 38, 9, 63, 85, 146, 122, 207, 194, 217, 32, 103, 218, 74, 45, 159, 148, 45, 64, 125, 82, 4, 11, 51, 48, 67, 161, 219, 83, 207, 225, 129] }))
+[trace] KeyShareClientHello: Ok((139, KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 203, 145, 139, 177, 43, 75, 205, 194, 3, 190, 156, 255, 186, 242, 173, 69, 183, 85, 93, 217, 78, 240, 66, 234, 52, 116, 151, 84, 215, 145, 0, 56, 107, 28, 144, 127, 199, 62, 240, 151, 141, 211, 80, 198, 242, 221, 230, 63, 183, 185, 8, 206, 31, 71, 88, 165, 180, 174, 184, 254, 169, 105, 160, 3, 238, 1, 201, 37, 102, 83, 12, 243, 143, 233, 242, 172, 125, 247, 38, 161, 137, 252, 207, 52, 80, 48, 119, 119, 167, 149, 251, 99, 20, 179, 221, 19, 48, 241, 101, 179, 38, 9, 63, 85, 146, 122, 207, 194, 217, 32, 103, 218, 74, 45, 159, 148, 45, 64, 125, 82, 4, 11, 51, 48, 67, 161, 219, 83, 207, 225, 129] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((139, KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 203, 145, 139, 177, 43, 75, 205, 194, 3, 190, 156, 255, 186, 242, 173, 69, 183, 85, 93, 217, 78, 240, 66, 234, 52, 116, 151, 84, 215, 145, 0, 56, 107, 28, 144, 127, 199, 62, 240, 151, 141, 211, 80, 198, 242, 221, 230, 63, 183, 185, 8, 206, 31, 71, 88, 165, 180, 174, 184, 254, 169, 105, 160, 3, 238, 1, 201, 37, 102, 83, 12, 243, 143, 233, 242, 172, 125, 247, 38, 161, 137, 252, 207, 52, 80, 48, 119, 119, 167, 149, 251, 99, 20, 179, 221, 19, 48, 241, 101, 179, 38, 9, 63, 85, 146, 122, 207, 194, 217, 32, 103, 218, 74, 45, 159, 148, 45, 64, 125, 82, 4, 11, 51, 48, 67, 161, 219, 83, 207, 225, 129] }]) })))
+[trace] ClientHelloExtension: Ok((143, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 203, 145, 139, 177, 43, 75, 205, 194, 3, 190, 156, 255, 186, 242, 173, 69, 183, 85, 93, 217, 78, 240, 66, 234, 52, 116, 151, 84, 215, 145, 0, 56, 107, 28, 144, 127, 199, 62, 240, 151, 141, 211, 80, 198, 242, 221, 230, 63, 183, 185, 8, 206, 31, 71, 88, 165, 180, 174, 184, 254, 169, 105, 160, 3, 238, 1, 201, 37, 102, 83, 12, 243, 143, 233, 242, 172, 125, 247, 38, 161, 137, 252, 207, 52, 80, 48, 119, 119, 167, 149, 251, 99, 20, 179, 221, 19, 48, 241, 101, 179, 38, 9, 63, 85, 146, 122, 207, 194, 217, 32, 103, 218, 74, 45, 159, 148, 45, 64, 125, 82, 4, 11, 51, 48, 67, 161, 219, 83, 207, 225, 129] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((123, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((123, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((127, ClientHelloExtension { extension_type: 21, ext_len: 123, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 203, 145, 139, 177, 43, 75, 205, 194, 3, 190, 156, 255, 186, 242, 173, 69, 183, 85, 93, 217, 78, 240, 66, 234, 52, 116, 151, 84, 215, 145, 0, 56, 107, 28, 144, 127, 199, 62, 240, 151, 141, 211, 80, 198, 242, 221, 230, 63, 183, 185, 8, 206, 31, 71, 88, 165, 180, 174, 184, 254, 169, 105, 160, 3, 238, 1, 201, 37, 102, 83, 12, 243, 143, 233, 242, 172, 125, 247, 38, 161, 137, 252, 207, 52, 80, 48, 119, 119, 167, 149, 251, 99, 20, 179, 221, 19, 48, 241, 101, 179, 38, 9, 63, 85, 146, 122, 207, 194, 217, 32, 103, 218, 74, 45, 159, 148, 45, 64, 125, 82, 4, 11, 51, 48, 67, 161, 219, 83, 207, 225, 129] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 123, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [58, 101, 129, 138, 79, 64, 121, 77, 206, 155, 13, 14, 242, 203, 15, 141, 67, 86, 170, 148, 56, 11, 111, 126, 72, 221, 121, 78, 193, 79, 238, 53], legacy_session_id: SessionId { l: 32, id: [196, 1, 32, 229, 175, 151, 106, 243, 45, 145, 96, 249, 55, 103, 253, 152, 189, 189, 52, 246, 227, 98, 53, 227, 32, 70, 138, 173, 134, 76, 165, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 203, 145, 139, 177, 43, 75, 205, 194, 3, 190, 156, 255, 186, 242, 173, 69, 183, 85, 93, 217, 78, 240, 66, 234, 52, 116, 151, 84, 215, 145, 0, 56, 107, 28, 144, 127, 199, 62, 240, 151, 141, 211, 80, 198, 242, 221, 230, 63, 183, 185, 8, 206, 31, 71, 88, 165, 180, 174, 184, 254, 169, 105, 160, 3, 238, 1, 201, 37, 102, 83, 12, 243, 143, 233, 242, 172, 125, 247, 38, 161, 137, 252, 207, 52, 80, 48, 119, 119, 167, 149, 251, 99, 20, 179, 221, 19, 48, 241, 101, 179, 38, 9, 63, 85, 146, 122, 207, 194, 217, 32, 103, 218, 74, 45, 159, 148, 45, 64, 125, 82, 4, 11, 51, 48, 67, 161, 219, 83, 207, 225, 129] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 123, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [58, 101, 129, 138, 79, 64, 121, 77, 206, 155, 13, 14, 242, 203, 15, 141, 67, 86, 170, 148, 56, 11, 111, 126, 72, 221, 121, 78, 193, 79, 238, 53], legacy_session_id: SessionId { l: 32, id: [196, 1, 32, 229, 175, 151, 106, 243, 45, 145, 96, 249, 55, 103, 253, 152, 189, 189, 52, 246, 227, 98, 53, 227, 32, 70, 138, 173, 134, 76, 165, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 203, 145, 139, 177, 43, 75, 205, 194, 3, 190, 156, 255, 186, 242, 173, 69, 183, 85, 93, 217, 78, 240, 66, 234, 52, 116, 151, 84, 215, 145, 0, 56, 107, 28, 144, 127, 199, 62, 240, 151, 141, 211, 80, 198, 242, 221, 230, 63, 183, 185, 8, 206, 31, 71, 88, 165, 180, 174, 184, 254, 169, 105, 160, 3, 238, 1, 201, 37, 102, 83, 12, 243, 143, 233, 242, 172, 125, 247, 38, 161, 137, 252, 207, 52, 80, 48, 119, 119, 167, 149, 251, 99, 20, 179, 221, 19, 48, 241, 101, 179, 38, 9, 63, 85, 146, 122, 207, 194, 217, 32, 103, 218, 74, 45, 159, 148, 45, 64, 125, 82, 4, 11, 51, 48, 67, 161, 219, 83, 207, 225, 129] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 123, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [58, 101, 129, 138, 79, 64, 121, 77, 206, 155, 13, 14, 242, 203, 15, 141, 67, 86, 170, 148, 56, 11, 111, 126, 72, 221, 121, 78, 193, 79, 238, 53], legacy_session_id: SessionId { l: 32, id: [196, 1, 32, 229, 175, 151, 106, 243, 45, 145, 96, 249, 55, 103, 253, 152, 189, 189, 52, 246, 227, 98, 53, 227, 32, 70, 138, 173, 134, 76, 165, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [109, 115, 110, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 203, 145, 139, 177, 43, 75, 205, 194, 3, 190, 156, 255, 186, 242, 173, 69, 183, 85, 93, 217, 78, 240, 66, 234, 52, 116, 151, 84, 215, 145, 0, 56, 107, 28, 144, 127, 199, 62, 240, 151, 141, 211, 80, 198, 242, 221, 230, 63, 183, 185, 8, 206, 31, 71, 88, 165, 180, 174, 184, 254, 169, 105, 160, 3, 238, 1, 201, 37, 102, 83, 12, 243, 143, 233, 242, 172, 125, 247, 38, 161, 137, 252, 207, 52, 80, 48, 119, 119, 167, 149, 251, 99, 20, 179, 221, 19, 48, 241, 101, 179, 38, 9, 63, 85, 146, 122, 207, 194, 217, 32, 103, 218, 74, 45, 159, 148, 45, 64, 125, 82, 4, 11, 51, 48, 67, 161, 219, 83, 207, 225, 129] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 123, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: bit.ly
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [119, 108, 200, 43, 145, 207, 137, 204, 167, 233, 193, 39, 229, 137, 215, 208, 100, 219, 26, 39, 205, 210, 226, 146, 203, 9, 42, 0, 207, 227, 184, 38] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((8, Opaque1Ffff { l: 6, data: [98, 105, 116, 46, 108, 121] }))
+[trace] HostName: Ok((8, Opaque1Ffff { l: 6, data: [98, 105, 116, 46, 108, 121] }))
+[trace] ServerNameName: Ok((8, HostName(Opaque1Ffff { l: 6, data: [98, 105, 116, 46, 108, 121] })))
+[trace] ServerName: Ok((9, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [98, 105, 116, 46, 108, 121] }) }))
+[trace] ServerNameList: Ok((11, ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [98, 105, 116, 46, 108, 121] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((11, ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [98, 105, 116, 46, 108, 121] }) }]) })))
+[trace] ClientHelloExtension: Ok((15, ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [98, 105, 116, 46, 108, 121] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [179, 3, 90, 253, 165, 133, 3, 220, 167, 152, 165, 108, 221, 163, 172, 208, 21, 89, 169, 200, 156, 89, 163, 10, 157, 28, 207, 209, 28, 215, 206, 87] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 3, 90, 253, 165, 133, 3, 220, 167, 152, 165, 108, 221, 163, 172, 208, 21, 89, 169, 200, 156, 89, 163, 10, 157, 28, 207, 209, 28, 215, 206, 87] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 3, 90, 253, 165, 133, 3, 220, 167, 152, 165, 108, 221, 163, 172, 208, 21, 89, 169, 200, 156, 89, 163, 10, 157, 28, 207, 209, 28, 215, 206, 87] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 3, 90, 253, 165, 133, 3, 220, 167, 152, 165, 108, 221, 163, 172, 208, 21, 89, 169, 200, 156, 89, 163, 10, 157, 28, 207, 209, 28, 215, 206, 87] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((225, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((225, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((229, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [98, 105, 116, 46, 108, 121] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 3, 90, 253, 165, 133, 3, 220, 167, 152, 165, 108, 221, 163, 172, 208, 21, 89, 169, 200, 156, 89, 163, 10, 157, 28, 207, 209, 28, 215, 206, 87] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [179, 66, 64, 132, 94, 109, 232, 241, 111, 172, 100, 131, 195, 132, 175, 90, 189, 7, 220, 112, 86, 184, 189, 207, 96, 234, 118, 234, 241, 212, 41, 144], legacy_session_id: SessionId { l: 32, id: [119, 108, 200, 43, 145, 207, 137, 204, 167, 233, 193, 39, 229, 137, 215, 208, 100, 219, 26, 39, 205, 210, 226, 146, 203, 9, 42, 0, 207, 227, 184, 38] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [98, 105, 116, 46, 108, 121] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 3, 90, 253, 165, 133, 3, 220, 167, 152, 165, 108, 221, 163, 172, 208, 21, 89, 169, 200, 156, 89, 163, 10, 157, 28, 207, 209, 28, 215, 206, 87] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [179, 66, 64, 132, 94, 109, 232, 241, 111, 172, 100, 131, 195, 132, 175, 90, 189, 7, 220, 112, 86, 184, 189, 207, 96, 234, 118, 234, 241, 212, 41, 144], legacy_session_id: SessionId { l: 32, id: [119, 108, 200, 43, 145, 207, 137, 204, 167, 233, 193, 39, 229, 137, 215, 208, 100, 219, 26, 39, 205, 210, 226, 146, 203, 9, 42, 0, 207, 227, 184, 38] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [98, 105, 116, 46, 108, 121] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 3, 90, 253, 165, 133, 3, 220, 167, 152, 165, 108, 221, 163, 172, 208, 21, 89, 169, 200, 156, 89, 163, 10, 157, 28, 207, 209, 28, 215, 206, 87] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [179, 66, 64, 132, 94, 109, 232, 241, 111, 172, 100, 131, 195, 132, 175, 90, 189, 7, 220, 112, 86, 184, 189, 207, 96, 234, 118, 234, 241, 212, 41, 144], legacy_session_id: SessionId { l: 32, id: [119, 108, 200, 43, 145, 207, 137, 204, 167, 233, 193, 39, 229, 137, 215, 208, 100, 219, 26, 39, 205, 210, 226, 146, 203, 9, 42, 0, 207, 227, 184, 38] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [98, 105, 116, 46, 108, 121] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [179, 3, 90, 253, 165, 133, 3, 220, 167, 152, 165, 108, 221, 163, 172, 208, 21, 89, 169, 200, 156, 89, 163, 10, 157, 28, 207, 209, 28, 215, 206, 87] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: nic.ru
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [111, 34, 60, 151, 184, 2, 146, 124, 221, 32, 210, 51, 13, 186, 176, 169, 142, 20, 238, 71, 131, 132, 154, 57, 217, 77, 225, 218, 142, 182, 196, 123] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((8, Opaque1Ffff { l: 6, data: [110, 105, 99, 46, 114, 117] }))
+[trace] HostName: Ok((8, Opaque1Ffff { l: 6, data: [110, 105, 99, 46, 114, 117] }))
+[trace] ServerNameName: Ok((8, HostName(Opaque1Ffff { l: 6, data: [110, 105, 99, 46, 114, 117] })))
+[trace] ServerName: Ok((9, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [110, 105, 99, 46, 114, 117] }) }))
+[trace] ServerNameList: Ok((11, ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [110, 105, 99, 46, 114, 117] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((11, ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [110, 105, 99, 46, 114, 117] }) }]) })))
+[trace] ClientHelloExtension: Ok((15, ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [110, 105, 99, 46, 114, 117] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [37, 38, 133, 30, 121, 236, 161, 104, 151, 151, 53, 112, 189, 228, 234, 156, 8, 58, 166, 45, 235, 249, 184, 214, 199, 251, 52, 68, 230, 113, 18, 98] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 38, 133, 30, 121, 236, 161, 104, 151, 151, 53, 112, 189, 228, 234, 156, 8, 58, 166, 45, 235, 249, 184, 214, 199, 251, 52, 68, 230, 113, 18, 98] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 38, 133, 30, 121, 236, 161, 104, 151, 151, 53, 112, 189, 228, 234, 156, 8, 58, 166, 45, 235, 249, 184, 214, 199, 251, 52, 68, 230, 113, 18, 98] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 38, 133, 30, 121, 236, 161, 104, 151, 151, 53, 112, 189, 228, 234, 156, 8, 58, 166, 45, 235, 249, 184, 214, 199, 251, 52, 68, 230, 113, 18, 98] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((225, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((225, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((229, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [110, 105, 99, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 38, 133, 30, 121, 236, 161, 104, 151, 151, 53, 112, 189, 228, 234, 156, 8, 58, 166, 45, 235, 249, 184, 214, 199, 251, 52, 68, 230, 113, 18, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [195, 71, 69, 252, 5, 203, 77, 13, 109, 65, 219, 34, 213, 140, 58, 148, 250, 124, 58, 164, 189, 153, 66, 75, 80, 117, 162, 32, 31, 141, 246, 172], legacy_session_id: SessionId { l: 32, id: [111, 34, 60, 151, 184, 2, 146, 124, 221, 32, 210, 51, 13, 186, 176, 169, 142, 20, 238, 71, 131, 132, 154, 57, 217, 77, 225, 218, 142, 182, 196, 123] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [110, 105, 99, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 38, 133, 30, 121, 236, 161, 104, 151, 151, 53, 112, 189, 228, 234, 156, 8, 58, 166, 45, 235, 249, 184, 214, 199, 251, 52, 68, 230, 113, 18, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [195, 71, 69, 252, 5, 203, 77, 13, 109, 65, 219, 34, 213, 140, 58, 148, 250, 124, 58, 164, 189, 153, 66, 75, 80, 117, 162, 32, 31, 141, 246, 172], legacy_session_id: SessionId { l: 32, id: [111, 34, 60, 151, 184, 2, 146, 124, 221, 32, 210, 51, 13, 186, 176, 169, 142, 20, 238, 71, 131, 132, 154, 57, 217, 77, 225, 218, 142, 182, 196, 123] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [110, 105, 99, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 38, 133, 30, 121, 236, 161, 104, 151, 151, 53, 112, 189, 228, 234, 156, 8, 58, 166, 45, 235, 249, 184, 214, 199, 251, 52, 68, 230, 113, 18, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [195, 71, 69, 252, 5, 203, 77, 13, 109, 65, 219, 34, 213, 140, 58, 148, 250, 124, 58, 164, 189, 153, 66, 75, 80, 117, 162, 32, 31, 141, 246, 172], legacy_session_id: SessionId { l: 32, id: [111, 34, 60, 151, 184, 2, 146, 124, 221, 32, 210, 51, 13, 186, 176, 169, 142, 20, 238, 71, 131, 132, 154, 57, 217, 77, 225, 218, 142, 182, 196, 123] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [110, 105, 99, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 38, 133, 30, 121, 236, 161, 104, 151, 151, 53, 112, 189, 228, 234, 156, 8, 58, 166, 45, 235, 249, 184, 214, 199, 251, 52, 68, 230, 113, 18, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: cloudflare.net
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [32, 50, 255, 4, 214, 16, 195, 88, 194, 129, 183, 80, 183, 68, 179, 85, 78, 169, 163, 231, 224, 141, 248, 204, 81, 213, 143, 224, 60, 195, 209, 106] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((16, Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 110, 101, 116] }))
+[trace] HostName: Ok((16, Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 110, 101, 116] }))
+[trace] ServerNameName: Ok((16, HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 110, 101, 116] })))
+[trace] ServerName: Ok((17, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 110, 101, 116] }) }))
+[trace] ServerNameList: Ok((19, ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 110, 101, 116] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((19, ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 110, 101, 116] }) }]) })))
+[trace] ClientHelloExtension: Ok((23, ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 110, 101, 116] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [16, 26, 64, 95, 161, 227, 6, 185, 76, 161, 140, 167, 2, 119, 74, 34, 77, 167, 218, 38, 66, 254, 179, 24, 141, 238, 60, 150, 23, 224, 229, 23] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 26, 64, 95, 161, 227, 6, 185, 76, 161, 140, 167, 2, 119, 74, 34, 77, 167, 218, 38, 66, 254, 179, 24, 141, 238, 60, 150, 23, 224, 229, 23] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 26, 64, 95, 161, 227, 6, 185, 76, 161, 140, 167, 2, 119, 74, 34, 77, 167, 218, 38, 66, 254, 179, 24, 141, 238, 60, 150, 23, 224, 229, 23] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 26, 64, 95, 161, 227, 6, 185, 76, 161, 140, 167, 2, 119, 74, 34, 77, 167, 218, 38, 66, 254, 179, 24, 141, 238, 60, 150, 23, 224, 229, 23] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((217, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((217, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((221, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 26, 64, 95, 161, 227, 6, 185, 76, 161, 140, 167, 2, 119, 74, 34, 77, 167, 218, 38, 66, 254, 179, 24, 141, 238, 60, 150, 23, 224, 229, 23] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [12, 233, 65, 205, 46, 13, 204, 154, 208, 230, 249, 135, 172, 249, 61, 211, 39, 233, 66, 28, 118, 245, 238, 248, 6, 203, 117, 76, 22, 129, 144, 40], legacy_session_id: SessionId { l: 32, id: [32, 50, 255, 4, 214, 16, 195, 88, 194, 129, 183, 80, 183, 68, 179, 85, 78, 169, 163, 231, 224, 141, 248, 204, 81, 213, 143, 224, 60, 195, 209, 106] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 26, 64, 95, 161, 227, 6, 185, 76, 161, 140, 167, 2, 119, 74, 34, 77, 167, 218, 38, 66, 254, 179, 24, 141, 238, 60, 150, 23, 224, 229, 23] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [12, 233, 65, 205, 46, 13, 204, 154, 208, 230, 249, 135, 172, 249, 61, 211, 39, 233, 66, 28, 118, 245, 238, 248, 6, 203, 117, 76, 22, 129, 144, 40], legacy_session_id: SessionId { l: 32, id: [32, 50, 255, 4, 214, 16, 195, 88, 194, 129, 183, 80, 183, 68, 179, 85, 78, 169, 163, 231, 224, 141, 248, 204, 81, 213, 143, 224, 60, 195, 209, 106] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 26, 64, 95, 161, 227, 6, 185, 76, 161, 140, 167, 2, 119, 74, 34, 77, 167, 218, 38, 66, 254, 179, 24, 141, 238, 60, 150, 23, 224, 229, 23] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [12, 233, 65, 205, 46, 13, 204, 154, 208, 230, 249, 135, 172, 249, 61, 211, 39, 233, 66, 28, 118, 245, 238, 248, 6, 203, 117, 76, 22, 129, 144, 40], legacy_session_id: SessionId { l: 32, id: [32, 50, 255, 4, 214, 16, 195, 88, 194, 129, 183, 80, 183, 68, 179, 85, 78, 169, 163, 231, 224, 141, 248, 204, 81, 213, 143, 224, 60, 195, 209, 106] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 19, extension_data: ServerName(ServerNameList { l: 17, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 14, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 26, 64, 95, 161, 227, 6, 185, 76, 161, 140, 167, 2, 119, 74, 34, 77, 167, 218, 38, 66, 254, 179, 24, 141, 238, 60, 150, 23, 224, 229, 23] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 217, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: tiktok.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [41, 41, 250, 203, 166, 240, 13, 137, 116, 207, 189, 181, 100, 129, 105, 109, 147, 33, 16, 182, 132, 11, 71, 115, 9, 148, 203, 28, 80, 39, 229, 82] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [116, 105, 107, 116, 111, 107, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [116, 105, 107, 116, 111, 107, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [116, 105, 107, 116, 111, 107, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 105, 107, 116, 111, 107, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 105, 107, 116, 111, 107, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 105, 107, 116, 111, 107, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 105, 107, 116, 111, 107, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [90, 149, 253, 175, 234, 103, 32, 165, 206, 240, 20, 71, 153, 223, 238, 103, 17, 162, 242, 93, 59, 216, 165, 84, 92, 121, 155, 104, 73, 137, 250, 120] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 149, 253, 175, 234, 103, 32, 165, 206, 240, 20, 71, 153, 223, 238, 103, 17, 162, 242, 93, 59, 216, 165, 84, 92, 121, 155, 104, 73, 137, 250, 120] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 149, 253, 175, 234, 103, 32, 165, 206, 240, 20, 71, 153, 223, 238, 103, 17, 162, 242, 93, 59, 216, 165, 84, 92, 121, 155, 104, 73, 137, 250, 120] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 149, 253, 175, 234, 103, 32, 165, 206, 240, 20, 71, 153, 223, 238, 103, 17, 162, 242, 93, 59, 216, 165, 84, 92, 121, 155, 104, 73, 137, 250, 120] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 105, 107, 116, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 149, 253, 175, 234, 103, 32, 165, 206, 240, 20, 71, 153, 223, 238, 103, 17, 162, 242, 93, 59, 216, 165, 84, 92, 121, 155, 104, 73, 137, 250, 120] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [75, 231, 138, 104, 95, 179, 205, 159, 60, 97, 113, 249, 130, 121, 186, 37, 217, 248, 126, 140, 9, 33, 128, 120, 0, 71, 4, 250, 36, 0, 56, 0], legacy_session_id: SessionId { l: 32, id: [41, 41, 250, 203, 166, 240, 13, 137, 116, 207, 189, 181, 100, 129, 105, 109, 147, 33, 16, 182, 132, 11, 71, 115, 9, 148, 203, 28, 80, 39, 229, 82] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 105, 107, 116, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 149, 253, 175, 234, 103, 32, 165, 206, 240, 20, 71, 153, 223, 238, 103, 17, 162, 242, 93, 59, 216, 165, 84, 92, 121, 155, 104, 73, 137, 250, 120] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [75, 231, 138, 104, 95, 179, 205, 159, 60, 97, 113, 249, 130, 121, 186, 37, 217, 248, 126, 140, 9, 33, 128, 120, 0, 71, 4, 250, 36, 0, 56, 0], legacy_session_id: SessionId { l: 32, id: [41, 41, 250, 203, 166, 240, 13, 137, 116, 207, 189, 181, 100, 129, 105, 109, 147, 33, 16, 182, 132, 11, 71, 115, 9, 148, 203, 28, 80, 39, 229, 82] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 105, 107, 116, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 149, 253, 175, 234, 103, 32, 165, 206, 240, 20, 71, 153, 223, 238, 103, 17, 162, 242, 93, 59, 216, 165, 84, 92, 121, 155, 104, 73, 137, 250, 120] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [75, 231, 138, 104, 95, 179, 205, 159, 60, 97, 113, 249, 130, 121, 186, 37, 217, 248, 126, 140, 9, 33, 128, 120, 0, 71, 4, 250, 36, 0, 56, 0], legacy_session_id: SessionId { l: 32, id: [41, 41, 250, 203, 166, 240, 13, 137, 116, 207, 189, 181, 100, 129, 105, 109, 147, 33, 16, 182, 132, 11, 71, 115, 9, 148, 203, 28, 80, 39, 229, 82] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 105, 107, 116, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 149, 253, 175, 234, 103, 32, 165, 206, 240, 20, 71, 153, 223, 238, 103, 17, 162, 242, 93, 59, 216, 165, 84, 92, 121, 155, 104, 73, 137, 250, 120] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: wordpress.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [0, 125, 47, 4, 49, 188, 64, 76, 61, 253, 39, 229, 41, 151, 68, 220, 130, 66, 66, 90, 102, 20, 0, 36, 236, 26, 161, 13, 226, 82, 50, 120] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((15, Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 99, 111, 109] }))
+[trace] HostName: Ok((15, Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((15, HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((16, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((18, ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((18, ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((22, ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [154, 185, 242, 24, 97, 148, 194, 205, 117, 18, 214, 182, 99, 206, 14, 255, 1, 90, 76, 139, 38, 117, 204, 42, 19, 129, 252, 209, 204, 98, 70, 114] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [154, 185, 242, 24, 97, 148, 194, 205, 117, 18, 214, 182, 99, 206, 14, 255, 1, 90, 76, 139, 38, 117, 204, 42, 19, 129, 252, 209, 204, 98, 70, 114] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [154, 185, 242, 24, 97, 148, 194, 205, 117, 18, 214, 182, 99, 206, 14, 255, 1, 90, 76, 139, 38, 117, 204, 42, 19, 129, 252, 209, 204, 98, 70, 114] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [154, 185, 242, 24, 97, 148, 194, 205, 117, 18, 214, 182, 99, 206, 14, 255, 1, 90, 76, 139, 38, 117, 204, 42, 19, 129, 252, 209, 204, 98, 70, 114] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((218, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((218, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((222, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [154, 185, 242, 24, 97, 148, 194, 205, 117, 18, 214, 182, 99, 206, 14, 255, 1, 90, 76, 139, 38, 117, 204, 42, 19, 129, 252, 209, 204, 98, 70, 114] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [60, 214, 238, 234, 150, 210, 228, 222, 53, 133, 3, 137, 224, 27, 75, 155, 151, 92, 235, 53, 175, 34, 243, 140, 107, 41, 130, 141, 74, 152, 28, 79], legacy_session_id: SessionId { l: 32, id: [0, 125, 47, 4, 49, 188, 64, 76, 61, 253, 39, 229, 41, 151, 68, 220, 130, 66, 66, 90, 102, 20, 0, 36, 236, 26, 161, 13, 226, 82, 50, 120] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [154, 185, 242, 24, 97, 148, 194, 205, 117, 18, 214, 182, 99, 206, 14, 255, 1, 90, 76, 139, 38, 117, 204, 42, 19, 129, 252, 209, 204, 98, 70, 114] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [60, 214, 238, 234, 150, 210, 228, 222, 53, 133, 3, 137, 224, 27, 75, 155, 151, 92, 235, 53, 175, 34, 243, 140, 107, 41, 130, 141, 74, 152, 28, 79], legacy_session_id: SessionId { l: 32, id: [0, 125, 47, 4, 49, 188, 64, 76, 61, 253, 39, 229, 41, 151, 68, 220, 130, 66, 66, 90, 102, 20, 0, 36, 236, 26, 161, 13, 226, 82, 50, 120] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [154, 185, 242, 24, 97, 148, 194, 205, 117, 18, 214, 182, 99, 206, 14, 255, 1, 90, 76, 139, 38, 117, 204, 42, 19, 129, 252, 209, 204, 98, 70, 114] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [60, 214, 238, 234, 150, 210, 228, 222, 53, 133, 3, 137, 224, 27, 75, 155, 151, 92, 235, 53, 175, 34, 243, 140, 107, 41, 130, 141, 74, 152, 28, 79], legacy_session_id: SessionId { l: 32, id: [0, 125, 47, 4, 49, 188, 64, 76, 61, 253, 39, 229, 41, 151, 68, 220, 130, 66, 66, 90, 102, 20, 0, 36, 236, 26, 161, 13, 226, 82, 50, 120] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [119, 111, 114, 100, 112, 114, 101, 115, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [154, 185, 242, 24, 97, 148, 194, 205, 117, 18, 214, 182, 99, 206, 14, 255, 1, 90, 76, 139, 38, 117, 204, 42, 19, 129, 252, 209, 204, 98, 70, 114] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: yandex.net
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [5, 181, 8, 194, 23, 236, 11, 246, 58, 152, 233, 210, 68, 92, 238, 80, 212, 228, 244, 229, 246, 161, 9, 26, 42, 140, 252, 191, 96, 141, 143, 216] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [121, 97, 110, 100, 101, 120, 46, 110, 101, 116] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [121, 97, 110, 100, 101, 120, 46, 110, 101, 116] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [121, 97, 110, 100, 101, 120, 46, 110, 101, 116] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [121, 97, 110, 100, 101, 120, 46, 110, 101, 116] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [121, 97, 110, 100, 101, 120, 46, 110, 101, 116] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [121, 97, 110, 100, 101, 120, 46, 110, 101, 116] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [121, 97, 110, 100, 101, 120, 46, 110, 101, 116] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [181, 32, 101, 11, 124, 20, 58, 116, 134, 112, 250, 170, 227, 118, 57, 115, 93, 89, 245, 29, 207, 65, 97, 128, 135, 16, 3, 217, 196, 117, 27, 105] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 32, 101, 11, 124, 20, 58, 116, 134, 112, 250, 170, 227, 118, 57, 115, 93, 89, 245, 29, 207, 65, 97, 128, 135, 16, 3, 217, 196, 117, 27, 105] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 32, 101, 11, 124, 20, 58, 116, 134, 112, 250, 170, 227, 118, 57, 115, 93, 89, 245, 29, 207, 65, 97, 128, 135, 16, 3, 217, 196, 117, 27, 105] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 32, 101, 11, 124, 20, 58, 116, 134, 112, 250, 170, 227, 118, 57, 115, 93, 89, 245, 29, 207, 65, 97, 128, 135, 16, 3, 217, 196, 117, 27, 105] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [121, 97, 110, 100, 101, 120, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 32, 101, 11, 124, 20, 58, 116, 134, 112, 250, 170, 227, 118, 57, 115, 93, 89, 245, 29, 207, 65, 97, 128, 135, 16, 3, 217, 196, 117, 27, 105] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [68, 229, 113, 226, 235, 11, 49, 73, 204, 42, 72, 131, 55, 135, 69, 115, 95, 240, 139, 59, 183, 167, 237, 199, 17, 134, 201, 95, 12, 121, 146, 248], legacy_session_id: SessionId { l: 32, id: [5, 181, 8, 194, 23, 236, 11, 246, 58, 152, 233, 210, 68, 92, 238, 80, 212, 228, 244, 229, 246, 161, 9, 26, 42, 140, 252, 191, 96, 141, 143, 216] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [121, 97, 110, 100, 101, 120, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 32, 101, 11, 124, 20, 58, 116, 134, 112, 250, 170, 227, 118, 57, 115, 93, 89, 245, 29, 207, 65, 97, 128, 135, 16, 3, 217, 196, 117, 27, 105] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [68, 229, 113, 226, 235, 11, 49, 73, 204, 42, 72, 131, 55, 135, 69, 115, 95, 240, 139, 59, 183, 167, 237, 199, 17, 134, 201, 95, 12, 121, 146, 248], legacy_session_id: SessionId { l: 32, id: [5, 181, 8, 194, 23, 236, 11, 246, 58, 152, 233, 210, 68, 92, 238, 80, 212, 228, 244, 229, 246, 161, 9, 26, 42, 140, 252, 191, 96, 141, 143, 216] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [121, 97, 110, 100, 101, 120, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 32, 101, 11, 124, 20, 58, 116, 134, 112, 250, 170, 227, 118, 57, 115, 93, 89, 245, 29, 207, 65, 97, 128, 135, 16, 3, 217, 196, 117, 27, 105] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [68, 229, 113, 226, 235, 11, 49, 73, 204, 42, 72, 131, 55, 135, 69, 115, 95, 240, 139, 59, 183, 167, 237, 199, 17, 134, 201, 95, 12, 121, 146, 248], legacy_session_id: SessionId { l: 32, id: [5, 181, 8, 194, 23, 236, 11, 246, 58, 152, 233, 210, 68, 92, 238, 80, 212, 228, 244, 229, 246, 161, 9, 26, 42, 140, 252, 191, 96, 141, 143, 216] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [121, 97, 110, 100, 101, 120, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [181, 32, 101, 11, 124, 20, 58, 116, 134, 112, 250, 170, 227, 118, 57, 115, 93, 89, 245, 29, 207, 65, 97, 128, 135, 16, 3, 217, 196, 117, 27, 105] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: google-analytics.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [121, 118, 48, 201, 104, 18, 109, 102, 0, 240, 3, 77, 189, 108, 17, 134, 96, 241, 255, 89, 137, 219, 157, 132, 231, 104, 176, 114, 157, 57, 150, 28] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((22, Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 46, 99, 111, 109] }))
+[trace] HostName: Ok((22, Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((22, HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((23, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((25, ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((25, ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((29, ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [2, 145, 1, 204, 113, 166, 53, 66, 9, 25, 214, 175, 227, 9, 201, 103, 27, 108, 193, 191, 74, 139, 73, 192, 130, 20, 64, 94, 158, 244, 238, 107] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [2, 145, 1, 204, 113, 166, 53, 66, 9, 25, 214, 175, 227, 9, 201, 103, 27, 108, 193, 191, 74, 139, 73, 192, 130, 20, 64, 94, 158, 244, 238, 107] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [2, 145, 1, 204, 113, 166, 53, 66, 9, 25, 214, 175, 227, 9, 201, 103, 27, 108, 193, 191, 74, 139, 73, 192, 130, 20, 64, 94, 158, 244, 238, 107] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [2, 145, 1, 204, 113, 166, 53, 66, 9, 25, 214, 175, 227, 9, 201, 103, 27, 108, 193, 191, 74, 139, 73, 192, 130, 20, 64, 94, 158, 244, 238, 107] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((211, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((211, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((215, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [2, 145, 1, 204, 113, 166, 53, 66, 9, 25, 214, 175, 227, 9, 201, 103, 27, 108, 193, 191, 74, 139, 73, 192, 130, 20, 64, 94, 158, 244, 238, 107] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [84, 145, 81, 36, 127, 152, 38, 46, 92, 147, 35, 198, 83, 59, 80, 141, 108, 119, 40, 140, 121, 227, 166, 191, 157, 24, 248, 246, 188, 235, 123, 128], legacy_session_id: SessionId { l: 32, id: [121, 118, 48, 201, 104, 18, 109, 102, 0, 240, 3, 77, 189, 108, 17, 134, 96, 241, 255, 89, 137, 219, 157, 132, 231, 104, 176, 114, 157, 57, 150, 28] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [2, 145, 1, 204, 113, 166, 53, 66, 9, 25, 214, 175, 227, 9, 201, 103, 27, 108, 193, 191, 74, 139, 73, 192, 130, 20, 64, 94, 158, 244, 238, 107] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [84, 145, 81, 36, 127, 152, 38, 46, 92, 147, 35, 198, 83, 59, 80, 141, 108, 119, 40, 140, 121, 227, 166, 191, 157, 24, 248, 246, 188, 235, 123, 128], legacy_session_id: SessionId { l: 32, id: [121, 118, 48, 201, 104, 18, 109, 102, 0, 240, 3, 77, 189, 108, 17, 134, 96, 241, 255, 89, 137, 219, 157, 132, 231, 104, 176, 114, 157, 57, 150, 28] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [2, 145, 1, 204, 113, 166, 53, 66, 9, 25, 214, 175, 227, 9, 201, 103, 27, 108, 193, 191, 74, 139, 73, 192, 130, 20, 64, 94, 158, 244, 238, 107] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [84, 145, 81, 36, 127, 152, 38, 46, 92, 147, 35, 198, 83, 59, 80, 141, 108, 119, 40, 140, 121, 227, 166, 191, 157, 24, 248, 246, 188, 235, 123, 128], legacy_session_id: SessionId { l: 32, id: [121, 118, 48, 201, 104, 18, 109, 102, 0, 240, 3, 77, 189, 108, 17, 134, 96, 241, 255, 89, 137, 219, 157, 132, 231, 104, 176, 114, 157, 57, 150, 28] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [2, 145, 1, 204, 113, 166, 53, 66, 9, 25, 214, 175, 227, 9, 201, 103, 27, 108, 193, 191, 74, 139, 73, 192, 130, 20, 64, 94, 158, 244, 238, 107] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: office365.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [166, 122, 33, 76, 253, 127, 223, 175, 21, 224, 75, 53, 254, 220, 22, 56, 103, 4, 12, 151, 227, 25, 238, 46, 59, 205, 241, 179, 135, 209, 174, 174] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((15, Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }))
+[trace] HostName: Ok((15, Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((15, HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((16, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((18, ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((18, ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((22, ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [66, 163, 75, 140, 136, 24, 32, 187, 242, 153, 174, 11, 47, 63, 197, 100, 227, 136, 221, 64, 245, 51, 103, 232, 42, 198, 108, 147, 196, 125, 38, 110] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [66, 163, 75, 140, 136, 24, 32, 187, 242, 153, 174, 11, 47, 63, 197, 100, 227, 136, 221, 64, 245, 51, 103, 232, 42, 198, 108, 147, 196, 125, 38, 110] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [66, 163, 75, 140, 136, 24, 32, 187, 242, 153, 174, 11, 47, 63, 197, 100, 227, 136, 221, 64, 245, 51, 103, 232, 42, 198, 108, 147, 196, 125, 38, 110] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [66, 163, 75, 140, 136, 24, 32, 187, 242, 153, 174, 11, 47, 63, 197, 100, 227, 136, 221, 64, 245, 51, 103, 232, 42, 198, 108, 147, 196, 125, 38, 110] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((218, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((218, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((222, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [66, 163, 75, 140, 136, 24, 32, 187, 242, 153, 174, 11, 47, 63, 197, 100, 227, 136, 221, 64, 245, 51, 103, 232, 42, 198, 108, 147, 196, 125, 38, 110] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [76, 240, 194, 100, 44, 161, 184, 223, 34, 97, 237, 126, 235, 227, 235, 61, 124, 76, 137, 44, 124, 64, 240, 230, 185, 113, 85, 117, 160, 74, 144, 154], legacy_session_id: SessionId { l: 32, id: [166, 122, 33, 76, 253, 127, 223, 175, 21, 224, 75, 53, 254, 220, 22, 56, 103, 4, 12, 151, 227, 25, 238, 46, 59, 205, 241, 179, 135, 209, 174, 174] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [66, 163, 75, 140, 136, 24, 32, 187, 242, 153, 174, 11, 47, 63, 197, 100, 227, 136, 221, 64, 245, 51, 103, 232, 42, 198, 108, 147, 196, 125, 38, 110] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [76, 240, 194, 100, 44, 161, 184, 223, 34, 97, 237, 126, 235, 227, 235, 61, 124, 76, 137, 44, 124, 64, 240, 230, 185, 113, 85, 117, 160, 74, 144, 154], legacy_session_id: SessionId { l: 32, id: [166, 122, 33, 76, 253, 127, 223, 175, 21, 224, 75, 53, 254, 220, 22, 56, 103, 4, 12, 151, 227, 25, 238, 46, 59, 205, 241, 179, 135, 209, 174, 174] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [66, 163, 75, 140, 136, 24, 32, 187, 242, 153, 174, 11, 47, 63, 197, 100, 227, 136, 221, 64, 245, 51, 103, 232, 42, 198, 108, 147, 196, 125, 38, 110] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [76, 240, 194, 100, 44, 161, 184, 223, 34, 97, 237, 126, 235, 227, 235, 61, 124, 76, 137, 44, 124, 64, 240, 230, 185, 113, 85, 117, 160, 74, 144, 154], legacy_session_id: SessionId { l: 32, id: [166, 122, 33, 76, 253, 127, 223, 175, 21, 224, 75, 53, 254, 220, 22, 56, 103, 4, 12, 151, 227, 25, 238, 46, 59, 205, 241, 179, 135, 209, 174, 174] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [66, 163, 75, 140, 136, 24, 32, 187, 242, 153, 174, 11, 47, 63, 197, 100, 227, 136, 221, 64, 245, 51, 103, 232, 42, 198, 108, 147, 196, 125, 38, 110] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [166, 122, 33, 76, 253, 127, 223, 175, 21, 224, 75, 53, 254, 220, 22, 56, 103, 4, 12, 151, 227, 25, 238, 46, 59, 205, 241, 179, 135, 209, 174, 174] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((15, Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }))
+[trace] HostName: Ok((15, Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((15, HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((16, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((18, ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((18, ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((22, ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 25))
+[trace] KeyShareEntry: Ok((137, KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 222, 194, 5, 199, 137, 246, 83, 180, 172, 136, 78, 252, 141, 249, 116, 112, 225, 121, 199, 86, 159, 37, 11, 111, 192, 32, 102, 194, 48, 168, 140, 31, 226, 153, 181, 163, 247, 160, 30, 194, 203, 91, 17, 67, 5, 18, 156, 137, 67, 248, 26, 92, 153, 3, 26, 60, 127, 231, 102, 84, 208, 25, 35, 246, 145, 0, 8, 247, 152, 161, 83, 28, 119, 170, 84, 41, 171, 39, 175, 73, 165, 93, 169, 170, 191, 232, 33, 3, 217, 114, 218, 248, 122, 20, 174, 93, 183, 231, 113, 185, 226, 77, 67, 27, 189, 52, 37, 64, 115, 214, 97, 12, 40, 211, 129, 12, 223, 253, 62, 107, 149, 18, 255, 87, 206, 0, 167, 129, 22, 83, 117] }))
+[trace] KeyShareClientHello: Ok((139, KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 222, 194, 5, 199, 137, 246, 83, 180, 172, 136, 78, 252, 141, 249, 116, 112, 225, 121, 199, 86, 159, 37, 11, 111, 192, 32, 102, 194, 48, 168, 140, 31, 226, 153, 181, 163, 247, 160, 30, 194, 203, 91, 17, 67, 5, 18, 156, 137, 67, 248, 26, 92, 153, 3, 26, 60, 127, 231, 102, 84, 208, 25, 35, 246, 145, 0, 8, 247, 152, 161, 83, 28, 119, 170, 84, 41, 171, 39, 175, 73, 165, 93, 169, 170, 191, 232, 33, 3, 217, 114, 218, 248, 122, 20, 174, 93, 183, 231, 113, 185, 226, 77, 67, 27, 189, 52, 37, 64, 115, 214, 97, 12, 40, 211, 129, 12, 223, 253, 62, 107, 149, 18, 255, 87, 206, 0, 167, 129, 22, 83, 117] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((139, KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 222, 194, 5, 199, 137, 246, 83, 180, 172, 136, 78, 252, 141, 249, 116, 112, 225, 121, 199, 86, 159, 37, 11, 111, 192, 32, 102, 194, 48, 168, 140, 31, 226, 153, 181, 163, 247, 160, 30, 194, 203, 91, 17, 67, 5, 18, 156, 137, 67, 248, 26, 92, 153, 3, 26, 60, 127, 231, 102, 84, 208, 25, 35, 246, 145, 0, 8, 247, 152, 161, 83, 28, 119, 170, 84, 41, 171, 39, 175, 73, 165, 93, 169, 170, 191, 232, 33, 3, 217, 114, 218, 248, 122, 20, 174, 93, 183, 231, 113, 185, 226, 77, 67, 27, 189, 52, 37, 64, 115, 214, 97, 12, 40, 211, 129, 12, 223, 253, 62, 107, 149, 18, 255, 87, 206, 0, 167, 129, 22, 83, 117] }]) })))
+[trace] ClientHelloExtension: Ok((143, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 222, 194, 5, 199, 137, 246, 83, 180, 172, 136, 78, 252, 141, 249, 116, 112, 225, 121, 199, 86, 159, 37, 11, 111, 192, 32, 102, 194, 48, 168, 140, 31, 226, 153, 181, 163, 247, 160, 30, 194, 203, 91, 17, 67, 5, 18, 156, 137, 67, 248, 26, 92, 153, 3, 26, 60, 127, 231, 102, 84, 208, 25, 35, 246, 145, 0, 8, 247, 152, 161, 83, 28, 119, 170, 84, 41, 171, 39, 175, 73, 165, 93, 169, 170, 191, 232, 33, 3, 217, 114, 218, 248, 122, 20, 174, 93, 183, 231, 113, 185, 226, 77, 67, 27, 189, 52, 37, 64, 115, 214, 97, 12, 40, 211, 129, 12, 223, 253, 62, 107, 149, 18, 255, 87, 206, 0, 167, 129, 22, 83, 117] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((117, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((117, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((121, ClientHelloExtension { extension_type: 21, ext_len: 117, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 222, 194, 5, 199, 137, 246, 83, 180, 172, 136, 78, 252, 141, 249, 116, 112, 225, 121, 199, 86, 159, 37, 11, 111, 192, 32, 102, 194, 48, 168, 140, 31, 226, 153, 181, 163, 247, 160, 30, 194, 203, 91, 17, 67, 5, 18, 156, 137, 67, 248, 26, 92, 153, 3, 26, 60, 127, 231, 102, 84, 208, 25, 35, 246, 145, 0, 8, 247, 152, 161, 83, 28, 119, 170, 84, 41, 171, 39, 175, 73, 165, 93, 169, 170, 191, 232, 33, 3, 217, 114, 218, 248, 122, 20, 174, 93, 183, 231, 113, 185, 226, 77, 67, 27, 189, 52, 37, 64, 115, 214, 97, 12, 40, 211, 129, 12, 223, 253, 62, 107, 149, 18, 255, 87, 206, 0, 167, 129, 22, 83, 117] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 117, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [76, 240, 194, 100, 44, 161, 184, 223, 34, 97, 237, 126, 235, 227, 235, 61, 124, 76, 137, 44, 124, 64, 240, 230, 185, 113, 85, 117, 160, 74, 144, 154], legacy_session_id: SessionId { l: 32, id: [166, 122, 33, 76, 253, 127, 223, 175, 21, 224, 75, 53, 254, 220, 22, 56, 103, 4, 12, 151, 227, 25, 238, 46, 59, 205, 241, 179, 135, 209, 174, 174] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 222, 194, 5, 199, 137, 246, 83, 180, 172, 136, 78, 252, 141, 249, 116, 112, 225, 121, 199, 86, 159, 37, 11, 111, 192, 32, 102, 194, 48, 168, 140, 31, 226, 153, 181, 163, 247, 160, 30, 194, 203, 91, 17, 67, 5, 18, 156, 137, 67, 248, 26, 92, 153, 3, 26, 60, 127, 231, 102, 84, 208, 25, 35, 246, 145, 0, 8, 247, 152, 161, 83, 28, 119, 170, 84, 41, 171, 39, 175, 73, 165, 93, 169, 170, 191, 232, 33, 3, 217, 114, 218, 248, 122, 20, 174, 93, 183, 231, 113, 185, 226, 77, 67, 27, 189, 52, 37, 64, 115, 214, 97, 12, 40, 211, 129, 12, 223, 253, 62, 107, 149, 18, 255, 87, 206, 0, 167, 129, 22, 83, 117] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 117, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [76, 240, 194, 100, 44, 161, 184, 223, 34, 97, 237, 126, 235, 227, 235, 61, 124, 76, 137, 44, 124, 64, 240, 230, 185, 113, 85, 117, 160, 74, 144, 154], legacy_session_id: SessionId { l: 32, id: [166, 122, 33, 76, 253, 127, 223, 175, 21, 224, 75, 53, 254, 220, 22, 56, 103, 4, 12, 151, 227, 25, 238, 46, 59, 205, 241, 179, 135, 209, 174, 174] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 222, 194, 5, 199, 137, 246, 83, 180, 172, 136, 78, 252, 141, 249, 116, 112, 225, 121, 199, 86, 159, 37, 11, 111, 192, 32, 102, 194, 48, 168, 140, 31, 226, 153, 181, 163, 247, 160, 30, 194, 203, 91, 17, 67, 5, 18, 156, 137, 67, 248, 26, 92, 153, 3, 26, 60, 127, 231, 102, 84, 208, 25, 35, 246, 145, 0, 8, 247, 152, 161, 83, 28, 119, 170, 84, 41, 171, 39, 175, 73, 165, 93, 169, 170, 191, 232, 33, 3, 217, 114, 218, 248, 122, 20, 174, 93, 183, 231, 113, 185, 226, 77, 67, 27, 189, 52, 37, 64, 115, 214, 97, 12, 40, 211, 129, 12, 223, 253, 62, 107, 149, 18, 255, 87, 206, 0, 167, 129, 22, 83, 117] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 117, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [76, 240, 194, 100, 44, 161, 184, 223, 34, 97, 237, 126, 235, 227, 235, 61, 124, 76, 137, 44, 124, 64, 240, 230, 185, 113, 85, 117, 160, 74, 144, 154], legacy_session_id: SessionId { l: 32, id: [166, 122, 33, 76, 253, 127, 223, 175, 21, 224, 75, 53, 254, 220, 22, 56, 103, 4, 12, 151, 227, 25, 238, 46, 59, 205, 241, 179, 135, 209, 174, 174] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [111, 102, 102, 105, 99, 101, 51, 54, 53, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 139, extension_data: KeyShare(KeyShareClientHello { l: 137, list: RepeatResult([KeyShareEntry { group: 25, l: 133, key_exchange: [4, 0, 222, 194, 5, 199, 137, 246, 83, 180, 172, 136, 78, 252, 141, 249, 116, 112, 225, 121, 199, 86, 159, 37, 11, 111, 192, 32, 102, 194, 48, 168, 140, 31, 226, 153, 181, 163, 247, 160, 30, 194, 203, 91, 17, 67, 5, 18, 156, 137, 67, 248, 26, 92, 153, 3, 26, 60, 127, 231, 102, 84, 208, 25, 35, 246, 145, 0, 8, 247, 152, 161, 83, 28, 119, 170, 84, 41, 171, 39, 175, 73, 165, 93, 169, 170, 191, 232, 33, 3, 217, 114, 218, 248, 122, 20, 174, 93, 183, 231, 113, 185, 226, 77, 67, 27, 189, 52, 37, 64, 115, 214, 97, 12, 40, 211, 129, 12, 223, 253, 62, 107, 149, 18, 255, 87, 206, 0, 167, 129, 22, 83, 117] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 117, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: qq.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [64, 18, 36, 71, 171, 225, 125, 96, 84, 42, 254, 74, 52, 12, 252, 90, 4, 43, 64, 72, 144, 63, 183, 77, 23, 228, 193, 134, 216, 168, 208, 3] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((8, Opaque1Ffff { l: 6, data: [113, 113, 46, 99, 111, 109] }))
+[trace] HostName: Ok((8, Opaque1Ffff { l: 6, data: [113, 113, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((8, HostName(Opaque1Ffff { l: 6, data: [113, 113, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((9, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [113, 113, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((11, ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [113, 113, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((11, ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [113, 113, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((15, ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [113, 113, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [166, 254, 83, 66, 30, 54, 96, 139, 86, 60, 254, 172, 154, 12, 115, 209, 252, 9, 27, 37, 134, 224, 187, 89, 251, 212, 55, 126, 206, 62, 2, 92] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [166, 254, 83, 66, 30, 54, 96, 139, 86, 60, 254, 172, 154, 12, 115, 209, 252, 9, 27, 37, 134, 224, 187, 89, 251, 212, 55, 126, 206, 62, 2, 92] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [166, 254, 83, 66, 30, 54, 96, 139, 86, 60, 254, 172, 154, 12, 115, 209, 252, 9, 27, 37, 134, 224, 187, 89, 251, 212, 55, 126, 206, 62, 2, 92] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [166, 254, 83, 66, 30, 54, 96, 139, 86, 60, 254, 172, 154, 12, 115, 209, 252, 9, 27, 37, 134, 224, 187, 89, 251, 212, 55, 126, 206, 62, 2, 92] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((225, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((225, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((229, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [113, 113, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [166, 254, 83, 66, 30, 54, 96, 139, 86, 60, 254, 172, 154, 12, 115, 209, 252, 9, 27, 37, 134, 224, 187, 89, 251, 212, 55, 126, 206, 62, 2, 92] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [38, 229, 77, 180, 163, 140, 178, 132, 84, 81, 214, 11, 253, 128, 167, 164, 45, 43, 183, 112, 192, 57, 57, 154, 6, 93, 33, 222, 71, 9, 146, 93], legacy_session_id: SessionId { l: 32, id: [64, 18, 36, 71, 171, 225, 125, 96, 84, 42, 254, 74, 52, 12, 252, 90, 4, 43, 64, 72, 144, 63, 183, 77, 23, 228, 193, 134, 216, 168, 208, 3] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [113, 113, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [166, 254, 83, 66, 30, 54, 96, 139, 86, 60, 254, 172, 154, 12, 115, 209, 252, 9, 27, 37, 134, 224, 187, 89, 251, 212, 55, 126, 206, 62, 2, 92] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [38, 229, 77, 180, 163, 140, 178, 132, 84, 81, 214, 11, 253, 128, 167, 164, 45, 43, 183, 112, 192, 57, 57, 154, 6, 93, 33, 222, 71, 9, 146, 93], legacy_session_id: SessionId { l: 32, id: [64, 18, 36, 71, 171, 225, 125, 96, 84, 42, 254, 74, 52, 12, 252, 90, 4, 43, 64, 72, 144, 63, 183, 77, 23, 228, 193, 134, 216, 168, 208, 3] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [113, 113, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [166, 254, 83, 66, 30, 54, 96, 139, 86, 60, 254, 172, 154, 12, 115, 209, 252, 9, 27, 37, 134, 224, 187, 89, 251, 212, 55, 126, 206, 62, 2, 92] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [38, 229, 77, 180, 163, 140, 178, 132, 84, 81, 214, 11, 253, 128, 167, 164, 45, 43, 183, 112, 192, 57, 57, 154, 6, 93, 33, 222, 71, 9, 146, 93], legacy_session_id: SessionId { l: 32, id: [64, 18, 36, 71, 171, 225, 125, 96, 84, 42, 254, 74, 52, 12, 252, 90, 4, 43, 64, 72, 144, 63, 183, 77, 23, 228, 193, 134, 216, 168, 208, 3] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [113, 113, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [166, 254, 83, 66, 30, 54, 96, 139, 86, 60, 254, 172, 154, 12, 115, 209, 252, 9, 27, 37, 134, 224, 187, 89, 251, 212, 55, 126, 206, 62, 2, 92] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(2004a611e2d7c02077645f353dfc7bf1e51ff6ba0f5bd2a86b1296052830199f15) }, encoded: 100000212004a611e2d7c02077645f353dfc7bf1e51ff6ba0f5bd2a86b1296052830199f15 }
+=====================================
+domain: gandi.net
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [4, 87, 69, 236, 105, 81, 94, 35, 129, 202, 155, 252, 115, 237, 70, 136, 120, 145, 25, 244, 212, 221, 134, 244, 155, 127, 238, 99, 216, 40, 43, 69] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [103, 97, 110, 100, 105, 46, 110, 101, 116] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [103, 97, 110, 100, 105, 46, 110, 101, 116] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [103, 97, 110, 100, 105, 46, 110, 101, 116] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 97, 110, 100, 105, 46, 110, 101, 116] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 97, 110, 100, 105, 46, 110, 101, 116] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 97, 110, 100, 105, 46, 110, 101, 116] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 97, 110, 100, 105, 46, 110, 101, 116] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [47, 94, 154, 55, 23, 226, 47, 77, 188, 142, 225, 246, 241, 32, 81, 192, 192, 185, 80, 114, 248, 15, 50, 195, 57, 80, 198, 29, 77, 180, 26, 53] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [47, 94, 154, 55, 23, 226, 47, 77, 188, 142, 225, 246, 241, 32, 81, 192, 192, 185, 80, 114, 248, 15, 50, 195, 57, 80, 198, 29, 77, 180, 26, 53] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [47, 94, 154, 55, 23, 226, 47, 77, 188, 142, 225, 246, 241, 32, 81, 192, 192, 185, 80, 114, 248, 15, 50, 195, 57, 80, 198, 29, 77, 180, 26, 53] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [47, 94, 154, 55, 23, 226, 47, 77, 188, 142, 225, 246, 241, 32, 81, 192, 192, 185, 80, 114, 248, 15, 50, 195, 57, 80, 198, 29, 77, 180, 26, 53] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 97, 110, 100, 105, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [47, 94, 154, 55, 23, 226, 47, 77, 188, 142, 225, 246, 241, 32, 81, 192, 192, 185, 80, 114, 248, 15, 50, 195, 57, 80, 198, 29, 77, 180, 26, 53] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [42, 235, 145, 86, 138, 222, 106, 168, 83, 43, 164, 212, 170, 227, 34, 78, 107, 99, 160, 88, 36, 56, 111, 60, 39, 201, 144, 84, 156, 52, 171, 149], legacy_session_id: SessionId { l: 32, id: [4, 87, 69, 236, 105, 81, 94, 35, 129, 202, 155, 252, 115, 237, 70, 136, 120, 145, 25, 244, 212, 221, 134, 244, 155, 127, 238, 99, 216, 40, 43, 69] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 97, 110, 100, 105, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [47, 94, 154, 55, 23, 226, 47, 77, 188, 142, 225, 246, 241, 32, 81, 192, 192, 185, 80, 114, 248, 15, 50, 195, 57, 80, 198, 29, 77, 180, 26, 53] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [42, 235, 145, 86, 138, 222, 106, 168, 83, 43, 164, 212, 170, 227, 34, 78, 107, 99, 160, 88, 36, 56, 111, 60, 39, 201, 144, 84, 156, 52, 171, 149], legacy_session_id: SessionId { l: 32, id: [4, 87, 69, 236, 105, 81, 94, 35, 129, 202, 155, 252, 115, 237, 70, 136, 120, 145, 25, 244, 212, 221, 134, 244, 155, 127, 238, 99, 216, 40, 43, 69] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 97, 110, 100, 105, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [47, 94, 154, 55, 23, 226, 47, 77, 188, 142, 225, 246, 241, 32, 81, 192, 192, 185, 80, 114, 248, 15, 50, 195, 57, 80, 198, 29, 77, 180, 26, 53] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [42, 235, 145, 86, 138, 222, 106, 168, 83, 43, 164, 212, 170, 227, 34, 78, 107, 99, 160, 88, 36, 56, 111, 60, 39, 201, 144, 84, 156, 52, 171, 149], legacy_session_id: SessionId { l: 32, id: [4, 87, 69, 236, 105, 81, 94, 35, 129, 202, 155, 252, 115, 237, 70, 136, 120, 145, 25, 244, 212, 221, 134, 244, 155, 127, 238, 99, 216, 40, 43, 69] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 97, 110, 100, 105, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [47, 94, 154, 55, 23, 226, 47, 77, 188, 142, 225, 246, 241, 32, 81, 192, 192, 185, 80, 114, 248, 15, 50, 195, 57, 80, 198, 29, 77, 180, 26, 53] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: mozilla.org
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [155, 227, 162, 228, 228, 147, 178, 224, 147, 201, 180, 208, 222, 96, 162, 143, 234, 103, 227, 178, 229, 93, 173, 104, 38, 19, 150, 176, 60, 88, 114, 54] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [109, 111, 122, 105, 108, 108, 97, 46, 111, 114, 103] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [109, 111, 122, 105, 108, 108, 97, 46, 111, 114, 103] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [109, 111, 122, 105, 108, 108, 97, 46, 111, 114, 103] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 111, 122, 105, 108, 108, 97, 46, 111, 114, 103] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 111, 122, 105, 108, 108, 97, 46, 111, 114, 103] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 111, 122, 105, 108, 108, 97, 46, 111, 114, 103] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 111, 122, 105, 108, 108, 97, 46, 111, 114, 103] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [237, 254, 43, 255, 5, 91, 190, 55, 85, 168, 223, 235, 27, 215, 212, 32, 73, 11, 170, 252, 21, 167, 218, 154, 110, 172, 162, 67, 70, 44, 71, 48] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 254, 43, 255, 5, 91, 190, 55, 85, 168, 223, 235, 27, 215, 212, 32, 73, 11, 170, 252, 21, 167, 218, 154, 110, 172, 162, 67, 70, 44, 71, 48] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 254, 43, 255, 5, 91, 190, 55, 85, 168, 223, 235, 27, 215, 212, 32, 73, 11, 170, 252, 21, 167, 218, 154, 110, 172, 162, 67, 70, 44, 71, 48] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 254, 43, 255, 5, 91, 190, 55, 85, 168, 223, 235, 27, 215, 212, 32, 73, 11, 170, 252, 21, 167, 218, 154, 110, 172, 162, 67, 70, 44, 71, 48] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 111, 122, 105, 108, 108, 97, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 254, 43, 255, 5, 91, 190, 55, 85, 168, 223, 235, 27, 215, 212, 32, 73, 11, 170, 252, 21, 167, 218, 154, 110, 172, 162, 67, 70, 44, 71, 48] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [111, 178, 250, 135, 225, 228, 50, 44, 215, 208, 44, 7, 82, 113, 89, 44, 254, 16, 139, 56, 238, 234, 43, 43, 168, 46, 177, 132, 20, 106, 211, 211], legacy_session_id: SessionId { l: 32, id: [155, 227, 162, 228, 228, 147, 178, 224, 147, 201, 180, 208, 222, 96, 162, 143, 234, 103, 227, 178, 229, 93, 173, 104, 38, 19, 150, 176, 60, 88, 114, 54] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 111, 122, 105, 108, 108, 97, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 254, 43, 255, 5, 91, 190, 55, 85, 168, 223, 235, 27, 215, 212, 32, 73, 11, 170, 252, 21, 167, 218, 154, 110, 172, 162, 67, 70, 44, 71, 48] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [111, 178, 250, 135, 225, 228, 50, 44, 215, 208, 44, 7, 82, 113, 89, 44, 254, 16, 139, 56, 238, 234, 43, 43, 168, 46, 177, 132, 20, 106, 211, 211], legacy_session_id: SessionId { l: 32, id: [155, 227, 162, 228, 228, 147, 178, 224, 147, 201, 180, 208, 222, 96, 162, 143, 234, 103, 227, 178, 229, 93, 173, 104, 38, 19, 150, 176, 60, 88, 114, 54] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 111, 122, 105, 108, 108, 97, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 254, 43, 255, 5, 91, 190, 55, 85, 168, 223, 235, 27, 215, 212, 32, 73, 11, 170, 252, 21, 167, 218, 154, 110, 172, 162, 67, 70, 44, 71, 48] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [111, 178, 250, 135, 225, 228, 50, 44, 215, 208, 44, 7, 82, 113, 89, 44, 254, 16, 139, 56, 238, 234, 43, 43, 168, 46, 177, 132, 20, 106, 211, 211], legacy_session_id: SessionId { l: 32, id: [155, 227, 162, 228, 228, 147, 178, 224, 147, 201, 180, 208, 222, 96, 162, 143, 234, 103, 227, 178, 229, 93, 173, 104, 38, 19, 150, 176, 60, 88, 114, 54] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 111, 122, 105, 108, 108, 97, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [237, 254, 43, 255, 5, 91, 190, 55, 85, 168, 223, 235, 27, 215, 212, 32, 73, 11, 170, 252, 21, 167, 218, 154, 110, 172, 162, 67, 70, 44, 71, 48] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: x.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [108, 240, 166, 248, 42, 190, 31, 50, 76, 139, 139, 204, 210, 102, 119, 155, 190, 226, 220, 153, 58, 76, 7, 202, 171, 232, 219, 72, 62, 19, 1, 210] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((7, Opaque1Ffff { l: 5, data: [120, 46, 99, 111, 109] }))
+[trace] HostName: Ok((7, Opaque1Ffff { l: 5, data: [120, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((7, HostName(Opaque1Ffff { l: 5, data: [120, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((8, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [120, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((10, ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [120, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((10, ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [120, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((14, ClientHelloExtension { extension_type: 0, ext_len: 10, extension_data: ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [120, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [33, 202, 17, 15, 143, 126, 234, 181, 244, 211, 210, 230, 121, 67, 80, 36, 245, 211, 159, 169, 73, 111, 183, 67, 98, 75, 17, 221, 131, 141, 140, 109] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [33, 202, 17, 15, 143, 126, 234, 181, 244, 211, 210, 230, 121, 67, 80, 36, 245, 211, 159, 169, 73, 111, 183, 67, 98, 75, 17, 221, 131, 141, 140, 109] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [33, 202, 17, 15, 143, 126, 234, 181, 244, 211, 210, 230, 121, 67, 80, 36, 245, 211, 159, 169, 73, 111, 183, 67, 98, 75, 17, 221, 131, 141, 140, 109] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [33, 202, 17, 15, 143, 126, 234, 181, 244, 211, 210, 230, 121, 67, 80, 36, 245, 211, 159, 169, 73, 111, 183, 67, 98, 75, 17, 221, 131, 141, 140, 109] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((226, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((226, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((230, ClientHelloExtension { extension_type: 21, ext_len: 226, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 10, extension_data: ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [33, 202, 17, 15, 143, 126, 234, 181, 244, 211, 210, 230, 121, 67, 80, 36, 245, 211, 159, 169, 73, 111, 183, 67, 98, 75, 17, 221, 131, 141, 140, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 226, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [169, 174, 148, 195, 83, 42, 182, 83, 73, 213, 8, 147, 234, 253, 81, 27, 52, 41, 120, 191, 183, 48, 171, 0, 39, 192, 150, 167, 82, 20, 44, 21], legacy_session_id: SessionId { l: 32, id: [108, 240, 166, 248, 42, 190, 31, 50, 76, 139, 139, 204, 210, 102, 119, 155, 190, 226, 220, 153, 58, 76, 7, 202, 171, 232, 219, 72, 62, 19, 1, 210] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 10, extension_data: ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [33, 202, 17, 15, 143, 126, 234, 181, 244, 211, 210, 230, 121, 67, 80, 36, 245, 211, 159, 169, 73, 111, 183, 67, 98, 75, 17, 221, 131, 141, 140, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 226, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [169, 174, 148, 195, 83, 42, 182, 83, 73, 213, 8, 147, 234, 253, 81, 27, 52, 41, 120, 191, 183, 48, 171, 0, 39, 192, 150, 167, 82, 20, 44, 21], legacy_session_id: SessionId { l: 32, id: [108, 240, 166, 248, 42, 190, 31, 50, 76, 139, 139, 204, 210, 102, 119, 155, 190, 226, 220, 153, 58, 76, 7, 202, 171, 232, 219, 72, 62, 19, 1, 210] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 10, extension_data: ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [33, 202, 17, 15, 143, 126, 234, 181, 244, 211, 210, 230, 121, 67, 80, 36, 245, 211, 159, 169, 73, 111, 183, 67, 98, 75, 17, 221, 131, 141, 140, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 226, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [169, 174, 148, 195, 83, 42, 182, 83, 73, 213, 8, 147, 234, 253, 81, 27, 52, 41, 120, 191, 183, 48, 171, 0, 39, 192, 150, 167, 82, 20, 44, 21], legacy_session_id: SessionId { l: 32, id: [108, 240, 166, 248, 42, 190, 31, 50, 76, 139, 139, 204, 210, 102, 119, 155, 190, 226, 220, 153, 58, 76, 7, 202, 171, 232, 219, 72, 62, 19, 1, 210] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 10, extension_data: ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [33, 202, 17, 15, 143, 126, 234, 181, 244, 211, 210, 230, 121, 67, 80, 36, 245, 211, 159, 169, 73, 111, 183, 67, 98, 75, 17, 221, 131, 141, 140, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 226, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: opera.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [231, 183, 193, 52, 189, 6, 1, 101, 168, 47, 15, 157, 120, 27, 187, 84, 36, 128, 237, 225, 218, 32, 69, 59, 9, 160, 47, 230, 34, 154, 22, 69] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [111, 112, 101, 114, 97, 46, 99, 111, 109] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [111, 112, 101, 114, 97, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [111, 112, 101, 114, 97, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [111, 112, 101, 114, 97, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [111, 112, 101, 114, 97, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [111, 112, 101, 114, 97, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [111, 112, 101, 114, 97, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [107, 128, 37, 103, 85, 158, 243, 177, 243, 7, 127, 193, 13, 149, 40, 195, 153, 50, 133, 232, 122, 13, 181, 63, 95, 105, 142, 147, 69, 217, 1, 38] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [107, 128, 37, 103, 85, 158, 243, 177, 243, 7, 127, 193, 13, 149, 40, 195, 153, 50, 133, 232, 122, 13, 181, 63, 95, 105, 142, 147, 69, 217, 1, 38] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [107, 128, 37, 103, 85, 158, 243, 177, 243, 7, 127, 193, 13, 149, 40, 195, 153, 50, 133, 232, 122, 13, 181, 63, 95, 105, 142, 147, 69, 217, 1, 38] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [107, 128, 37, 103, 85, 158, 243, 177, 243, 7, 127, 193, 13, 149, 40, 195, 153, 50, 133, 232, 122, 13, 181, 63, 95, 105, 142, 147, 69, 217, 1, 38] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [111, 112, 101, 114, 97, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [107, 128, 37, 103, 85, 158, 243, 177, 243, 7, 127, 193, 13, 149, 40, 195, 153, 50, 133, 232, 122, 13, 181, 63, 95, 105, 142, 147, 69, 217, 1, 38] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [181, 53, 184, 112, 133, 224, 251, 136, 39, 216, 166, 175, 161, 141, 204, 199, 135, 243, 157, 12, 137, 29, 52, 202, 146, 109, 35, 251, 164, 242, 72, 76], legacy_session_id: SessionId { l: 32, id: [231, 183, 193, 52, 189, 6, 1, 101, 168, 47, 15, 157, 120, 27, 187, 84, 36, 128, 237, 225, 218, 32, 69, 59, 9, 160, 47, 230, 34, 154, 22, 69] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [111, 112, 101, 114, 97, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [107, 128, 37, 103, 85, 158, 243, 177, 243, 7, 127, 193, 13, 149, 40, 195, 153, 50, 133, 232, 122, 13, 181, 63, 95, 105, 142, 147, 69, 217, 1, 38] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [181, 53, 184, 112, 133, 224, 251, 136, 39, 216, 166, 175, 161, 141, 204, 199, 135, 243, 157, 12, 137, 29, 52, 202, 146, 109, 35, 251, 164, 242, 72, 76], legacy_session_id: SessionId { l: 32, id: [231, 183, 193, 52, 189, 6, 1, 101, 168, 47, 15, 157, 120, 27, 187, 84, 36, 128, 237, 225, 218, 32, 69, 59, 9, 160, 47, 230, 34, 154, 22, 69] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [111, 112, 101, 114, 97, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [107, 128, 37, 103, 85, 158, 243, 177, 243, 7, 127, 193, 13, 149, 40, 195, 153, 50, 133, 232, 122, 13, 181, 63, 95, 105, 142, 147, 69, 217, 1, 38] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [181, 53, 184, 112, 133, 224, 251, 136, 39, 216, 166, 175, 161, 141, 204, 199, 135, 243, 157, 12, 137, 29, 52, 202, 146, 109, 35, 251, 164, 242, 72, 76], legacy_session_id: SessionId { l: 32, id: [231, 183, 193, 52, 189, 6, 1, 101, 168, 47, 15, 157, 120, 27, 187, 84, 36, 128, 237, 225, 218, 32, 69, 59, 9, 160, 47, 230, 34, 154, 22, 69] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [111, 112, 101, 114, 97, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [107, 128, 37, 103, 85, 158, 243, 177, 243, 7, 127, 193, 13, 149, 40, 195, 153, 50, 133, 232, 122, 13, 181, 63, 95, 105, 142, 147, 69, 217, 1, 38] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: blogspot.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [46, 219, 64, 146, 206, 215, 26, 83, 66, 194, 60, 12, 92, 97, 37, 172, 57, 99, 210, 1, 19, 10, 98, 147, 96, 168, 73, 105, 241, 232, 193, 103] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((14, Opaque1Ffff { l: 12, data: [98, 108, 111, 103, 115, 112, 111, 116, 46, 99, 111, 109] }))
+[trace] HostName: Ok((14, Opaque1Ffff { l: 12, data: [98, 108, 111, 103, 115, 112, 111, 116, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((14, HostName(Opaque1Ffff { l: 12, data: [98, 108, 111, 103, 115, 112, 111, 116, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((15, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [98, 108, 111, 103, 115, 112, 111, 116, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((17, ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [98, 108, 111, 103, 115, 112, 111, 116, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((17, ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [98, 108, 111, 103, 115, 112, 111, 116, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((21, ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [98, 108, 111, 103, 115, 112, 111, 116, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [76, 22, 16, 41, 45, 75, 55, 205, 166, 127, 22, 177, 175, 88, 39, 67, 176, 17, 205, 70, 202, 134, 91, 160, 169, 172, 254, 188, 77, 129, 168, 111] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [76, 22, 16, 41, 45, 75, 55, 205, 166, 127, 22, 177, 175, 88, 39, 67, 176, 17, 205, 70, 202, 134, 91, 160, 169, 172, 254, 188, 77, 129, 168, 111] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [76, 22, 16, 41, 45, 75, 55, 205, 166, 127, 22, 177, 175, 88, 39, 67, 176, 17, 205, 70, 202, 134, 91, 160, 169, 172, 254, 188, 77, 129, 168, 111] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [76, 22, 16, 41, 45, 75, 55, 205, 166, 127, 22, 177, 175, 88, 39, 67, 176, 17, 205, 70, 202, 134, 91, 160, 169, 172, 254, 188, 77, 129, 168, 111] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((219, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((219, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((223, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [98, 108, 111, 103, 115, 112, 111, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [76, 22, 16, 41, 45, 75, 55, 205, 166, 127, 22, 177, 175, 88, 39, 67, 176, 17, 205, 70, 202, 134, 91, 160, 169, 172, 254, 188, 77, 129, 168, 111] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [24, 55, 6, 181, 249, 177, 23, 124, 49, 127, 14, 250, 233, 187, 251, 189, 191, 72, 14, 69, 115, 73, 17, 191, 24, 239, 190, 99, 116, 42, 228, 46], legacy_session_id: SessionId { l: 32, id: [46, 219, 64, 146, 206, 215, 26, 83, 66, 194, 60, 12, 92, 97, 37, 172, 57, 99, 210, 1, 19, 10, 98, 147, 96, 168, 73, 105, 241, 232, 193, 103] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [98, 108, 111, 103, 115, 112, 111, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [76, 22, 16, 41, 45, 75, 55, 205, 166, 127, 22, 177, 175, 88, 39, 67, 176, 17, 205, 70, 202, 134, 91, 160, 169, 172, 254, 188, 77, 129, 168, 111] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [24, 55, 6, 181, 249, 177, 23, 124, 49, 127, 14, 250, 233, 187, 251, 189, 191, 72, 14, 69, 115, 73, 17, 191, 24, 239, 190, 99, 116, 42, 228, 46], legacy_session_id: SessionId { l: 32, id: [46, 219, 64, 146, 206, 215, 26, 83, 66, 194, 60, 12, 92, 97, 37, 172, 57, 99, 210, 1, 19, 10, 98, 147, 96, 168, 73, 105, 241, 232, 193, 103] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [98, 108, 111, 103, 115, 112, 111, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [76, 22, 16, 41, 45, 75, 55, 205, 166, 127, 22, 177, 175, 88, 39, 67, 176, 17, 205, 70, 202, 134, 91, 160, 169, 172, 254, 188, 77, 129, 168, 111] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [24, 55, 6, 181, 249, 177, 23, 124, 49, 127, 14, 250, 233, 187, 251, 189, 191, 72, 14, 69, 115, 73, 17, 191, 24, 239, 190, 99, 116, 42, 228, 46], legacy_session_id: SessionId { l: 32, id: [46, 219, 64, 146, 206, 215, 26, 83, 66, 194, 60, 12, 92, 97, 37, 172, 57, 99, 210, 1, 19, 10, 98, 147, 96, 168, 73, 105, 241, 232, 193, 103] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [98, 108, 111, 103, 115, 112, 111, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [76, 22, 16, 41, 45, 75, 55, 205, 166, 127, 22, 177, 175, 88, 39, 67, 176, 17, 205, 70, 202, 134, 91, 160, 169, 172, 254, 188, 77, 129, 168, 111] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: zoom.us
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [33, 67, 176, 200, 56, 187, 15, 122, 206, 158, 212, 76, 138, 43, 228, 40, 68, 1, 194, 119, 44, 182, 62, 31, 12, 46, 20, 179, 62, 190, 237, 65] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((9, Opaque1Ffff { l: 7, data: [122, 111, 111, 109, 46, 117, 115] }))
+[trace] HostName: Ok((9, Opaque1Ffff { l: 7, data: [122, 111, 111, 109, 46, 117, 115] }))
+[trace] ServerNameName: Ok((9, HostName(Opaque1Ffff { l: 7, data: [122, 111, 111, 109, 46, 117, 115] })))
+[trace] ServerName: Ok((10, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [122, 111, 111, 109, 46, 117, 115] }) }))
+[trace] ServerNameList: Ok((12, ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [122, 111, 111, 109, 46, 117, 115] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((12, ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [122, 111, 111, 109, 46, 117, 115] }) }]) })))
+[trace] ClientHelloExtension: Ok((16, ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [122, 111, 111, 109, 46, 117, 115] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [165, 41, 235, 158, 49, 223, 109, 228, 216, 190, 144, 26, 11, 111, 191, 229, 51, 104, 172, 242, 240, 178, 92, 140, 88, 223, 147, 204, 145, 132, 58, 102] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [165, 41, 235, 158, 49, 223, 109, 228, 216, 190, 144, 26, 11, 111, 191, 229, 51, 104, 172, 242, 240, 178, 92, 140, 88, 223, 147, 204, 145, 132, 58, 102] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [165, 41, 235, 158, 49, 223, 109, 228, 216, 190, 144, 26, 11, 111, 191, 229, 51, 104, 172, 242, 240, 178, 92, 140, 88, 223, 147, 204, 145, 132, 58, 102] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [165, 41, 235, 158, 49, 223, 109, 228, 216, 190, 144, 26, 11, 111, 191, 229, 51, 104, 172, 242, 240, 178, 92, 140, 88, 223, 147, 204, 145, 132, 58, 102] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((224, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((224, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((228, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [122, 111, 111, 109, 46, 117, 115] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [165, 41, 235, 158, 49, 223, 109, 228, 216, 190, 144, 26, 11, 111, 191, 229, 51, 104, 172, 242, 240, 178, 92, 140, 88, 223, 147, 204, 145, 132, 58, 102] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [16, 43, 98, 236, 237, 224, 62, 184, 90, 227, 238, 204, 237, 46, 220, 102, 163, 75, 146, 65, 11, 133, 154, 188, 56, 233, 109, 109, 106, 137, 103, 23], legacy_session_id: SessionId { l: 32, id: [33, 67, 176, 200, 56, 187, 15, 122, 206, 158, 212, 76, 138, 43, 228, 40, 68, 1, 194, 119, 44, 182, 62, 31, 12, 46, 20, 179, 62, 190, 237, 65] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [122, 111, 111, 109, 46, 117, 115] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [165, 41, 235, 158, 49, 223, 109, 228, 216, 190, 144, 26, 11, 111, 191, 229, 51, 104, 172, 242, 240, 178, 92, 140, 88, 223, 147, 204, 145, 132, 58, 102] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [16, 43, 98, 236, 237, 224, 62, 184, 90, 227, 238, 204, 237, 46, 220, 102, 163, 75, 146, 65, 11, 133, 154, 188, 56, 233, 109, 109, 106, 137, 103, 23], legacy_session_id: SessionId { l: 32, id: [33, 67, 176, 200, 56, 187, 15, 122, 206, 158, 212, 76, 138, 43, 228, 40, 68, 1, 194, 119, 44, 182, 62, 31, 12, 46, 20, 179, 62, 190, 237, 65] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [122, 111, 111, 109, 46, 117, 115] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [165, 41, 235, 158, 49, 223, 109, 228, 216, 190, 144, 26, 11, 111, 191, 229, 51, 104, 172, 242, 240, 178, 92, 140, 88, 223, 147, 204, 145, 132, 58, 102] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [16, 43, 98, 236, 237, 224, 62, 184, 90, 227, 238, 204, 237, 46, 220, 102, 163, 75, 146, 65, 11, 133, 154, 188, 56, 233, 109, 109, 106, 137, 103, 23], legacy_session_id: SessionId { l: 32, id: [33, 67, 176, 200, 56, 187, 15, 122, 206, 158, 212, 76, 138, 43, 228, 40, 68, 1, 194, 119, 44, 182, 62, 31, 12, 46, 20, 179, 62, 190, 237, 65] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [122, 111, 111, 109, 46, 117, 115] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [165, 41, 235, 158, 49, 223, 109, 228, 216, 190, 144, 26, 11, 111, 191, 229, 51, 104, 172, 242, 240, 178, 92, 140, 88, 223, 147, 204, 145, 132, 58, 102] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: cloudflare-dns.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [8, 200, 149, 169, 105, 21, 99, 11, 128, 41, 112, 103, 133, 104, 27, 241, 238, 110, 205, 182, 153, 205, 26, 119, 187, 113, 121, 207, 215, 88, 191, 198] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((20, Opaque1Ffff { l: 18, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 45, 100, 110, 115, 46, 99, 111, 109] }))
+[trace] HostName: Ok((20, Opaque1Ffff { l: 18, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 45, 100, 110, 115, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((20, HostName(Opaque1Ffff { l: 18, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 45, 100, 110, 115, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((21, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 18, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 45, 100, 110, 115, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((23, ServerNameList { l: 21, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 18, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 45, 100, 110, 115, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((23, ServerName(ServerNameList { l: 21, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 18, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 45, 100, 110, 115, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((27, ClientHelloExtension { extension_type: 0, ext_len: 23, extension_data: ServerName(ServerNameList { l: 21, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 18, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 45, 100, 110, 115, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [82, 188, 38, 40, 254, 58, 220, 129, 220, 212, 85, 93, 191, 188, 137, 222, 99, 0, 176, 29, 179, 137, 196, 233, 25, 205, 249, 226, 224, 225, 103, 45] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [82, 188, 38, 40, 254, 58, 220, 129, 220, 212, 85, 93, 191, 188, 137, 222, 99, 0, 176, 29, 179, 137, 196, 233, 25, 205, 249, 226, 224, 225, 103, 45] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [82, 188, 38, 40, 254, 58, 220, 129, 220, 212, 85, 93, 191, 188, 137, 222, 99, 0, 176, 29, 179, 137, 196, 233, 25, 205, 249, 226, 224, 225, 103, 45] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [82, 188, 38, 40, 254, 58, 220, 129, 220, 212, 85, 93, 191, 188, 137, 222, 99, 0, 176, 29, 179, 137, 196, 233, 25, 205, 249, 226, 224, 225, 103, 45] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((213, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((213, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((217, ClientHelloExtension { extension_type: 21, ext_len: 213, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 23, extension_data: ServerName(ServerNameList { l: 21, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 18, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 45, 100, 110, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [82, 188, 38, 40, 254, 58, 220, 129, 220, 212, 85, 93, 191, 188, 137, 222, 99, 0, 176, 29, 179, 137, 196, 233, 25, 205, 249, 226, 224, 225, 103, 45] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 213, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [152, 173, 187, 213, 72, 115, 171, 141, 109, 137, 199, 244, 150, 206, 225, 59, 191, 49, 52, 183, 41, 101, 114, 103, 115, 21, 204, 25, 178, 144, 82, 55], legacy_session_id: SessionId { l: 32, id: [8, 200, 149, 169, 105, 21, 99, 11, 128, 41, 112, 103, 133, 104, 27, 241, 238, 110, 205, 182, 153, 205, 26, 119, 187, 113, 121, 207, 215, 88, 191, 198] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 23, extension_data: ServerName(ServerNameList { l: 21, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 18, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 45, 100, 110, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [82, 188, 38, 40, 254, 58, 220, 129, 220, 212, 85, 93, 191, 188, 137, 222, 99, 0, 176, 29, 179, 137, 196, 233, 25, 205, 249, 226, 224, 225, 103, 45] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 213, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [152, 173, 187, 213, 72, 115, 171, 141, 109, 137, 199, 244, 150, 206, 225, 59, 191, 49, 52, 183, 41, 101, 114, 103, 115, 21, 204, 25, 178, 144, 82, 55], legacy_session_id: SessionId { l: 32, id: [8, 200, 149, 169, 105, 21, 99, 11, 128, 41, 112, 103, 133, 104, 27, 241, 238, 110, 205, 182, 153, 205, 26, 119, 187, 113, 121, 207, 215, 88, 191, 198] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 23, extension_data: ServerName(ServerNameList { l: 21, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 18, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 45, 100, 110, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [82, 188, 38, 40, 254, 58, 220, 129, 220, 212, 85, 93, 191, 188, 137, 222, 99, 0, 176, 29, 179, 137, 196, 233, 25, 205, 249, 226, 224, 225, 103, 45] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 213, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [152, 173, 187, 213, 72, 115, 171, 141, 109, 137, 199, 244, 150, 206, 225, 59, 191, 49, 52, 183, 41, 101, 114, 103, 115, 21, 204, 25, 178, 144, 82, 55], legacy_session_id: SessionId { l: 32, id: [8, 200, 149, 169, 105, 21, 99, 11, 128, 41, 112, 103, 133, 104, 27, 241, 238, 110, 205, 182, 153, 205, 26, 119, 187, 113, 121, 207, 215, 88, 191, 198] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 23, extension_data: ServerName(ServerNameList { l: 21, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 18, data: [99, 108, 111, 117, 100, 102, 108, 97, 114, 101, 45, 100, 110, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [82, 188, 38, 40, 254, 58, 220, 129, 220, 212, 85, 93, 191, 188, 137, 222, 99, 0, 176, 29, 179, 137, 196, 233, 25, 205, 249, 226, 224, 225, 103, 45] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 213, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: unity3d.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [254, 115, 60, 255, 193, 233, 190, 30, 134, 41, 192, 16, 30, 124, 37, 71, 29, 200, 17, 164, 204, 87, 44, 109, 140, 244, 155, 240, 88, 227, 155, 113] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [117, 110, 105, 116, 121, 51, 100, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [117, 110, 105, 116, 121, 51, 100, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [117, 110, 105, 116, 121, 51, 100, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 110, 105, 116, 121, 51, 100, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 110, 105, 116, 121, 51, 100, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 110, 105, 116, 121, 51, 100, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 110, 105, 116, 121, 51, 100, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [8, 195, 165, 113, 8, 163, 94, 59, 186, 72, 150, 59, 67, 137, 204, 45, 134, 232, 109, 119, 95, 123, 188, 90, 209, 247, 241, 40, 36, 211, 116, 67] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [8, 195, 165, 113, 8, 163, 94, 59, 186, 72, 150, 59, 67, 137, 204, 45, 134, 232, 109, 119, 95, 123, 188, 90, 209, 247, 241, 40, 36, 211, 116, 67] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [8, 195, 165, 113, 8, 163, 94, 59, 186, 72, 150, 59, 67, 137, 204, 45, 134, 232, 109, 119, 95, 123, 188, 90, 209, 247, 241, 40, 36, 211, 116, 67] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [8, 195, 165, 113, 8, 163, 94, 59, 186, 72, 150, 59, 67, 137, 204, 45, 134, 232, 109, 119, 95, 123, 188, 90, 209, 247, 241, 40, 36, 211, 116, 67] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 110, 105, 116, 121, 51, 100, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [8, 195, 165, 113, 8, 163, 94, 59, 186, 72, 150, 59, 67, 137, 204, 45, 134, 232, 109, 119, 95, 123, 188, 90, 209, 247, 241, 40, 36, 211, 116, 67] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [77, 24, 203, 57, 133, 98, 244, 89, 75, 175, 129, 200, 115, 156, 101, 33, 5, 126, 150, 165, 155, 154, 141, 159, 182, 8, 146, 149, 118, 127, 46, 94], legacy_session_id: SessionId { l: 32, id: [254, 115, 60, 255, 193, 233, 190, 30, 134, 41, 192, 16, 30, 124, 37, 71, 29, 200, 17, 164, 204, 87, 44, 109, 140, 244, 155, 240, 88, 227, 155, 113] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 110, 105, 116, 121, 51, 100, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [8, 195, 165, 113, 8, 163, 94, 59, 186, 72, 150, 59, 67, 137, 204, 45, 134, 232, 109, 119, 95, 123, 188, 90, 209, 247, 241, 40, 36, 211, 116, 67] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [77, 24, 203, 57, 133, 98, 244, 89, 75, 175, 129, 200, 115, 156, 101, 33, 5, 126, 150, 165, 155, 154, 141, 159, 182, 8, 146, 149, 118, 127, 46, 94], legacy_session_id: SessionId { l: 32, id: [254, 115, 60, 255, 193, 233, 190, 30, 134, 41, 192, 16, 30, 124, 37, 71, 29, 200, 17, 164, 204, 87, 44, 109, 140, 244, 155, 240, 88, 227, 155, 113] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 110, 105, 116, 121, 51, 100, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [8, 195, 165, 113, 8, 163, 94, 59, 186, 72, 150, 59, 67, 137, 204, 45, 134, 232, 109, 119, 95, 123, 188, 90, 209, 247, 241, 40, 36, 211, 116, 67] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [77, 24, 203, 57, 133, 98, 244, 89, 75, 175, 129, 200, 115, 156, 101, 33, 5, 126, 150, 165, 155, 154, 141, 159, 182, 8, 146, 149, 118, 127, 46, 94], legacy_session_id: SessionId { l: 32, id: [254, 115, 60, 255, 193, 233, 190, 30, 134, 41, 192, 16, 30, 124, 37, 71, 29, 200, 17, 164, 204, 87, 44, 109, 140, 244, 155, 240, 88, 227, 155, 113] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 110, 105, 116, 121, 51, 100, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [8, 195, 165, 113, 8, 163, 94, 59, 186, 72, 150, 59, 67, 137, 204, 45, 134, 232, 109, 119, 95, 123, 188, 90, 209, 247, 241, 40, 36, 211, 116, 67] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(4104d7fc60e044ee29aaab0bf37e1d7204032fa83f5985acfb11a79855b523fef340a09010c5a7c132c8f772d5fadd9321ee7521c7fcbbdfa06f1a72b94d0cf610dd) }, encoded: 100000424104d7fc60e044ee29aaab0bf37e1d7204032fa83f5985acfb11a79855b523fef340a09010c5a7c132c8f772d5fadd9321ee7521c7fcbbdfa06f1a72b94d0cf610dd }
+=====================================
+domain: reddit.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [241, 222, 56, 153, 147, 140, 46, 238, 132, 221, 40, 82, 78, 145, 70, 116, 234, 52, 134, 33, 219, 141, 223, 106, 106, 149, 141, 220, 128, 232, 204, 128] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [114, 101, 100, 100, 105, 116, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [114, 101, 100, 100, 105, 116, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [114, 101, 100, 100, 105, 116, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 101, 100, 100, 105, 116, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 101, 100, 100, 105, 116, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 101, 100, 100, 105, 116, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 101, 100, 100, 105, 116, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [196, 94, 175, 175, 111, 147, 177, 132, 180, 32, 2, 110, 22, 216, 173, 161, 61, 39, 24, 150, 93, 243, 18, 219, 104, 182, 209, 129, 112, 184, 115, 109] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [196, 94, 175, 175, 111, 147, 177, 132, 180, 32, 2, 110, 22, 216, 173, 161, 61, 39, 24, 150, 93, 243, 18, 219, 104, 182, 209, 129, 112, 184, 115, 109] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [196, 94, 175, 175, 111, 147, 177, 132, 180, 32, 2, 110, 22, 216, 173, 161, 61, 39, 24, 150, 93, 243, 18, 219, 104, 182, 209, 129, 112, 184, 115, 109] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [196, 94, 175, 175, 111, 147, 177, 132, 180, 32, 2, 110, 22, 216, 173, 161, 61, 39, 24, 150, 93, 243, 18, 219, 104, 182, 209, 129, 112, 184, 115, 109] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 101, 100, 100, 105, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [196, 94, 175, 175, 111, 147, 177, 132, 180, 32, 2, 110, 22, 216, 173, 161, 61, 39, 24, 150, 93, 243, 18, 219, 104, 182, 209, 129, 112, 184, 115, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [103, 63, 206, 203, 134, 255, 25, 128, 193, 160, 170, 154, 45, 64, 110, 11, 226, 56, 47, 178, 172, 250, 242, 25, 117, 138, 150, 154, 117, 40, 4, 6], legacy_session_id: SessionId { l: 32, id: [241, 222, 56, 153, 147, 140, 46, 238, 132, 221, 40, 82, 78, 145, 70, 116, 234, 52, 134, 33, 219, 141, 223, 106, 106, 149, 141, 220, 128, 232, 204, 128] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 101, 100, 100, 105, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [196, 94, 175, 175, 111, 147, 177, 132, 180, 32, 2, 110, 22, 216, 173, 161, 61, 39, 24, 150, 93, 243, 18, 219, 104, 182, 209, 129, 112, 184, 115, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [103, 63, 206, 203, 134, 255, 25, 128, 193, 160, 170, 154, 45, 64, 110, 11, 226, 56, 47, 178, 172, 250, 242, 25, 117, 138, 150, 154, 117, 40, 4, 6], legacy_session_id: SessionId { l: 32, id: [241, 222, 56, 153, 147, 140, 46, 238, 132, 221, 40, 82, 78, 145, 70, 116, 234, 52, 134, 33, 219, 141, 223, 106, 106, 149, 141, 220, 128, 232, 204, 128] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 101, 100, 100, 105, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [196, 94, 175, 175, 111, 147, 177, 132, 180, 32, 2, 110, 22, 216, 173, 161, 61, 39, 24, 150, 93, 243, 18, 219, 104, 182, 209, 129, 112, 184, 115, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [103, 63, 206, 203, 134, 255, 25, 128, 193, 160, 170, 154, 45, 64, 110, 11, 226, 56, 47, 178, 172, 250, 242, 25, 117, 138, 150, 154, 117, 40, 4, 6], legacy_session_id: SessionId { l: 32, id: [241, 222, 56, 153, 147, 140, 46, 238, 132, 221, 40, 82, 78, 145, 70, 116, 234, 52, 134, 33, 219, 141, 223, 106, 106, 149, 141, 220, 128, 232, 204, 128] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [114, 101, 100, 100, 105, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [196, 94, 175, 175, 111, 147, 177, 132, 180, 32, 2, 110, 22, 216, 173, 161, 61, 39, 24, 150, 93, 243, 18, 219, 104, 182, 209, 129, 112, 184, 115, 109] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: samsung.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [187, 45, 253, 97, 50, 117, 238, 167, 228, 236, 108, 64, 86, 201, 35, 119, 255, 158, 82, 11, 219, 145, 141, 180, 35, 180, 223, 181, 71, 184, 10, 155] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [115, 97, 109, 115, 117, 110, 103, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [115, 97, 109, 115, 117, 110, 103, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [115, 97, 109, 115, 117, 110, 103, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 97, 109, 115, 117, 110, 103, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 97, 109, 115, 117, 110, 103, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 97, 109, 115, 117, 110, 103, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 97, 109, 115, 117, 110, 103, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [129, 131, 150, 55, 231, 1, 101, 223, 198, 223, 138, 1, 31, 178, 212, 248, 254, 103, 194, 243, 162, 133, 8, 200, 117, 236, 137, 68, 12, 116, 36, 9] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 131, 150, 55, 231, 1, 101, 223, 198, 223, 138, 1, 31, 178, 212, 248, 254, 103, 194, 243, 162, 133, 8, 200, 117, 236, 137, 68, 12, 116, 36, 9] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 131, 150, 55, 231, 1, 101, 223, 198, 223, 138, 1, 31, 178, 212, 248, 254, 103, 194, 243, 162, 133, 8, 200, 117, 236, 137, 68, 12, 116, 36, 9] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 131, 150, 55, 231, 1, 101, 223, 198, 223, 138, 1, 31, 178, 212, 248, 254, 103, 194, 243, 162, 133, 8, 200, 117, 236, 137, 68, 12, 116, 36, 9] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 97, 109, 115, 117, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 131, 150, 55, 231, 1, 101, 223, 198, 223, 138, 1, 31, 178, 212, 248, 254, 103, 194, 243, 162, 133, 8, 200, 117, 236, 137, 68, 12, 116, 36, 9] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [250, 191, 163, 19, 29, 80, 25, 57, 213, 23, 143, 156, 174, 175, 110, 238, 176, 185, 109, 249, 65, 211, 130, 79, 40, 176, 219, 74, 158, 11, 242, 33], legacy_session_id: SessionId { l: 32, id: [187, 45, 253, 97, 50, 117, 238, 167, 228, 236, 108, 64, 86, 201, 35, 119, 255, 158, 82, 11, 219, 145, 141, 180, 35, 180, 223, 181, 71, 184, 10, 155] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 97, 109, 115, 117, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 131, 150, 55, 231, 1, 101, 223, 198, 223, 138, 1, 31, 178, 212, 248, 254, 103, 194, 243, 162, 133, 8, 200, 117, 236, 137, 68, 12, 116, 36, 9] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [250, 191, 163, 19, 29, 80, 25, 57, 213, 23, 143, 156, 174, 175, 110, 238, 176, 185, 109, 249, 65, 211, 130, 79, 40, 176, 219, 74, 158, 11, 242, 33], legacy_session_id: SessionId { l: 32, id: [187, 45, 253, 97, 50, 117, 238, 167, 228, 236, 108, 64, 86, 201, 35, 119, 255, 158, 82, 11, 219, 145, 141, 180, 35, 180, 223, 181, 71, 184, 10, 155] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 97, 109, 115, 117, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 131, 150, 55, 231, 1, 101, 223, 198, 223, 138, 1, 31, 178, 212, 248, 254, 103, 194, 243, 162, 133, 8, 200, 117, 236, 137, 68, 12, 116, 36, 9] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [250, 191, 163, 19, 29, 80, 25, 57, 213, 23, 143, 156, 174, 175, 110, 238, 176, 185, 109, 249, 65, 211, 130, 79, 40, 176, 219, 74, 158, 11, 242, 33], legacy_session_id: SessionId { l: 32, id: [187, 45, 253, 97, 50, 117, 238, 167, 228, 236, 108, 64, 86, 201, 35, 119, 255, 158, 82, 11, 219, 145, 141, 180, 35, 180, 223, 181, 71, 184, 10, 155] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [115, 97, 109, 115, 117, 110, 103, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [129, 131, 150, 55, 231, 1, 101, 223, 198, 223, 138, 1, 31, 178, 212, 248, 254, 103, 194, 243, 162, 133, 8, 200, 117, 236, 137, 68, 12, 116, 36, 9] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(4104c184778e4f0b7109f1bd894ff800f334bae95efac4173c71027cad18b9d83a63daa8ceeaca4cb8f35710f699b1f93b31541b89bb3c116e7a5d2c5230016149a0) }, encoded: 100000424104c184778e4f0b7109f1bd894ff800f334bae95efac4173c71027cad18b9d83a63daa8ceeaca4cb8f35710f699b1f93b31541b89bb3c116e7a5d2c5230016149a0 }
+=====================================
+domain: mts.ru
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [68, 173, 116, 117, 86, 130, 59, 72, 206, 66, 58, 216, 133, 32, 105, 105, 48, 194, 237, 65, 148, 210, 105, 243, 82, 88, 244, 17, 5, 160, 13, 71] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((8, Opaque1Ffff { l: 6, data: [109, 116, 115, 46, 114, 117] }))
+[trace] HostName: Ok((8, Opaque1Ffff { l: 6, data: [109, 116, 115, 46, 114, 117] }))
+[trace] ServerNameName: Ok((8, HostName(Opaque1Ffff { l: 6, data: [109, 116, 115, 46, 114, 117] })))
+[trace] ServerName: Ok((9, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [109, 116, 115, 46, 114, 117] }) }))
+[trace] ServerNameList: Ok((11, ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [109, 116, 115, 46, 114, 117] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((11, ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [109, 116, 115, 46, 114, 117] }) }]) })))
+[trace] ClientHelloExtension: Ok((15, ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [109, 116, 115, 46, 114, 117] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [16, 175, 225, 179, 85, 89, 77, 246, 170, 99, 199, 219, 118, 195, 161, 185, 19, 215, 1, 142, 240, 90, 44, 221, 186, 112, 154, 176, 57, 226, 102, 81] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 175, 225, 179, 85, 89, 77, 246, 170, 99, 199, 219, 118, 195, 161, 185, 19, 215, 1, 142, 240, 90, 44, 221, 186, 112, 154, 176, 57, 226, 102, 81] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 175, 225, 179, 85, 89, 77, 246, 170, 99, 199, 219, 118, 195, 161, 185, 19, 215, 1, 142, 240, 90, 44, 221, 186, 112, 154, 176, 57, 226, 102, 81] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 175, 225, 179, 85, 89, 77, 246, 170, 99, 199, 219, 118, 195, 161, 185, 19, 215, 1, 142, 240, 90, 44, 221, 186, 112, 154, 176, 57, 226, 102, 81] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((225, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((225, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((229, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [109, 116, 115, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 175, 225, 179, 85, 89, 77, 246, 170, 99, 199, 219, 118, 195, 161, 185, 19, 215, 1, 142, 240, 90, 44, 221, 186, 112, 154, 176, 57, 226, 102, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [162, 46, 135, 199, 44, 151, 199, 77, 124, 119, 0, 23, 207, 143, 207, 52, 141, 196, 111, 84, 114, 192, 162, 142, 14, 39, 198, 206, 161, 239, 94, 196], legacy_session_id: SessionId { l: 32, id: [68, 173, 116, 117, 86, 130, 59, 72, 206, 66, 58, 216, 133, 32, 105, 105, 48, 194, 237, 65, 148, 210, 105, 243, 82, 88, 244, 17, 5, 160, 13, 71] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [109, 116, 115, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 175, 225, 179, 85, 89, 77, 246, 170, 99, 199, 219, 118, 195, 161, 185, 19, 215, 1, 142, 240, 90, 44, 221, 186, 112, 154, 176, 57, 226, 102, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [162, 46, 135, 199, 44, 151, 199, 77, 124, 119, 0, 23, 207, 143, 207, 52, 141, 196, 111, 84, 114, 192, 162, 142, 14, 39, 198, 206, 161, 239, 94, 196], legacy_session_id: SessionId { l: 32, id: [68, 173, 116, 117, 86, 130, 59, 72, 206, 66, 58, 216, 133, 32, 105, 105, 48, 194, 237, 65, 148, 210, 105, 243, 82, 88, 244, 17, 5, 160, 13, 71] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [109, 116, 115, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 175, 225, 179, 85, 89, 77, 246, 170, 99, 199, 219, 118, 195, 161, 185, 19, 215, 1, 142, 240, 90, 44, 221, 186, 112, 154, 176, 57, 226, 102, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [162, 46, 135, 199, 44, 151, 199, 77, 124, 119, 0, 23, 207, 143, 207, 52, 141, 196, 111, 84, 114, 192, 162, 142, 14, 39, 198, 206, 161, 239, 94, 196], legacy_session_id: SessionId { l: 32, id: [68, 173, 116, 117, 86, 130, 59, 72, 206, 66, 58, 216, 133, 32, 105, 105, 48, 194, 237, 65, 148, 210, 105, 243, 82, 88, 244, 17, 5, 160, 13, 71] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [109, 116, 115, 46, 114, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [16, 175, 225, 179, 85, 89, 77, 246, 170, 99, 199, 219, 118, 195, 161, 185, 19, 215, 1, 142, 240, 90, 44, 221, 186, 112, 154, 176, 57, 226, 102, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: baidu.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [118, 206, 207, 59, 168, 102, 244, 172, 75, 39, 250, 142, 181, 87, 219, 75, 151, 25, 176, 255, 223, 128, 219, 32, 154, 185, 212, 217, 245, 57, 27, 61] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [98, 97, 105, 100, 117, 46, 99, 111, 109] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [98, 97, 105, 100, 117, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [98, 97, 105, 100, 117, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [98, 97, 105, 100, 117, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [98, 97, 105, 100, 117, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [98, 97, 105, 100, 117, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [98, 97, 105, 100, 117, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [103, 200, 21, 34, 119, 166, 216, 105, 183, 98, 95, 149, 179, 206, 70, 133, 77, 119, 168, 219, 61, 133, 17, 60, 194, 249, 2, 138, 180, 207, 83, 50] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [103, 200, 21, 34, 119, 166, 216, 105, 183, 98, 95, 149, 179, 206, 70, 133, 77, 119, 168, 219, 61, 133, 17, 60, 194, 249, 2, 138, 180, 207, 83, 50] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [103, 200, 21, 34, 119, 166, 216, 105, 183, 98, 95, 149, 179, 206, 70, 133, 77, 119, 168, 219, 61, 133, 17, 60, 194, 249, 2, 138, 180, 207, 83, 50] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [103, 200, 21, 34, 119, 166, 216, 105, 183, 98, 95, 149, 179, 206, 70, 133, 77, 119, 168, 219, 61, 133, 17, 60, 194, 249, 2, 138, 180, 207, 83, 50] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [98, 97, 105, 100, 117, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [103, 200, 21, 34, 119, 166, 216, 105, 183, 98, 95, 149, 179, 206, 70, 133, 77, 119, 168, 219, 61, 133, 17, 60, 194, 249, 2, 138, 180, 207, 83, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [120, 5, 117, 199, 77, 79, 23, 89, 113, 21, 30, 94, 229, 237, 119, 23, 133, 130, 58, 43, 251, 238, 76, 163, 202, 54, 240, 93, 205, 125, 6, 9], legacy_session_id: SessionId { l: 32, id: [118, 206, 207, 59, 168, 102, 244, 172, 75, 39, 250, 142, 181, 87, 219, 75, 151, 25, 176, 255, 223, 128, 219, 32, 154, 185, 212, 217, 245, 57, 27, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [98, 97, 105, 100, 117, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [103, 200, 21, 34, 119, 166, 216, 105, 183, 98, 95, 149, 179, 206, 70, 133, 77, 119, 168, 219, 61, 133, 17, 60, 194, 249, 2, 138, 180, 207, 83, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [120, 5, 117, 199, 77, 79, 23, 89, 113, 21, 30, 94, 229, 237, 119, 23, 133, 130, 58, 43, 251, 238, 76, 163, 202, 54, 240, 93, 205, 125, 6, 9], legacy_session_id: SessionId { l: 32, id: [118, 206, 207, 59, 168, 102, 244, 172, 75, 39, 250, 142, 181, 87, 219, 75, 151, 25, 176, 255, 223, 128, 219, 32, 154, 185, 212, 217, 245, 57, 27, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [98, 97, 105, 100, 117, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [103, 200, 21, 34, 119, 166, 216, 105, 183, 98, 95, 149, 179, 206, 70, 133, 77, 119, 168, 219, 61, 133, 17, 60, 194, 249, 2, 138, 180, 207, 83, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [120, 5, 117, 199, 77, 79, 23, 89, 113, 21, 30, 94, 229, 237, 119, 23, 133, 130, 58, 43, 251, 238, 76, 163, 202, 54, 240, 93, 205, 125, 6, 9], legacy_session_id: SessionId { l: 32, id: [118, 206, 207, 59, 168, 102, 244, 172, 75, 39, 250, 142, 181, 87, 219, 75, 151, 25, 176, 255, 223, 128, 219, 32, 154, 185, 212, 217, 245, 57, 27, 61] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [98, 97, 105, 100, 117, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [103, 200, 21, 34, 119, 166, 216, 105, 183, 98, 95, 149, 179, 206, 70, 133, 77, 119, 168, 219, 61, 133, 17, 60, 194, 249, 2, 138, 180, 207, 83, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(4104c3cc223dcc778eaace8c0d028fb0de6446243856196a2c950454c820096bc6e1895ccfd974b73c612265a8c9c97fca328a6e670703c89cb366395a6e053e4dbf) }, encoded: 100000424104c3cc223dcc778eaace8c0d028fb0de6446243856196a2c950454c820096bc6e1895ccfd974b73c612265a8c9c97fca328a6e670703c89cb366395a6e053e4dbf }
+=====================================
+domain: telekom.de
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [143, 58, 15, 188, 116, 27, 125, 179, 97, 228, 85, 10, 34, 255, 33, 99, 213, 221, 174, 158, 50, 66, 128, 90, 250, 108, 199, 48, 16, 114, 162, 204] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [116, 101, 108, 101, 107, 111, 109, 46, 100, 101] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [116, 101, 108, 101, 107, 111, 109, 46, 100, 101] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [116, 101, 108, 101, 107, 111, 109, 46, 100, 101] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 101, 108, 101, 107, 111, 109, 46, 100, 101] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 101, 108, 101, 107, 111, 109, 46, 100, 101] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 101, 108, 101, 107, 111, 109, 46, 100, 101] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 101, 108, 101, 107, 111, 109, 46, 100, 101] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [171, 213, 179, 108, 35, 12, 0, 41, 192, 209, 112, 79, 75, 210, 153, 150, 28, 234, 201, 70, 145, 135, 188, 155, 99, 186, 165, 117, 194, 166, 110, 19] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [171, 213, 179, 108, 35, 12, 0, 41, 192, 209, 112, 79, 75, 210, 153, 150, 28, 234, 201, 70, 145, 135, 188, 155, 99, 186, 165, 117, 194, 166, 110, 19] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [171, 213, 179, 108, 35, 12, 0, 41, 192, 209, 112, 79, 75, 210, 153, 150, 28, 234, 201, 70, 145, 135, 188, 155, 99, 186, 165, 117, 194, 166, 110, 19] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [171, 213, 179, 108, 35, 12, 0, 41, 192, 209, 112, 79, 75, 210, 153, 150, 28, 234, 201, 70, 145, 135, 188, 155, 99, 186, 165, 117, 194, 166, 110, 19] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 101, 108, 101, 107, 111, 109, 46, 100, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [171, 213, 179, 108, 35, 12, 0, 41, 192, 209, 112, 79, 75, 210, 153, 150, 28, 234, 201, 70, 145, 135, 188, 155, 99, 186, 165, 117, 194, 166, 110, 19] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [146, 196, 53, 242, 40, 175, 136, 0, 48, 59, 172, 18, 29, 103, 49, 94, 14, 66, 141, 43, 204, 54, 41, 143, 25, 18, 226, 94, 211, 126, 160, 185], legacy_session_id: SessionId { l: 32, id: [143, 58, 15, 188, 116, 27, 125, 179, 97, 228, 85, 10, 34, 255, 33, 99, 213, 221, 174, 158, 50, 66, 128, 90, 250, 108, 199, 48, 16, 114, 162, 204] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 101, 108, 101, 107, 111, 109, 46, 100, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [171, 213, 179, 108, 35, 12, 0, 41, 192, 209, 112, 79, 75, 210, 153, 150, 28, 234, 201, 70, 145, 135, 188, 155, 99, 186, 165, 117, 194, 166, 110, 19] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [146, 196, 53, 242, 40, 175, 136, 0, 48, 59, 172, 18, 29, 103, 49, 94, 14, 66, 141, 43, 204, 54, 41, 143, 25, 18, 226, 94, 211, 126, 160, 185], legacy_session_id: SessionId { l: 32, id: [143, 58, 15, 188, 116, 27, 125, 179, 97, 228, 85, 10, 34, 255, 33, 99, 213, 221, 174, 158, 50, 66, 128, 90, 250, 108, 199, 48, 16, 114, 162, 204] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 101, 108, 101, 107, 111, 109, 46, 100, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [171, 213, 179, 108, 35, 12, 0, 41, 192, 209, 112, 79, 75, 210, 153, 150, 28, 234, 201, 70, 145, 135, 188, 155, 99, 186, 165, 117, 194, 166, 110, 19] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [146, 196, 53, 242, 40, 175, 136, 0, 48, 59, 172, 18, 29, 103, 49, 94, 14, 66, 141, 43, 204, 54, 41, 143, 25, 18, 226, 94, 211, 126, 160, 185], legacy_session_id: SessionId { l: 32, id: [143, 58, 15, 188, 116, 27, 125, 179, 97, 228, 85, 10, 34, 255, 33, 99, 213, 221, 174, 158, 50, 66, 128, 90, 250, 108, 199, 48, 16, 114, 162, 204] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 101, 108, 101, 107, 111, 109, 46, 100, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [171, 213, 179, 108, 35, 12, 0, 41, 192, 209, 112, 79, 75, 210, 153, 150, 28, 234, 201, 70, 145, 135, 188, 155, 99, 186, 165, 117, 194, 166, 110, 19] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: googleadservices.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [142, 238, 55, 208, 105, 102, 113, 134, 182, 230, 243, 6, 144, 111, 108, 72, 185, 81, 96, 126, 1, 46, 228, 1, 87, 94, 149, 103, 129, 224, 101, 198] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((22, Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 97, 100, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }))
+[trace] HostName: Ok((22, Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 97, 100, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((22, HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 97, 100, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((23, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 97, 100, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((25, ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 97, 100, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((25, ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 97, 100, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((29, ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 97, 100, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [58, 248, 116, 47, 169, 106, 132, 57, 60, 75, 191, 80, 217, 23, 12, 251, 183, 22, 193, 246, 12, 79, 252, 83, 44, 96, 214, 23, 105, 98, 155, 17] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [58, 248, 116, 47, 169, 106, 132, 57, 60, 75, 191, 80, 217, 23, 12, 251, 183, 22, 193, 246, 12, 79, 252, 83, 44, 96, 214, 23, 105, 98, 155, 17] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [58, 248, 116, 47, 169, 106, 132, 57, 60, 75, 191, 80, 217, 23, 12, 251, 183, 22, 193, 246, 12, 79, 252, 83, 44, 96, 214, 23, 105, 98, 155, 17] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [58, 248, 116, 47, 169, 106, 132, 57, 60, 75, 191, 80, 217, 23, 12, 251, 183, 22, 193, 246, 12, 79, 252, 83, 44, 96, 214, 23, 105, 98, 155, 17] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((211, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((211, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((215, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 97, 100, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [58, 248, 116, 47, 169, 106, 132, 57, 60, 75, 191, 80, 217, 23, 12, 251, 183, 22, 193, 246, 12, 79, 252, 83, 44, 96, 214, 23, 105, 98, 155, 17] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [134, 90, 197, 36, 11, 148, 171, 125, 167, 99, 90, 119, 105, 250, 167, 165, 0, 55, 204, 76, 154, 184, 136, 54, 222, 126, 117, 128, 203, 34, 114, 37], legacy_session_id: SessionId { l: 32, id: [142, 238, 55, 208, 105, 102, 113, 134, 182, 230, 243, 6, 144, 111, 108, 72, 185, 81, 96, 126, 1, 46, 228, 1, 87, 94, 149, 103, 129, 224, 101, 198] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 97, 100, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [58, 248, 116, 47, 169, 106, 132, 57, 60, 75, 191, 80, 217, 23, 12, 251, 183, 22, 193, 246, 12, 79, 252, 83, 44, 96, 214, 23, 105, 98, 155, 17] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [134, 90, 197, 36, 11, 148, 171, 125, 167, 99, 90, 119, 105, 250, 167, 165, 0, 55, 204, 76, 154, 184, 136, 54, 222, 126, 117, 128, 203, 34, 114, 37], legacy_session_id: SessionId { l: 32, id: [142, 238, 55, 208, 105, 102, 113, 134, 182, 230, 243, 6, 144, 111, 108, 72, 185, 81, 96, 126, 1, 46, 228, 1, 87, 94, 149, 103, 129, 224, 101, 198] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 97, 100, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [58, 248, 116, 47, 169, 106, 132, 57, 60, 75, 191, 80, 217, 23, 12, 251, 183, 22, 193, 246, 12, 79, 252, 83, 44, 96, 214, 23, 105, 98, 155, 17] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [134, 90, 197, 36, 11, 148, 171, 125, 167, 99, 90, 119, 105, 250, 167, 165, 0, 55, 204, 76, 154, 184, 136, 54, 222, 126, 117, 128, 203, 34, 114, 37], legacy_session_id: SessionId { l: 32, id: [142, 238, 55, 208, 105, 102, 113, 134, 182, 230, 243, 6, 144, 111, 108, 72, 185, 81, 96, 126, 1, 46, 228, 1, 87, 94, 149, 103, 129, 224, 101, 198] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 25, extension_data: ServerName(ServerNameList { l: 23, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 20, data: [103, 111, 111, 103, 108, 101, 97, 100, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [58, 248, 116, 47, 169, 106, 132, 57, 60, 75, 191, 80, 217, 23, 12, 251, 183, 22, 193, 246, 12, 79, 252, 83, 44, 96, 214, 23, 105, 98, 155, 17] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 211, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: snapchat.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [228, 61, 185, 114, 122, 11, 255, 125, 68, 78, 184, 192, 229, 148, 138, 252, 34, 220, 206, 79, 197, 8, 217, 252, 217, 214, 11, 49, 138, 144, 94, 244] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((14, Opaque1Ffff { l: 12, data: [115, 110, 97, 112, 99, 104, 97, 116, 46, 99, 111, 109] }))
+[trace] HostName: Ok((14, Opaque1Ffff { l: 12, data: [115, 110, 97, 112, 99, 104, 97, 116, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((14, HostName(Opaque1Ffff { l: 12, data: [115, 110, 97, 112, 99, 104, 97, 116, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((15, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [115, 110, 97, 112, 99, 104, 97, 116, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((17, ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [115, 110, 97, 112, 99, 104, 97, 116, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((17, ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [115, 110, 97, 112, 99, 104, 97, 116, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((21, ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [115, 110, 97, 112, 99, 104, 97, 116, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [113, 151, 49, 253, 18, 30, 5, 210, 152, 104, 24, 209, 217, 255, 62, 202, 94, 225, 28, 237, 77, 210, 36, 30, 83, 36, 20, 109, 79, 55, 43, 14] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [113, 151, 49, 253, 18, 30, 5, 210, 152, 104, 24, 209, 217, 255, 62, 202, 94, 225, 28, 237, 77, 210, 36, 30, 83, 36, 20, 109, 79, 55, 43, 14] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [113, 151, 49, 253, 18, 30, 5, 210, 152, 104, 24, 209, 217, 255, 62, 202, 94, 225, 28, 237, 77, 210, 36, 30, 83, 36, 20, 109, 79, 55, 43, 14] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [113, 151, 49, 253, 18, 30, 5, 210, 152, 104, 24, 209, 217, 255, 62, 202, 94, 225, 28, 237, 77, 210, 36, 30, 83, 36, 20, 109, 79, 55, 43, 14] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((219, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((219, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((223, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [115, 110, 97, 112, 99, 104, 97, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [113, 151, 49, 253, 18, 30, 5, 210, 152, 104, 24, 209, 217, 255, 62, 202, 94, 225, 28, 237, 77, 210, 36, 30, 83, 36, 20, 109, 79, 55, 43, 14] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [96, 79, 100, 61, 55, 27, 179, 183, 208, 137, 45, 227, 49, 0, 220, 24, 199, 185, 86, 115, 193, 81, 99, 187, 176, 118, 245, 182, 122, 168, 173, 177], legacy_session_id: SessionId { l: 32, id: [228, 61, 185, 114, 122, 11, 255, 125, 68, 78, 184, 192, 229, 148, 138, 252, 34, 220, 206, 79, 197, 8, 217, 252, 217, 214, 11, 49, 138, 144, 94, 244] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [115, 110, 97, 112, 99, 104, 97, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [113, 151, 49, 253, 18, 30, 5, 210, 152, 104, 24, 209, 217, 255, 62, 202, 94, 225, 28, 237, 77, 210, 36, 30, 83, 36, 20, 109, 79, 55, 43, 14] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [96, 79, 100, 61, 55, 27, 179, 183, 208, 137, 45, 227, 49, 0, 220, 24, 199, 185, 86, 115, 193, 81, 99, 187, 176, 118, 245, 182, 122, 168, 173, 177], legacy_session_id: SessionId { l: 32, id: [228, 61, 185, 114, 122, 11, 255, 125, 68, 78, 184, 192, 229, 148, 138, 252, 34, 220, 206, 79, 197, 8, 217, 252, 217, 214, 11, 49, 138, 144, 94, 244] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [115, 110, 97, 112, 99, 104, 97, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [113, 151, 49, 253, 18, 30, 5, 210, 152, 104, 24, 209, 217, 255, 62, 202, 94, 225, 28, 237, 77, 210, 36, 30, 83, 36, 20, 109, 79, 55, 43, 14] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [96, 79, 100, 61, 55, 27, 179, 183, 208, 137, 45, 227, 49, 0, 220, 24, 199, 185, 86, 115, 193, 81, 99, 187, 176, 118, 245, 182, 122, 168, 173, 177], legacy_session_id: SessionId { l: 32, id: [228, 61, 185, 114, 122, 11, 255, 125, 68, 78, 184, 192, 229, 148, 138, 252, 34, 220, 206, 79, 197, 8, 217, 252, 217, 214, 11, 49, 138, 144, 94, 244] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [115, 110, 97, 112, 99, 104, 97, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [113, 151, 49, 253, 18, 30, 5, 210, 152, 104, 24, 209, 217, 255, 62, 202, 94, 225, 28, 237, 77, 210, 36, 30, 83, 36, 20, 109, 79, 55, 43, 14] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: europa.eu
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [226, 90, 41, 202, 131, 198, 32, 71, 59, 196, 241, 211, 169, 203, 168, 194, 115, 40, 125, 138, 197, 121, 220, 124, 25, 210, 199, 220, 78, 172, 68, 100] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [101, 117, 114, 111, 112, 97, 46, 101, 117] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [101, 117, 114, 111, 112, 97, 46, 101, 117] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [101, 117, 114, 111, 112, 97, 46, 101, 117] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [101, 117, 114, 111, 112, 97, 46, 101, 117] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [101, 117, 114, 111, 112, 97, 46, 101, 117] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [101, 117, 114, 111, 112, 97, 46, 101, 117] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [101, 117, 114, 111, 112, 97, 46, 101, 117] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [204, 167, 239, 133, 20, 33, 17, 23, 232, 173, 172, 146, 69, 232, 114, 144, 126, 169, 49, 172, 173, 172, 99, 202, 47, 69, 33, 217, 42, 77, 0, 5] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 167, 239, 133, 20, 33, 17, 23, 232, 173, 172, 146, 69, 232, 114, 144, 126, 169, 49, 172, 173, 172, 99, 202, 47, 69, 33, 217, 42, 77, 0, 5] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 167, 239, 133, 20, 33, 17, 23, 232, 173, 172, 146, 69, 232, 114, 144, 126, 169, 49, 172, 173, 172, 99, 202, 47, 69, 33, 217, 42, 77, 0, 5] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 167, 239, 133, 20, 33, 17, 23, 232, 173, 172, 146, 69, 232, 114, 144, 126, 169, 49, 172, 173, 172, 99, 202, 47, 69, 33, 217, 42, 77, 0, 5] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [101, 117, 114, 111, 112, 97, 46, 101, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 167, 239, 133, 20, 33, 17, 23, 232, 173, 172, 146, 69, 232, 114, 144, 126, 169, 49, 172, 173, 172, 99, 202, 47, 69, 33, 217, 42, 77, 0, 5] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [238, 249, 154, 9, 18, 58, 248, 84, 190, 203, 67, 190, 191, 15, 73, 8, 217, 168, 190, 94, 55, 164, 79, 150, 227, 51, 139, 19, 198, 223, 70, 119], legacy_session_id: SessionId { l: 32, id: [226, 90, 41, 202, 131, 198, 32, 71, 59, 196, 241, 211, 169, 203, 168, 194, 115, 40, 125, 138, 197, 121, 220, 124, 25, 210, 199, 220, 78, 172, 68, 100] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [101, 117, 114, 111, 112, 97, 46, 101, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 167, 239, 133, 20, 33, 17, 23, 232, 173, 172, 146, 69, 232, 114, 144, 126, 169, 49, 172, 173, 172, 99, 202, 47, 69, 33, 217, 42, 77, 0, 5] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [238, 249, 154, 9, 18, 58, 248, 84, 190, 203, 67, 190, 191, 15, 73, 8, 217, 168, 190, 94, 55, 164, 79, 150, 227, 51, 139, 19, 198, 223, 70, 119], legacy_session_id: SessionId { l: 32, id: [226, 90, 41, 202, 131, 198, 32, 71, 59, 196, 241, 211, 169, 203, 168, 194, 115, 40, 125, 138, 197, 121, 220, 124, 25, 210, 199, 220, 78, 172, 68, 100] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [101, 117, 114, 111, 112, 97, 46, 101, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 167, 239, 133, 20, 33, 17, 23, 232, 173, 172, 146, 69, 232, 114, 144, 126, 169, 49, 172, 173, 172, 99, 202, 47, 69, 33, 217, 42, 77, 0, 5] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [238, 249, 154, 9, 18, 58, 248, 84, 190, 203, 67, 190, 191, 15, 73, 8, 217, 168, 190, 94, 55, 164, 79, 150, 227, 51, 139, 19, 198, 223, 70, 119], legacy_session_id: SessionId { l: 32, id: [226, 90, 41, 202, 131, 198, 32, 71, 59, 196, 241, 211, 169, 203, 168, 194, 115, 40, 125, 138, 197, 121, 220, 124, 25, 210, 199, 220, 78, 172, 68, 100] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [101, 117, 114, 111, 112, 97, 46, 101, 117] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [204, 167, 239, 133, 20, 33, 17, 23, 232, 173, 172, 146, 69, 232, 114, 144, 126, 169, 49, 172, 173, 172, 99, 202, 47, 69, 33, 217, 42, 77, 0, 5] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: googledomains.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [244, 6, 117, 160, 103, 102, 30, 46, 217, 221, 228, 240, 138, 236, 249, 191, 112, 61, 88, 174, 53, 243, 56, 202, 107, 122, 48, 89, 5, 229, 76, 71] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((19, Opaque1Ffff { l: 17, data: [103, 111, 111, 103, 108, 101, 100, 111, 109, 97, 105, 110, 115, 46, 99, 111, 109] }))
+[trace] HostName: Ok((19, Opaque1Ffff { l: 17, data: [103, 111, 111, 103, 108, 101, 100, 111, 109, 97, 105, 110, 115, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((19, HostName(Opaque1Ffff { l: 17, data: [103, 111, 111, 103, 108, 101, 100, 111, 109, 97, 105, 110, 115, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((20, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 17, data: [103, 111, 111, 103, 108, 101, 100, 111, 109, 97, 105, 110, 115, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((22, ServerNameList { l: 20, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 17, data: [103, 111, 111, 103, 108, 101, 100, 111, 109, 97, 105, 110, 115, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, ServerName(ServerNameList { l: 20, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 17, data: [103, 111, 111, 103, 108, 101, 100, 111, 109, 97, 105, 110, 115, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 0, ext_len: 22, extension_data: ServerName(ServerNameList { l: 20, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 17, data: [103, 111, 111, 103, 108, 101, 100, 111, 109, 97, 105, 110, 115, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [37, 33, 115, 253, 92, 185, 37, 224, 106, 128, 132, 148, 19, 189, 1, 50, 38, 86, 43, 117, 140, 66, 12, 171, 86, 15, 168, 138, 153, 224, 117, 67] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 33, 115, 253, 92, 185, 37, 224, 106, 128, 132, 148, 19, 189, 1, 50, 38, 86, 43, 117, 140, 66, 12, 171, 86, 15, 168, 138, 153, 224, 117, 67] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 33, 115, 253, 92, 185, 37, 224, 106, 128, 132, 148, 19, 189, 1, 50, 38, 86, 43, 117, 140, 66, 12, 171, 86, 15, 168, 138, 153, 224, 117, 67] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 33, 115, 253, 92, 185, 37, 224, 106, 128, 132, 148, 19, 189, 1, 50, 38, 86, 43, 117, 140, 66, 12, 171, 86, 15, 168, 138, 153, 224, 117, 67] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((214, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((214, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((218, ClientHelloExtension { extension_type: 21, ext_len: 214, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 22, extension_data: ServerName(ServerNameList { l: 20, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 17, data: [103, 111, 111, 103, 108, 101, 100, 111, 109, 97, 105, 110, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 33, 115, 253, 92, 185, 37, 224, 106, 128, 132, 148, 19, 189, 1, 50, 38, 86, 43, 117, 140, 66, 12, 171, 86, 15, 168, 138, 153, 224, 117, 67] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 214, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [125, 110, 102, 230, 43, 119, 201, 36, 52, 56, 234, 165, 119, 172, 245, 71, 126, 108, 62, 238, 17, 232, 56, 230, 38, 213, 242, 37, 199, 119, 129, 228], legacy_session_id: SessionId { l: 32, id: [244, 6, 117, 160, 103, 102, 30, 46, 217, 221, 228, 240, 138, 236, 249, 191, 112, 61, 88, 174, 53, 243, 56, 202, 107, 122, 48, 89, 5, 229, 76, 71] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 22, extension_data: ServerName(ServerNameList { l: 20, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 17, data: [103, 111, 111, 103, 108, 101, 100, 111, 109, 97, 105, 110, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 33, 115, 253, 92, 185, 37, 224, 106, 128, 132, 148, 19, 189, 1, 50, 38, 86, 43, 117, 140, 66, 12, 171, 86, 15, 168, 138, 153, 224, 117, 67] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 214, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [125, 110, 102, 230, 43, 119, 201, 36, 52, 56, 234, 165, 119, 172, 245, 71, 126, 108, 62, 238, 17, 232, 56, 230, 38, 213, 242, 37, 199, 119, 129, 228], legacy_session_id: SessionId { l: 32, id: [244, 6, 117, 160, 103, 102, 30, 46, 217, 221, 228, 240, 138, 236, 249, 191, 112, 61, 88, 174, 53, 243, 56, 202, 107, 122, 48, 89, 5, 229, 76, 71] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 22, extension_data: ServerName(ServerNameList { l: 20, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 17, data: [103, 111, 111, 103, 108, 101, 100, 111, 109, 97, 105, 110, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 33, 115, 253, 92, 185, 37, 224, 106, 128, 132, 148, 19, 189, 1, 50, 38, 86, 43, 117, 140, 66, 12, 171, 86, 15, 168, 138, 153, 224, 117, 67] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 214, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [125, 110, 102, 230, 43, 119, 201, 36, 52, 56, 234, 165, 119, 172, 245, 71, 126, 108, 62, 238, 17, 232, 56, 230, 38, 213, 242, 37, 199, 119, 129, 228], legacy_session_id: SessionId { l: 32, id: [244, 6, 117, 160, 103, 102, 30, 46, 217, 221, 228, 240, 138, 236, 249, 191, 112, 61, 88, 174, 53, 243, 56, 202, 107, 122, 48, 89, 5, 229, 76, 71] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 22, extension_data: ServerName(ServerNameList { l: 20, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 17, data: [103, 111, 111, 103, 108, 101, 100, 111, 109, 97, 105, 110, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [37, 33, 115, 253, 92, 185, 37, 224, 106, 128, 132, 148, 19, 189, 1, 50, 38, 86, 43, 117, 140, 66, 12, 171, 86, 15, 168, 138, 153, 224, 117, 67] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 214, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: intuit.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [178, 211, 153, 93, 40, 135, 9, 60, 216, 128, 127, 118, 92, 22, 240, 193, 88, 110, 224, 52, 203, 59, 85, 89, 111, 103, 111, 132, 246, 169, 154, 196] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [105, 110, 116, 117, 105, 116, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [105, 110, 116, 117, 105, 116, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [105, 110, 116, 117, 105, 116, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 110, 116, 117, 105, 116, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 110, 116, 117, 105, 116, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 110, 116, 117, 105, 116, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 110, 116, 117, 105, 116, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [59, 80, 125, 114, 191, 116, 254, 17, 156, 215, 105, 17, 105, 200, 140, 137, 94, 95, 133, 35, 6, 225, 45, 234, 180, 127, 77, 70, 92, 39, 112, 76] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [59, 80, 125, 114, 191, 116, 254, 17, 156, 215, 105, 17, 105, 200, 140, 137, 94, 95, 133, 35, 6, 225, 45, 234, 180, 127, 77, 70, 92, 39, 112, 76] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [59, 80, 125, 114, 191, 116, 254, 17, 156, 215, 105, 17, 105, 200, 140, 137, 94, 95, 133, 35, 6, 225, 45, 234, 180, 127, 77, 70, 92, 39, 112, 76] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [59, 80, 125, 114, 191, 116, 254, 17, 156, 215, 105, 17, 105, 200, 140, 137, 94, 95, 133, 35, 6, 225, 45, 234, 180, 127, 77, 70, 92, 39, 112, 76] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 110, 116, 117, 105, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [59, 80, 125, 114, 191, 116, 254, 17, 156, 215, 105, 17, 105, 200, 140, 137, 94, 95, 133, 35, 6, 225, 45, 234, 180, 127, 77, 70, 92, 39, 112, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [130, 0, 36, 111, 201, 232, 246, 156, 23, 140, 91, 12, 138, 185, 128, 69, 202, 252, 150, 2, 219, 103, 200, 21, 149, 181, 16, 249, 19, 127, 4, 205], legacy_session_id: SessionId { l: 32, id: [178, 211, 153, 93, 40, 135, 9, 60, 216, 128, 127, 118, 92, 22, 240, 193, 88, 110, 224, 52, 203, 59, 85, 89, 111, 103, 111, 132, 246, 169, 154, 196] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 110, 116, 117, 105, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [59, 80, 125, 114, 191, 116, 254, 17, 156, 215, 105, 17, 105, 200, 140, 137, 94, 95, 133, 35, 6, 225, 45, 234, 180, 127, 77, 70, 92, 39, 112, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [130, 0, 36, 111, 201, 232, 246, 156, 23, 140, 91, 12, 138, 185, 128, 69, 202, 252, 150, 2, 219, 103, 200, 21, 149, 181, 16, 249, 19, 127, 4, 205], legacy_session_id: SessionId { l: 32, id: [178, 211, 153, 93, 40, 135, 9, 60, 216, 128, 127, 118, 92, 22, 240, 193, 88, 110, 224, 52, 203, 59, 85, 89, 111, 103, 111, 132, 246, 169, 154, 196] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 110, 116, 117, 105, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [59, 80, 125, 114, 191, 116, 254, 17, 156, 215, 105, 17, 105, 200, 140, 137, 94, 95, 133, 35, 6, 225, 45, 234, 180, 127, 77, 70, 92, 39, 112, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [130, 0, 36, 111, 201, 232, 246, 156, 23, 140, 91, 12, 138, 185, 128, 69, 202, 252, 150, 2, 219, 103, 200, 21, 149, 181, 16, 249, 19, 127, 4, 205], legacy_session_id: SessionId { l: 32, id: [178, 211, 153, 93, 40, 135, 9, 60, 216, 128, 127, 118, 92, 22, 240, 193, 88, 110, 224, 52, 203, 59, 85, 89, 111, 103, 111, 132, 246, 169, 154, 196] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [105, 110, 116, 117, 105, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [59, 80, 125, 114, 191, 116, 254, 17, 156, 215, 105, 17, 105, 200, 140, 137, 94, 95, 133, 35, 6, 225, 45, 234, 180, 127, 77, 70, 92, 39, 112, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: wa.me
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [223, 3, 109, 216, 168, 67, 166, 63, 232, 17, 202, 10, 190, 22, 97, 28, 209, 150, 194, 68, 106, 144, 212, 117, 185, 176, 127, 254, 210, 144, 27, 180] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((7, Opaque1Ffff { l: 5, data: [119, 97, 46, 109, 101] }))
+[trace] HostName: Ok((7, Opaque1Ffff { l: 5, data: [119, 97, 46, 109, 101] }))
+[trace] ServerNameName: Ok((7, HostName(Opaque1Ffff { l: 5, data: [119, 97, 46, 109, 101] })))
+[trace] ServerName: Ok((8, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [119, 97, 46, 109, 101] }) }))
+[trace] ServerNameList: Ok((10, ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [119, 97, 46, 109, 101] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((10, ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [119, 97, 46, 109, 101] }) }]) })))
+[trace] ClientHelloExtension: Ok((14, ClientHelloExtension { extension_type: 0, ext_len: 10, extension_data: ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [119, 97, 46, 109, 101] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [211, 23, 29, 98, 201, 103, 253, 183, 98, 31, 10, 58, 55, 195, 29, 253, 232, 72, 153, 105, 112, 144, 166, 203, 186, 238, 117, 151, 124, 255, 207, 64] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [211, 23, 29, 98, 201, 103, 253, 183, 98, 31, 10, 58, 55, 195, 29, 253, 232, 72, 153, 105, 112, 144, 166, 203, 186, 238, 117, 151, 124, 255, 207, 64] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [211, 23, 29, 98, 201, 103, 253, 183, 98, 31, 10, 58, 55, 195, 29, 253, 232, 72, 153, 105, 112, 144, 166, 203, 186, 238, 117, 151, 124, 255, 207, 64] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [211, 23, 29, 98, 201, 103, 253, 183, 98, 31, 10, 58, 55, 195, 29, 253, 232, 72, 153, 105, 112, 144, 166, 203, 186, 238, 117, 151, 124, 255, 207, 64] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((226, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((226, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((230, ClientHelloExtension { extension_type: 21, ext_len: 226, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 10, extension_data: ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [119, 97, 46, 109, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [211, 23, 29, 98, 201, 103, 253, 183, 98, 31, 10, 58, 55, 195, 29, 253, 232, 72, 153, 105, 112, 144, 166, 203, 186, 238, 117, 151, 124, 255, 207, 64] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 226, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [85, 159, 54, 247, 95, 136, 151, 141, 40, 204, 209, 52, 128, 216, 100, 98, 113, 49, 224, 66, 109, 3, 127, 174, 38, 170, 113, 224, 213, 97, 220, 192], legacy_session_id: SessionId { l: 32, id: [223, 3, 109, 216, 168, 67, 166, 63, 232, 17, 202, 10, 190, 22, 97, 28, 209, 150, 194, 68, 106, 144, 212, 117, 185, 176, 127, 254, 210, 144, 27, 180] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 10, extension_data: ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [119, 97, 46, 109, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [211, 23, 29, 98, 201, 103, 253, 183, 98, 31, 10, 58, 55, 195, 29, 253, 232, 72, 153, 105, 112, 144, 166, 203, 186, 238, 117, 151, 124, 255, 207, 64] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 226, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [85, 159, 54, 247, 95, 136, 151, 141, 40, 204, 209, 52, 128, 216, 100, 98, 113, 49, 224, 66, 109, 3, 127, 174, 38, 170, 113, 224, 213, 97, 220, 192], legacy_session_id: SessionId { l: 32, id: [223, 3, 109, 216, 168, 67, 166, 63, 232, 17, 202, 10, 190, 22, 97, 28, 209, 150, 194, 68, 106, 144, 212, 117, 185, 176, 127, 254, 210, 144, 27, 180] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 10, extension_data: ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [119, 97, 46, 109, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [211, 23, 29, 98, 201, 103, 253, 183, 98, 31, 10, 58, 55, 195, 29, 253, 232, 72, 153, 105, 112, 144, 166, 203, 186, 238, 117, 151, 124, 255, 207, 64] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 226, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [85, 159, 54, 247, 95, 136, 151, 141, 40, 204, 209, 52, 128, 216, 100, 98, 113, 49, 224, 66, 109, 3, 127, 174, 38, 170, 113, 224, 213, 97, 220, 192], legacy_session_id: SessionId { l: 32, id: [223, 3, 109, 216, 168, 67, 166, 63, 232, 17, 202, 10, 190, 22, 97, 28, 209, 150, 194, 68, 106, 144, 212, 117, 185, 176, 127, 254, 210, 144, 27, 180] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 10, extension_data: ServerName(ServerNameList { l: 8, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 5, data: [119, 97, 46, 109, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [211, 23, 29, 98, 201, 103, 253, 183, 98, 31, 10, 58, 55, 195, 29, 253, 232, 72, 153, 105, 112, 144, 166, 203, 186, 238, 117, 151, 124, 255, 207, 64] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 226, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: t.me
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [40, 45, 37, 187, 219, 19, 23, 7, 22, 0, 207, 156, 206, 52, 95, 14, 130, 231, 140, 114, 165, 210, 100, 96, 80, 222, 80, 159, 230, 87, 196, 219] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((6, Opaque1Ffff { l: 4, data: [116, 46, 109, 101] }))
+[trace] HostName: Ok((6, Opaque1Ffff { l: 4, data: [116, 46, 109, 101] }))
+[trace] ServerNameName: Ok((6, HostName(Opaque1Ffff { l: 4, data: [116, 46, 109, 101] })))
+[trace] ServerName: Ok((7, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 4, data: [116, 46, 109, 101] }) }))
+[trace] ServerNameList: Ok((9, ServerNameList { l: 7, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 4, data: [116, 46, 109, 101] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((9, ServerName(ServerNameList { l: 7, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 4, data: [116, 46, 109, 101] }) }]) })))
+[trace] ClientHelloExtension: Ok((13, ClientHelloExtension { extension_type: 0, ext_len: 9, extension_data: ServerName(ServerNameList { l: 7, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 4, data: [116, 46, 109, 101] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [221, 164, 15, 234, 135, 18, 123, 139, 65, 58, 12, 178, 162, 39, 110, 179, 176, 89, 120, 186, 9, 144, 27, 58, 101, 180, 135, 112, 167, 132, 87, 30] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [221, 164, 15, 234, 135, 18, 123, 139, 65, 58, 12, 178, 162, 39, 110, 179, 176, 89, 120, 186, 9, 144, 27, 58, 101, 180, 135, 112, 167, 132, 87, 30] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [221, 164, 15, 234, 135, 18, 123, 139, 65, 58, 12, 178, 162, 39, 110, 179, 176, 89, 120, 186, 9, 144, 27, 58, 101, 180, 135, 112, 167, 132, 87, 30] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [221, 164, 15, 234, 135, 18, 123, 139, 65, 58, 12, 178, 162, 39, 110, 179, 176, 89, 120, 186, 9, 144, 27, 58, 101, 180, 135, 112, 167, 132, 87, 30] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((227, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((227, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((231, ClientHelloExtension { extension_type: 21, ext_len: 227, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 9, extension_data: ServerName(ServerNameList { l: 7, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 4, data: [116, 46, 109, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [221, 164, 15, 234, 135, 18, 123, 139, 65, 58, 12, 178, 162, 39, 110, 179, 176, 89, 120, 186, 9, 144, 27, 58, 101, 180, 135, 112, 167, 132, 87, 30] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 227, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [144, 76, 67, 147, 52, 47, 194, 83, 46, 138, 128, 73, 39, 40, 200, 232, 83, 148, 66, 213, 16, 11, 111, 122, 184, 41, 158, 55, 92, 46, 158, 208], legacy_session_id: SessionId { l: 32, id: [40, 45, 37, 187, 219, 19, 23, 7, 22, 0, 207, 156, 206, 52, 95, 14, 130, 231, 140, 114, 165, 210, 100, 96, 80, 222, 80, 159, 230, 87, 196, 219] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 9, extension_data: ServerName(ServerNameList { l: 7, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 4, data: [116, 46, 109, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [221, 164, 15, 234, 135, 18, 123, 139, 65, 58, 12, 178, 162, 39, 110, 179, 176, 89, 120, 186, 9, 144, 27, 58, 101, 180, 135, 112, 167, 132, 87, 30] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 227, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [144, 76, 67, 147, 52, 47, 194, 83, 46, 138, 128, 73, 39, 40, 200, 232, 83, 148, 66, 213, 16, 11, 111, 122, 184, 41, 158, 55, 92, 46, 158, 208], legacy_session_id: SessionId { l: 32, id: [40, 45, 37, 187, 219, 19, 23, 7, 22, 0, 207, 156, 206, 52, 95, 14, 130, 231, 140, 114, 165, 210, 100, 96, 80, 222, 80, 159, 230, 87, 196, 219] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 9, extension_data: ServerName(ServerNameList { l: 7, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 4, data: [116, 46, 109, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [221, 164, 15, 234, 135, 18, 123, 139, 65, 58, 12, 178, 162, 39, 110, 179, 176, 89, 120, 186, 9, 144, 27, 58, 101, 180, 135, 112, 167, 132, 87, 30] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 227, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [144, 76, 67, 147, 52, 47, 194, 83, 46, 138, 128, 73, 39, 40, 200, 232, 83, 148, 66, 213, 16, 11, 111, 122, 184, 41, 158, 55, 92, 46, 158, 208], legacy_session_id: SessionId { l: 32, id: [40, 45, 37, 187, 219, 19, 23, 7, 22, 0, 207, 156, 206, 52, 95, 14, 130, 231, 140, 114, 165, 210, 100, 96, 80, 222, 80, 159, 230, 87, 196, 219] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 9, extension_data: ServerName(ServerNameList { l: 7, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 4, data: [116, 46, 109, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [221, 164, 15, 234, 135, 18, 123, 139, 65, 58, 12, 178, 162, 39, 110, 179, 176, 89, 120, 186, 9, 144, 27, 58, 101, 180, 135, 112, 167, 132, 87, 30] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 227, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: outlook.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [53, 196, 189, 83, 35, 213, 221, 82, 21, 203, 209, 109, 201, 0, 187, 81, 93, 32, 38, 34, 80, 168, 114, 96, 80, 43, 67, 176, 53, 80, 179, 239] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [111, 117, 116, 108, 111, 111, 107, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [111, 117, 116, 108, 111, 111, 107, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [111, 117, 116, 108, 111, 111, 107, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [111, 117, 116, 108, 111, 111, 107, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [111, 117, 116, 108, 111, 111, 107, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [111, 117, 116, 108, 111, 111, 107, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [111, 117, 116, 108, 111, 111, 107, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [130, 157, 93, 221, 119, 232, 146, 249, 114, 150, 107, 179, 208, 170, 253, 111, 60, 16, 23, 207, 22, 77, 184, 21, 115, 98, 222, 241, 199, 97, 84, 90] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [130, 157, 93, 221, 119, 232, 146, 249, 114, 150, 107, 179, 208, 170, 253, 111, 60, 16, 23, 207, 22, 77, 184, 21, 115, 98, 222, 241, 199, 97, 84, 90] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [130, 157, 93, 221, 119, 232, 146, 249, 114, 150, 107, 179, 208, 170, 253, 111, 60, 16, 23, 207, 22, 77, 184, 21, 115, 98, 222, 241, 199, 97, 84, 90] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [130, 157, 93, 221, 119, 232, 146, 249, 114, 150, 107, 179, 208, 170, 253, 111, 60, 16, 23, 207, 22, 77, 184, 21, 115, 98, 222, 241, 199, 97, 84, 90] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [111, 117, 116, 108, 111, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [130, 157, 93, 221, 119, 232, 146, 249, 114, 150, 107, 179, 208, 170, 253, 111, 60, 16, 23, 207, 22, 77, 184, 21, 115, 98, 222, 241, 199, 97, 84, 90] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [168, 201, 33, 192, 200, 96, 208, 165, 254, 120, 150, 231, 233, 135, 225, 79, 253, 101, 37, 139, 142, 171, 172, 100, 54, 191, 12, 231, 21, 77, 177, 72], legacy_session_id: SessionId { l: 32, id: [53, 196, 189, 83, 35, 213, 221, 82, 21, 203, 209, 109, 201, 0, 187, 81, 93, 32, 38, 34, 80, 168, 114, 96, 80, 43, 67, 176, 53, 80, 179, 239] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [111, 117, 116, 108, 111, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [130, 157, 93, 221, 119, 232, 146, 249, 114, 150, 107, 179, 208, 170, 253, 111, 60, 16, 23, 207, 22, 77, 184, 21, 115, 98, 222, 241, 199, 97, 84, 90] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [168, 201, 33, 192, 200, 96, 208, 165, 254, 120, 150, 231, 233, 135, 225, 79, 253, 101, 37, 139, 142, 171, 172, 100, 54, 191, 12, 231, 21, 77, 177, 72], legacy_session_id: SessionId { l: 32, id: [53, 196, 189, 83, 35, 213, 221, 82, 21, 203, 209, 109, 201, 0, 187, 81, 93, 32, 38, 34, 80, 168, 114, 96, 80, 43, 67, 176, 53, 80, 179, 239] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [111, 117, 116, 108, 111, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [130, 157, 93, 221, 119, 232, 146, 249, 114, 150, 107, 179, 208, 170, 253, 111, 60, 16, 23, 207, 22, 77, 184, 21, 115, 98, 222, 241, 199, 97, 84, 90] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [168, 201, 33, 192, 200, 96, 208, 165, 254, 120, 150, 231, 233, 135, 225, 79, 253, 101, 37, 139, 142, 171, 172, 100, 54, 191, 12, 231, 21, 77, 177, 72], legacy_session_id: SessionId { l: 32, id: [53, 196, 189, 83, 35, 213, 221, 82, 21, 203, 209, 109, 201, 0, 187, 81, 93, 32, 38, 34, 80, 168, 114, 96, 80, 43, 67, 176, 53, 80, 179, 239] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [111, 117, 116, 108, 111, 111, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [130, 157, 93, 221, 119, 232, 146, 249, 114, 150, 107, 179, 208, 170, 253, 111, 60, 16, 23, 207, 22, 77, 184, 21, 115, 98, 222, 241, 199, 97, 84, 90] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(610418518f2be48e57e2cd9759a25994d0f817b0a598320062d59395744a0b4a24ea266213dab40ce1d3725b75327c99fb3dfc61cb5686e6674ba47e41cb4fe4902c3e3c5f58020ff0bc112a77c20c47c57d8f46807d196a5d41b5378a94b123e43a) }, encoded: 10000062610418518f2be48e57e2cd9759a25994d0f817b0a598320062d59395744a0b4a24ea266213dab40ce1d3725b75327c99fb3dfc61cb5686e6674ba47e41cb4fe4902c3e3c5f58020ff0bc112a77c20c47c57d8f46807d196a5d41b5378a94b123e43a }
+=====================================
+domain: apache.org
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [243, 227, 63, 179, 111, 26, 136, 121, 228, 214, 115, 51, 190, 159, 61, 132, 36, 196, 164, 21, 155, 204, 130, 191, 0, 66, 69, 237, 74, 200, 10, 21] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [97, 112, 97, 99, 104, 101, 46, 111, 114, 103] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [97, 112, 97, 99, 104, 101, 46, 111, 114, 103] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [97, 112, 97, 99, 104, 101, 46, 111, 114, 103] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 112, 97, 99, 104, 101, 46, 111, 114, 103] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 112, 97, 99, 104, 101, 46, 111, 114, 103] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 112, 97, 99, 104, 101, 46, 111, 114, 103] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 112, 97, 99, 104, 101, 46, 111, 114, 103] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [162, 64, 95, 45, 6, 52, 170, 161, 86, 161, 95, 186, 85, 0, 139, 146, 239, 14, 93, 208, 174, 166, 54, 145, 11, 132, 25, 249, 77, 55, 250, 9] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [162, 64, 95, 45, 6, 52, 170, 161, 86, 161, 95, 186, 85, 0, 139, 146, 239, 14, 93, 208, 174, 166, 54, 145, 11, 132, 25, 249, 77, 55, 250, 9] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [162, 64, 95, 45, 6, 52, 170, 161, 86, 161, 95, 186, 85, 0, 139, 146, 239, 14, 93, 208, 174, 166, 54, 145, 11, 132, 25, 249, 77, 55, 250, 9] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [162, 64, 95, 45, 6, 52, 170, 161, 86, 161, 95, 186, 85, 0, 139, 146, 239, 14, 93, 208, 174, 166, 54, 145, 11, 132, 25, 249, 77, 55, 250, 9] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 112, 97, 99, 104, 101, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [162, 64, 95, 45, 6, 52, 170, 161, 86, 161, 95, 186, 85, 0, 139, 146, 239, 14, 93, 208, 174, 166, 54, 145, 11, 132, 25, 249, 77, 55, 250, 9] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [232, 255, 51, 105, 214, 13, 176, 190, 253, 231, 28, 7, 146, 100, 244, 94, 39, 135, 102, 194, 73, 173, 245, 191, 51, 17, 0, 31, 26, 242, 67, 49], legacy_session_id: SessionId { l: 32, id: [243, 227, 63, 179, 111, 26, 136, 121, 228, 214, 115, 51, 190, 159, 61, 132, 36, 196, 164, 21, 155, 204, 130, 191, 0, 66, 69, 237, 74, 200, 10, 21] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 112, 97, 99, 104, 101, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [162, 64, 95, 45, 6, 52, 170, 161, 86, 161, 95, 186, 85, 0, 139, 146, 239, 14, 93, 208, 174, 166, 54, 145, 11, 132, 25, 249, 77, 55, 250, 9] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [232, 255, 51, 105, 214, 13, 176, 190, 253, 231, 28, 7, 146, 100, 244, 94, 39, 135, 102, 194, 73, 173, 245, 191, 51, 17, 0, 31, 26, 242, 67, 49], legacy_session_id: SessionId { l: 32, id: [243, 227, 63, 179, 111, 26, 136, 121, 228, 214, 115, 51, 190, 159, 61, 132, 36, 196, 164, 21, 155, 204, 130, 191, 0, 66, 69, 237, 74, 200, 10, 21] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 112, 97, 99, 104, 101, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [162, 64, 95, 45, 6, 52, 170, 161, 86, 161, 95, 186, 85, 0, 139, 146, 239, 14, 93, 208, 174, 166, 54, 145, 11, 132, 25, 249, 77, 55, 250, 9] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [232, 255, 51, 105, 214, 13, 176, 190, 253, 231, 28, 7, 146, 100, 244, 94, 39, 135, 102, 194, 73, 173, 245, 191, 51, 17, 0, 31, 26, 242, 67, 49], legacy_session_id: SessionId { l: 32, id: [243, 227, 63, 179, 111, 26, 136, 121, 228, 214, 115, 51, 190, 159, 61, 132, 36, 196, 164, 21, 155, 204, 130, 191, 0, 66, 69, 237, 74, 200, 10, 21] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [97, 112, 97, 99, 104, 101, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [162, 64, 95, 45, 6, 52, 170, 161, 86, 161, 95, 186, 85, 0, 139, 146, 239, 14, 93, 208, 174, 166, 54, 145, 11, 132, 25, 249, 77, 55, 250, 9] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: vk.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [77, 56, 187, 18, 255, 211, 218, 219, 207, 82, 94, 30, 57, 100, 113, 32, 52, 58, 113, 211, 189, 32, 183, 31, 132, 152, 65, 237, 220, 208, 138, 37] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((8, Opaque1Ffff { l: 6, data: [118, 107, 46, 99, 111, 109] }))
+[trace] HostName: Ok((8, Opaque1Ffff { l: 6, data: [118, 107, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((8, HostName(Opaque1Ffff { l: 6, data: [118, 107, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((9, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [118, 107, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((11, ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [118, 107, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((11, ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [118, 107, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((15, ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [118, 107, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [178, 121, 151, 100, 18, 110, 102, 120, 17, 75, 92, 185, 36, 186, 81, 2, 197, 27, 70, 46, 120, 16, 207, 175, 142, 241, 196, 62, 199, 166, 151, 38] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [178, 121, 151, 100, 18, 110, 102, 120, 17, 75, 92, 185, 36, 186, 81, 2, 197, 27, 70, 46, 120, 16, 207, 175, 142, 241, 196, 62, 199, 166, 151, 38] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [178, 121, 151, 100, 18, 110, 102, 120, 17, 75, 92, 185, 36, 186, 81, 2, 197, 27, 70, 46, 120, 16, 207, 175, 142, 241, 196, 62, 199, 166, 151, 38] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [178, 121, 151, 100, 18, 110, 102, 120, 17, 75, 92, 185, 36, 186, 81, 2, 197, 27, 70, 46, 120, 16, 207, 175, 142, 241, 196, 62, 199, 166, 151, 38] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((225, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((225, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((229, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [118, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [178, 121, 151, 100, 18, 110, 102, 120, 17, 75, 92, 185, 36, 186, 81, 2, 197, 27, 70, 46, 120, 16, 207, 175, 142, 241, 196, 62, 199, 166, 151, 38] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [74, 45, 223, 59, 210, 249, 79, 0, 89, 79, 147, 27, 51, 172, 45, 177, 26, 131, 104, 173, 143, 252, 88, 130, 59, 96, 252, 55, 115, 13, 49, 74], legacy_session_id: SessionId { l: 32, id: [77, 56, 187, 18, 255, 211, 218, 219, 207, 82, 94, 30, 57, 100, 113, 32, 52, 58, 113, 211, 189, 32, 183, 31, 132, 152, 65, 237, 220, 208, 138, 37] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [118, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [178, 121, 151, 100, 18, 110, 102, 120, 17, 75, 92, 185, 36, 186, 81, 2, 197, 27, 70, 46, 120, 16, 207, 175, 142, 241, 196, 62, 199, 166, 151, 38] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [74, 45, 223, 59, 210, 249, 79, 0, 89, 79, 147, 27, 51, 172, 45, 177, 26, 131, 104, 173, 143, 252, 88, 130, 59, 96, 252, 55, 115, 13, 49, 74], legacy_session_id: SessionId { l: 32, id: [77, 56, 187, 18, 255, 211, 218, 219, 207, 82, 94, 30, 57, 100, 113, 32, 52, 58, 113, 211, 189, 32, 183, 31, 132, 152, 65, 237, 220, 208, 138, 37] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [118, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [178, 121, 151, 100, 18, 110, 102, 120, 17, 75, 92, 185, 36, 186, 81, 2, 197, 27, 70, 46, 120, 16, 207, 175, 142, 241, 196, 62, 199, 166, 151, 38] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [74, 45, 223, 59, 210, 249, 79, 0, 89, 79, 147, 27, 51, 172, 45, 177, 26, 131, 104, 173, 143, 252, 88, 130, 59, 96, 252, 55, 115, 13, 49, 74], legacy_session_id: SessionId { l: 32, id: [77, 56, 187, 18, 255, 211, 218, 219, 207, 82, 94, 30, 57, 100, 113, 32, 52, 58, 113, 211, 189, 32, 183, 31, 132, 152, 65, 237, 220, 208, 138, 37] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [118, 107, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [178, 121, 151, 100, 18, 110, 102, 120, 17, 75, 92, 185, 36, 186, 81, 2, 197, 27, 70, 46, 120, 16, 207, 175, 142, 241, 196, 62, 199, 166, 151, 38] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: epicgames.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [36, 157, 175, 47, 193, 66, 126, 59, 12, 203, 97, 177, 218, 242, 99, 154, 244, 96, 138, 199, 41, 6, 20, 239, 189, 249, 132, 201, 97, 249, 2, 68] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((15, Opaque1Ffff { l: 13, data: [101, 112, 105, 99, 103, 97, 109, 101, 115, 46, 99, 111, 109] }))
+[trace] HostName: Ok((15, Opaque1Ffff { l: 13, data: [101, 112, 105, 99, 103, 97, 109, 101, 115, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((15, HostName(Opaque1Ffff { l: 13, data: [101, 112, 105, 99, 103, 97, 109, 101, 115, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((16, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [101, 112, 105, 99, 103, 97, 109, 101, 115, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((18, ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [101, 112, 105, 99, 103, 97, 109, 101, 115, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((18, ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [101, 112, 105, 99, 103, 97, 109, 101, 115, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((22, ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [101, 112, 105, 99, 103, 97, 109, 101, 115, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [42, 127, 27, 239, 14, 162, 46, 158, 126, 52, 236, 40, 193, 169, 127, 68, 193, 37, 125, 52, 125, 204, 154, 61, 47, 224, 27, 240, 230, 137, 223, 76] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [42, 127, 27, 239, 14, 162, 46, 158, 126, 52, 236, 40, 193, 169, 127, 68, 193, 37, 125, 52, 125, 204, 154, 61, 47, 224, 27, 240, 230, 137, 223, 76] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [42, 127, 27, 239, 14, 162, 46, 158, 126, 52, 236, 40, 193, 169, 127, 68, 193, 37, 125, 52, 125, 204, 154, 61, 47, 224, 27, 240, 230, 137, 223, 76] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [42, 127, 27, 239, 14, 162, 46, 158, 126, 52, 236, 40, 193, 169, 127, 68, 193, 37, 125, 52, 125, 204, 154, 61, 47, 224, 27, 240, 230, 137, 223, 76] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((218, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((218, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((222, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [101, 112, 105, 99, 103, 97, 109, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [42, 127, 27, 239, 14, 162, 46, 158, 126, 52, 236, 40, 193, 169, 127, 68, 193, 37, 125, 52, 125, 204, 154, 61, 47, 224, 27, 240, 230, 137, 223, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [226, 219, 13, 134, 139, 65, 127, 122, 119, 237, 221, 206, 180, 57, 24, 81, 209, 9, 253, 27, 245, 180, 48, 89, 47, 147, 67, 79, 3, 45, 33, 103], legacy_session_id: SessionId { l: 32, id: [36, 157, 175, 47, 193, 66, 126, 59, 12, 203, 97, 177, 218, 242, 99, 154, 244, 96, 138, 199, 41, 6, 20, 239, 189, 249, 132, 201, 97, 249, 2, 68] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [101, 112, 105, 99, 103, 97, 109, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [42, 127, 27, 239, 14, 162, 46, 158, 126, 52, 236, 40, 193, 169, 127, 68, 193, 37, 125, 52, 125, 204, 154, 61, 47, 224, 27, 240, 230, 137, 223, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [226, 219, 13, 134, 139, 65, 127, 122, 119, 237, 221, 206, 180, 57, 24, 81, 209, 9, 253, 27, 245, 180, 48, 89, 47, 147, 67, 79, 3, 45, 33, 103], legacy_session_id: SessionId { l: 32, id: [36, 157, 175, 47, 193, 66, 126, 59, 12, 203, 97, 177, 218, 242, 99, 154, 244, 96, 138, 199, 41, 6, 20, 239, 189, 249, 132, 201, 97, 249, 2, 68] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [101, 112, 105, 99, 103, 97, 109, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [42, 127, 27, 239, 14, 162, 46, 158, 126, 52, 236, 40, 193, 169, 127, 68, 193, 37, 125, 52, 125, 204, 154, 61, 47, 224, 27, 240, 230, 137, 223, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [226, 219, 13, 134, 139, 65, 127, 122, 119, 237, 221, 206, 180, 57, 24, 81, 209, 9, 253, 27, 245, 180, 48, 89, 47, 147, 67, 79, 3, 45, 33, 103], legacy_session_id: SessionId { l: 32, id: [36, 157, 175, 47, 193, 66, 126, 59, 12, 203, 97, 177, 218, 242, 99, 154, 244, 96, 138, 199, 41, 6, 20, 239, 189, 249, 132, 201, 97, 249, 2, 68] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 18, extension_data: ServerName(ServerNameList { l: 16, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 13, data: [101, 112, 105, 99, 103, 97, 109, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [42, 127, 27, 239, 14, 162, 46, 158, 126, 52, 236, 40, 193, 169, 127, 68, 193, 37, 125, 52, 125, 204, 154, 61, 47, 224, 27, 240, 230, 137, 223, 76] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 218, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(41040b810b09d4bb2a329f7524d7499d2a58989fa9437d2bf9cc8ce9fdf57d0cef9b0677e7cbea7cfed26a1969ad84601eb0ca6e04c7409be81bb42551ad9780d02a) }, encoded: 1000004241040b810b09d4bb2a329f7524d7499d2a58989fa9437d2bf9cc8ce9fdf57d0cef9b0677e7cbea7cfed26a1969ad84601eb0ca6e04c7409be81bb42551ad9780d02a }
+=====================================
+domain: nginx.org
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [211, 88, 247, 68, 93, 112, 143, 51, 85, 70, 199, 234, 237, 43, 52, 177, 4, 209, 174, 210, 30, 203, 27, 86, 216, 207, 54, 55, 172, 35, 119, 109] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 111, 114, 103] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 111, 114, 103] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 111, 114, 103] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 111, 114, 103] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 111, 114, 103] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 111, 114, 103] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 111, 114, 103] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [27, 242, 255, 67, 216, 94, 58, 183, 111, 31, 225, 31, 175, 26, 179, 250, 203, 205, 230, 77, 228, 214, 30, 7, 25, 104, 87, 38, 15, 98, 132, 85] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [27, 242, 255, 67, 216, 94, 58, 183, 111, 31, 225, 31, 175, 26, 179, 250, 203, 205, 230, 77, 228, 214, 30, 7, 25, 104, 87, 38, 15, 98, 132, 85] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [27, 242, 255, 67, 216, 94, 58, 183, 111, 31, 225, 31, 175, 26, 179, 250, 203, 205, 230, 77, 228, 214, 30, 7, 25, 104, 87, 38, 15, 98, 132, 85] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [27, 242, 255, 67, 216, 94, 58, 183, 111, 31, 225, 31, 175, 26, 179, 250, 203, 205, 230, 77, 228, 214, 30, 7, 25, 104, 87, 38, 15, 98, 132, 85] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [27, 242, 255, 67, 216, 94, 58, 183, 111, 31, 225, 31, 175, 26, 179, 250, 203, 205, 230, 77, 228, 214, 30, 7, 25, 104, 87, 38, 15, 98, 132, 85] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [80, 180, 24, 144, 122, 209, 102, 161, 242, 67, 183, 108, 84, 219, 44, 44, 204, 69, 254, 140, 98, 118, 180, 23, 210, 8, 178, 79, 79, 164, 226, 201], legacy_session_id: SessionId { l: 32, id: [211, 88, 247, 68, 93, 112, 143, 51, 85, 70, 199, 234, 237, 43, 52, 177, 4, 209, 174, 210, 30, 203, 27, 86, 216, 207, 54, 55, 172, 35, 119, 109] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [27, 242, 255, 67, 216, 94, 58, 183, 111, 31, 225, 31, 175, 26, 179, 250, 203, 205, 230, 77, 228, 214, 30, 7, 25, 104, 87, 38, 15, 98, 132, 85] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [80, 180, 24, 144, 122, 209, 102, 161, 242, 67, 183, 108, 84, 219, 44, 44, 204, 69, 254, 140, 98, 118, 180, 23, 210, 8, 178, 79, 79, 164, 226, 201], legacy_session_id: SessionId { l: 32, id: [211, 88, 247, 68, 93, 112, 143, 51, 85, 70, 199, 234, 237, 43, 52, 177, 4, 209, 174, 210, 30, 203, 27, 86, 216, 207, 54, 55, 172, 35, 119, 109] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [27, 242, 255, 67, 216, 94, 58, 183, 111, 31, 225, 31, 175, 26, 179, 250, 203, 205, 230, 77, 228, 214, 30, 7, 25, 104, 87, 38, 15, 98, 132, 85] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [80, 180, 24, 144, 122, 209, 102, 161, 242, 67, 183, 108, 84, 219, 44, 44, 204, 69, 254, 140, 98, 118, 180, 23, 210, 8, 178, 79, 79, 164, 226, 201], legacy_session_id: SessionId { l: 32, id: [211, 88, 247, 68, 93, 112, 143, 51, 85, 70, 199, 234, 237, 43, 52, 177, 4, 209, 174, 210, 30, 203, 27, 86, 216, 207, 54, 55, 172, 35, 119, 109] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 111, 114, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [27, 242, 255, 67, 216, 94, 58, 183, 111, 31, 225, 31, 175, 26, 179, 250, 203, 205, 230, 77, 228, 214, 30, 7, 25, 104, 87, 38, 15, 98, 132, 85] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(2037c5f2550f71da26e29e8f26a8c297753246b74301f5632454111e2dff92bc11) }, encoded: 100000212037c5f2550f71da26e29e8f26a8c297753246b74301f5632454111e2dff92bc11 }
+=====================================
+domain: pki.goog
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [117, 106, 51, 3, 217, 59, 128, 22, 132, 15, 251, 0, 51, 32, 249, 0, 188, 138, 76, 229, 219, 47, 30, 110, 249, 153, 195, 117, 51, 35, 138, 8] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((10, Opaque1Ffff { l: 8, data: [112, 107, 105, 46, 103, 111, 111, 103] }))
+[trace] HostName: Ok((10, Opaque1Ffff { l: 8, data: [112, 107, 105, 46, 103, 111, 111, 103] }))
+[trace] ServerNameName: Ok((10, HostName(Opaque1Ffff { l: 8, data: [112, 107, 105, 46, 103, 111, 111, 103] })))
+[trace] ServerName: Ok((11, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [112, 107, 105, 46, 103, 111, 111, 103] }) }))
+[trace] ServerNameList: Ok((13, ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [112, 107, 105, 46, 103, 111, 111, 103] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((13, ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [112, 107, 105, 46, 103, 111, 111, 103] }) }]) })))
+[trace] ClientHelloExtension: Ok((17, ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [112, 107, 105, 46, 103, 111, 111, 103] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [125, 149, 15, 71, 188, 225, 221, 37, 72, 87, 34, 210, 63, 124, 250, 18, 214, 83, 135, 11, 80, 132, 27, 189, 88, 193, 36, 223, 179, 37, 112, 83] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [125, 149, 15, 71, 188, 225, 221, 37, 72, 87, 34, 210, 63, 124, 250, 18, 214, 83, 135, 11, 80, 132, 27, 189, 88, 193, 36, 223, 179, 37, 112, 83] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [125, 149, 15, 71, 188, 225, 221, 37, 72, 87, 34, 210, 63, 124, 250, 18, 214, 83, 135, 11, 80, 132, 27, 189, 88, 193, 36, 223, 179, 37, 112, 83] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [125, 149, 15, 71, 188, 225, 221, 37, 72, 87, 34, 210, 63, 124, 250, 18, 214, 83, 135, 11, 80, 132, 27, 189, 88, 193, 36, 223, 179, 37, 112, 83] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((223, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((223, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((227, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [112, 107, 105, 46, 103, 111, 111, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [125, 149, 15, 71, 188, 225, 221, 37, 72, 87, 34, 210, 63, 124, 250, 18, 214, 83, 135, 11, 80, 132, 27, 189, 88, 193, 36, 223, 179, 37, 112, 83] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [245, 54, 100, 215, 4, 183, 122, 231, 105, 9, 3, 162, 215, 21, 204, 81, 69, 233, 44, 88, 219, 162, 74, 30, 228, 70, 77, 151, 65, 194, 96, 95], legacy_session_id: SessionId { l: 32, id: [117, 106, 51, 3, 217, 59, 128, 22, 132, 15, 251, 0, 51, 32, 249, 0, 188, 138, 76, 229, 219, 47, 30, 110, 249, 153, 195, 117, 51, 35, 138, 8] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [112, 107, 105, 46, 103, 111, 111, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [125, 149, 15, 71, 188, 225, 221, 37, 72, 87, 34, 210, 63, 124, 250, 18, 214, 83, 135, 11, 80, 132, 27, 189, 88, 193, 36, 223, 179, 37, 112, 83] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [245, 54, 100, 215, 4, 183, 122, 231, 105, 9, 3, 162, 215, 21, 204, 81, 69, 233, 44, 88, 219, 162, 74, 30, 228, 70, 77, 151, 65, 194, 96, 95], legacy_session_id: SessionId { l: 32, id: [117, 106, 51, 3, 217, 59, 128, 22, 132, 15, 251, 0, 51, 32, 249, 0, 188, 138, 76, 229, 219, 47, 30, 110, 249, 153, 195, 117, 51, 35, 138, 8] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [112, 107, 105, 46, 103, 111, 111, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [125, 149, 15, 71, 188, 225, 221, 37, 72, 87, 34, 210, 63, 124, 250, 18, 214, 83, 135, 11, 80, 132, 27, 189, 88, 193, 36, 223, 179, 37, 112, 83] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [245, 54, 100, 215, 4, 183, 122, 231, 105, 9, 3, 162, 215, 21, 204, 81, 69, 233, 44, 88, 219, 162, 74, 30, 228, 70, 77, 151, 65, 194, 96, 95], legacy_session_id: SessionId { l: 32, id: [117, 106, 51, 3, 217, 59, 128, 22, 132, 15, 251, 0, 51, 32, 249, 0, 188, 138, 76, 229, 219, 47, 30, 110, 249, 153, 195, 117, 51, 35, 138, 8] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 13, extension_data: ServerName(ServerNameList { l: 11, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 8, data: [112, 107, 105, 46, 103, 111, 111, 103] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [125, 149, 15, 71, 188, 225, 221, 37, 72, 87, 34, 210, 63, 124, 250, 18, 214, 83, 135, 11, 80, 132, 27, 189, 88, 193, 36, 223, 179, 37, 112, 83] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 223, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: dropbox.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [103, 184, 156, 75, 155, 119, 136, 159, 43, 28, 45, 252, 120, 128, 149, 194, 196, 184, 95, 3, 196, 5, 162, 143, 93, 122, 185, 47, 145, 247, 62, 39] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [100, 114, 111, 112, 98, 111, 120, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [100, 114, 111, 112, 98, 111, 120, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [100, 114, 111, 112, 98, 111, 120, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [100, 114, 111, 112, 98, 111, 120, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [100, 114, 111, 112, 98, 111, 120, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [100, 114, 111, 112, 98, 111, 120, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [100, 114, 111, 112, 98, 111, 120, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [95, 39, 56, 91, 20, 37, 11, 191, 140, 13, 243, 175, 46, 150, 174, 229, 149, 170, 148, 76, 193, 99, 57, 215, 64, 206, 123, 232, 52, 56, 254, 62] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [95, 39, 56, 91, 20, 37, 11, 191, 140, 13, 243, 175, 46, 150, 174, 229, 149, 170, 148, 76, 193, 99, 57, 215, 64, 206, 123, 232, 52, 56, 254, 62] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [95, 39, 56, 91, 20, 37, 11, 191, 140, 13, 243, 175, 46, 150, 174, 229, 149, 170, 148, 76, 193, 99, 57, 215, 64, 206, 123, 232, 52, 56, 254, 62] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [95, 39, 56, 91, 20, 37, 11, 191, 140, 13, 243, 175, 46, 150, 174, 229, 149, 170, 148, 76, 193, 99, 57, 215, 64, 206, 123, 232, 52, 56, 254, 62] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [100, 114, 111, 112, 98, 111, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [95, 39, 56, 91, 20, 37, 11, 191, 140, 13, 243, 175, 46, 150, 174, 229, 149, 170, 148, 76, 193, 99, 57, 215, 64, 206, 123, 232, 52, 56, 254, 62] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [2, 111, 13, 181, 196, 23, 5, 213, 46, 97, 185, 253, 97, 141, 68, 206, 201, 77, 116, 199, 214, 100, 181, 46, 244, 46, 186, 12, 188, 52, 200, 184], legacy_session_id: SessionId { l: 32, id: [103, 184, 156, 75, 155, 119, 136, 159, 43, 28, 45, 252, 120, 128, 149, 194, 196, 184, 95, 3, 196, 5, 162, 143, 93, 122, 185, 47, 145, 247, 62, 39] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [100, 114, 111, 112, 98, 111, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [95, 39, 56, 91, 20, 37, 11, 191, 140, 13, 243, 175, 46, 150, 174, 229, 149, 170, 148, 76, 193, 99, 57, 215, 64, 206, 123, 232, 52, 56, 254, 62] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [2, 111, 13, 181, 196, 23, 5, 213, 46, 97, 185, 253, 97, 141, 68, 206, 201, 77, 116, 199, 214, 100, 181, 46, 244, 46, 186, 12, 188, 52, 200, 184], legacy_session_id: SessionId { l: 32, id: [103, 184, 156, 75, 155, 119, 136, 159, 43, 28, 45, 252, 120, 128, 149, 194, 196, 184, 95, 3, 196, 5, 162, 143, 93, 122, 185, 47, 145, 247, 62, 39] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [100, 114, 111, 112, 98, 111, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [95, 39, 56, 91, 20, 37, 11, 191, 140, 13, 243, 175, 46, 150, 174, 229, 149, 170, 148, 76, 193, 99, 57, 215, 64, 206, 123, 232, 52, 56, 254, 62] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [2, 111, 13, 181, 196, 23, 5, 213, 46, 97, 185, 253, 97, 141, 68, 206, 201, 77, 116, 199, 214, 100, 181, 46, 244, 46, 186, 12, 188, 52, 200, 184], legacy_session_id: SessionId { l: 32, id: [103, 184, 156, 75, 155, 119, 136, 159, 43, 28, 45, 252, 120, 128, 149, 194, 196, 184, 95, 3, 196, 5, 162, 143, 93, 122, 185, 47, 145, 247, 62, 39] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [100, 114, 111, 112, 98, 111, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [95, 39, 56, 91, 20, 37, 11, 191, 140, 13, 243, 175, 46, 150, 174, 229, 149, 170, 148, 76, 193, 99, 57, 215, 64, 206, 123, 232, 52, 56, 254, 62] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: ui.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [88, 62, 162, 124, 109, 185, 160, 5, 79, 203, 110, 110, 12, 232, 233, 206, 253, 157, 14, 51, 197, 10, 85, 244, 125, 96, 163, 172, 149, 29, 206, 123] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((8, Opaque1Ffff { l: 6, data: [117, 105, 46, 99, 111, 109] }))
+[trace] HostName: Ok((8, Opaque1Ffff { l: 6, data: [117, 105, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((8, HostName(Opaque1Ffff { l: 6, data: [117, 105, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((9, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [117, 105, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((11, ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [117, 105, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((11, ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [117, 105, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((15, ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [117, 105, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [90, 16, 50, 210, 233, 214, 221, 2, 149, 229, 100, 62, 101, 28, 170, 18, 45, 116, 239, 253, 209, 241, 253, 43, 255, 182, 179, 224, 194, 111, 132, 40] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 16, 50, 210, 233, 214, 221, 2, 149, 229, 100, 62, 101, 28, 170, 18, 45, 116, 239, 253, 209, 241, 253, 43, 255, 182, 179, 224, 194, 111, 132, 40] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 16, 50, 210, 233, 214, 221, 2, 149, 229, 100, 62, 101, 28, 170, 18, 45, 116, 239, 253, 209, 241, 253, 43, 255, 182, 179, 224, 194, 111, 132, 40] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 16, 50, 210, 233, 214, 221, 2, 149, 229, 100, 62, 101, 28, 170, 18, 45, 116, 239, 253, 209, 241, 253, 43, 255, 182, 179, 224, 194, 111, 132, 40] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((225, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((225, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((229, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [117, 105, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 16, 50, 210, 233, 214, 221, 2, 149, 229, 100, 62, 101, 28, 170, 18, 45, 116, 239, 253, 209, 241, 253, 43, 255, 182, 179, 224, 194, 111, 132, 40] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [34, 143, 185, 189, 223, 175, 204, 0, 149, 135, 35, 162, 106, 96, 127, 190, 28, 177, 62, 119, 60, 246, 209, 251, 65, 226, 218, 61, 3, 55, 100, 225], legacy_session_id: SessionId { l: 32, id: [88, 62, 162, 124, 109, 185, 160, 5, 79, 203, 110, 110, 12, 232, 233, 206, 253, 157, 14, 51, 197, 10, 85, 244, 125, 96, 163, 172, 149, 29, 206, 123] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [117, 105, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 16, 50, 210, 233, 214, 221, 2, 149, 229, 100, 62, 101, 28, 170, 18, 45, 116, 239, 253, 209, 241, 253, 43, 255, 182, 179, 224, 194, 111, 132, 40] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [34, 143, 185, 189, 223, 175, 204, 0, 149, 135, 35, 162, 106, 96, 127, 190, 28, 177, 62, 119, 60, 246, 209, 251, 65, 226, 218, 61, 3, 55, 100, 225], legacy_session_id: SessionId { l: 32, id: [88, 62, 162, 124, 109, 185, 160, 5, 79, 203, 110, 110, 12, 232, 233, 206, 253, 157, 14, 51, 197, 10, 85, 244, 125, 96, 163, 172, 149, 29, 206, 123] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [117, 105, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 16, 50, 210, 233, 214, 221, 2, 149, 229, 100, 62, 101, 28, 170, 18, 45, 116, 239, 253, 209, 241, 253, 43, 255, 182, 179, 224, 194, 111, 132, 40] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [34, 143, 185, 189, 223, 175, 204, 0, 149, 135, 35, 162, 106, 96, 127, 190, 28, 177, 62, 119, 60, 246, 209, 251, 65, 226, 218, 61, 3, 55, 100, 225], legacy_session_id: SessionId { l: 32, id: [88, 62, 162, 124, 109, 185, 160, 5, 79, 203, 110, 110, 12, 232, 233, 206, 253, 157, 14, 51, 197, 10, 85, 244, 125, 96, 163, 172, 149, 29, 206, 123] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 11, extension_data: ServerName(ServerNameList { l: 9, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 6, data: [117, 105, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [90, 16, 50, 210, 233, 214, 221, 2, 149, 229, 100, 62, 101, 28, 170, 18, 45, 116, 239, 253, 209, 241, 253, 43, 255, 182, 179, 224, 194, 111, 132, 40] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 225, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: gravatar.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [80, 244, 5, 138, 49, 7, 244, 245, 248, 147, 101, 156, 253, 34, 178, 238, 249, 238, 129, 239, 64, 210, 119, 6, 35, 136, 36, 141, 85, 5, 221, 103] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((14, Opaque1Ffff { l: 12, data: [103, 114, 97, 118, 97, 116, 97, 114, 46, 99, 111, 109] }))
+[trace] HostName: Ok((14, Opaque1Ffff { l: 12, data: [103, 114, 97, 118, 97, 116, 97, 114, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((14, HostName(Opaque1Ffff { l: 12, data: [103, 114, 97, 118, 97, 116, 97, 114, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((15, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [103, 114, 97, 118, 97, 116, 97, 114, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((17, ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [103, 114, 97, 118, 97, 116, 97, 114, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((17, ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [103, 114, 97, 118, 97, 116, 97, 114, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((21, ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [103, 114, 97, 118, 97, 116, 97, 114, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [17, 159, 29, 34, 3, 60, 45, 58, 118, 194, 37, 214, 31, 2, 9, 41, 206, 63, 72, 153, 171, 155, 135, 155, 0, 168, 88, 144, 155, 26, 43, 10] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [17, 159, 29, 34, 3, 60, 45, 58, 118, 194, 37, 214, 31, 2, 9, 41, 206, 63, 72, 153, 171, 155, 135, 155, 0, 168, 88, 144, 155, 26, 43, 10] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [17, 159, 29, 34, 3, 60, 45, 58, 118, 194, 37, 214, 31, 2, 9, 41, 206, 63, 72, 153, 171, 155, 135, 155, 0, 168, 88, 144, 155, 26, 43, 10] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [17, 159, 29, 34, 3, 60, 45, 58, 118, 194, 37, 214, 31, 2, 9, 41, 206, 63, 72, 153, 171, 155, 135, 155, 0, 168, 88, 144, 155, 26, 43, 10] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((219, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((219, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((223, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [103, 114, 97, 118, 97, 116, 97, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [17, 159, 29, 34, 3, 60, 45, 58, 118, 194, 37, 214, 31, 2, 9, 41, 206, 63, 72, 153, 171, 155, 135, 155, 0, 168, 88, 144, 155, 26, 43, 10] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [120, 41, 112, 10, 132, 51, 163, 13, 37, 6, 38, 127, 11, 55, 54, 188, 89, 181, 41, 227, 4, 56, 66, 56, 186, 11, 126, 155, 137, 58, 114, 246], legacy_session_id: SessionId { l: 32, id: [80, 244, 5, 138, 49, 7, 244, 245, 248, 147, 101, 156, 253, 34, 178, 238, 249, 238, 129, 239, 64, 210, 119, 6, 35, 136, 36, 141, 85, 5, 221, 103] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [103, 114, 97, 118, 97, 116, 97, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [17, 159, 29, 34, 3, 60, 45, 58, 118, 194, 37, 214, 31, 2, 9, 41, 206, 63, 72, 153, 171, 155, 135, 155, 0, 168, 88, 144, 155, 26, 43, 10] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [120, 41, 112, 10, 132, 51, 163, 13, 37, 6, 38, 127, 11, 55, 54, 188, 89, 181, 41, 227, 4, 56, 66, 56, 186, 11, 126, 155, 137, 58, 114, 246], legacy_session_id: SessionId { l: 32, id: [80, 244, 5, 138, 49, 7, 244, 245, 248, 147, 101, 156, 253, 34, 178, 238, 249, 238, 129, 239, 64, 210, 119, 6, 35, 136, 36, 141, 85, 5, 221, 103] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [103, 114, 97, 118, 97, 116, 97, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [17, 159, 29, 34, 3, 60, 45, 58, 118, 194, 37, 214, 31, 2, 9, 41, 206, 63, 72, 153, 171, 155, 135, 155, 0, 168, 88, 144, 155, 26, 43, 10] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [120, 41, 112, 10, 132, 51, 163, 13, 37, 6, 38, 127, 11, 55, 54, 188, 89, 181, 41, 227, 4, 56, 66, 56, 186, 11, 126, 155, 137, 58, 114, 246], legacy_session_id: SessionId { l: 32, id: [80, 244, 5, 138, 49, 7, 244, 245, 248, 147, 101, 156, 253, 34, 178, 238, 249, 238, 129, 239, 64, 210, 119, 6, 35, 136, 36, 141, 85, 5, 221, 103] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 17, extension_data: ServerName(ServerNameList { l: 15, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 12, data: [103, 114, 97, 118, 97, 116, 97, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [17, 159, 29, 34, 3, 60, 45, 58, 118, 194, 37, 214, 31, 2, 9, 41, 206, 63, 72, 153, 171, 155, 135, 155, 0, 168, 88, 144, 155, 26, 43, 10] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 219, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: nih.gov
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [125, 120, 122, 91, 255, 5, 58, 174, 48, 36, 141, 141, 107, 111, 155, 196, 220, 111, 103, 187, 60, 63, 34, 231, 24, 46, 32, 79, 109, 32, 115, 147] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((9, Opaque1Ffff { l: 7, data: [110, 105, 104, 46, 103, 111, 118] }))
+[trace] HostName: Ok((9, Opaque1Ffff { l: 7, data: [110, 105, 104, 46, 103, 111, 118] }))
+[trace] ServerNameName: Ok((9, HostName(Opaque1Ffff { l: 7, data: [110, 105, 104, 46, 103, 111, 118] })))
+[trace] ServerName: Ok((10, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 105, 104, 46, 103, 111, 118] }) }))
+[trace] ServerNameList: Ok((12, ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 105, 104, 46, 103, 111, 118] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((12, ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 105, 104, 46, 103, 111, 118] }) }]) })))
+[trace] ClientHelloExtension: Ok((16, ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 105, 104, 46, 103, 111, 118] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [177, 34, 174, 244, 244, 81, 119, 44, 125, 77, 160, 228, 212, 82, 222, 149, 27, 179, 203, 41, 7, 144, 47, 160, 25, 194, 221, 129, 18, 141, 64, 74] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [177, 34, 174, 244, 244, 81, 119, 44, 125, 77, 160, 228, 212, 82, 222, 149, 27, 179, 203, 41, 7, 144, 47, 160, 25, 194, 221, 129, 18, 141, 64, 74] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [177, 34, 174, 244, 244, 81, 119, 44, 125, 77, 160, 228, 212, 82, 222, 149, 27, 179, 203, 41, 7, 144, 47, 160, 25, 194, 221, 129, 18, 141, 64, 74] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [177, 34, 174, 244, 244, 81, 119, 44, 125, 77, 160, 228, 212, 82, 222, 149, 27, 179, 203, 41, 7, 144, 47, 160, 25, 194, 221, 129, 18, 141, 64, 74] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((224, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((224, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((228, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 105, 104, 46, 103, 111, 118] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [177, 34, 174, 244, 244, 81, 119, 44, 125, 77, 160, 228, 212, 82, 222, 149, 27, 179, 203, 41, 7, 144, 47, 160, 25, 194, 221, 129, 18, 141, 64, 74] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [136, 120, 166, 236, 56, 173, 72, 248, 41, 218, 23, 37, 240, 152, 128, 195, 23, 22, 79, 213, 133, 41, 24, 173, 20, 225, 166, 206, 126, 203, 5, 8], legacy_session_id: SessionId { l: 32, id: [125, 120, 122, 91, 255, 5, 58, 174, 48, 36, 141, 141, 107, 111, 155, 196, 220, 111, 103, 187, 60, 63, 34, 231, 24, 46, 32, 79, 109, 32, 115, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 105, 104, 46, 103, 111, 118] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [177, 34, 174, 244, 244, 81, 119, 44, 125, 77, 160, 228, 212, 82, 222, 149, 27, 179, 203, 41, 7, 144, 47, 160, 25, 194, 221, 129, 18, 141, 64, 74] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [136, 120, 166, 236, 56, 173, 72, 248, 41, 218, 23, 37, 240, 152, 128, 195, 23, 22, 79, 213, 133, 41, 24, 173, 20, 225, 166, 206, 126, 203, 5, 8], legacy_session_id: SessionId { l: 32, id: [125, 120, 122, 91, 255, 5, 58, 174, 48, 36, 141, 141, 107, 111, 155, 196, 220, 111, 103, 187, 60, 63, 34, 231, 24, 46, 32, 79, 109, 32, 115, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 105, 104, 46, 103, 111, 118] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [177, 34, 174, 244, 244, 81, 119, 44, 125, 77, 160, 228, 212, 82, 222, 149, 27, 179, 203, 41, 7, 144, 47, 160, 25, 194, 221, 129, 18, 141, 64, 74] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [136, 120, 166, 236, 56, 173, 72, 248, 41, 218, 23, 37, 240, 152, 128, 195, 23, 22, 79, 213, 133, 41, 24, 173, 20, 225, 166, 206, 126, 203, 5, 8], legacy_session_id: SessionId { l: 32, id: [125, 120, 122, 91, 255, 5, 58, 174, 48, 36, 141, 141, 107, 111, 155, 196, 220, 111, 103, 187, 60, 63, 34, 231, 24, 46, 32, 79, 109, 32, 115, 147] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 12, extension_data: ServerName(ServerNameList { l: 10, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 7, data: [110, 105, 104, 46, 103, 111, 118] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [177, 34, 174, 244, 244, 81, 119, 44, 125, 77, 160, 228, 212, 82, 222, 149, 27, 179, 203, 41, 7, 144, 47, 160, 25, 194, 221, 129, 18, 141, 64, 74] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 224, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(41045260746feef0577df73a70e446e580825589163d452b4fe453dfd933bdbe15f4a8d187406b3b455057dc4ac025590e676c4e511ef3f0c73c403e76f205aa47c0) }, encoded: 1000004241045260746feef0577df73a70e446e580825589163d452b4fe453dfd933bdbe15f4a8d187406b3b455057dc4ac025590e676c4e511ef3f0c73c403e76f205aa47c0 }
+=====================================
+domain: windows.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [102, 204, 196, 151, 46, 22, 84, 0, 252, 38, 153, 243, 235, 131, 162, 225, 152, 110, 158, 150, 146, 180, 52, 24, 149, 172, 106, 239, 220, 64, 155, 196] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [119, 105, 110, 100, 111, 119, 115, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [119, 105, 110, 100, 111, 119, 115, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [119, 105, 110, 100, 111, 119, 115, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 105, 110, 100, 111, 119, 115, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 105, 110, 100, 111, 119, 115, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 105, 110, 100, 111, 119, 115, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 105, 110, 100, 111, 119, 115, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [106, 197, 200, 97, 57, 51, 221, 194, 63, 84, 188, 151, 68, 175, 111, 152, 175, 182, 109, 6, 23, 144, 255, 169, 136, 213, 84, 1, 61, 4, 127, 63] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [106, 197, 200, 97, 57, 51, 221, 194, 63, 84, 188, 151, 68, 175, 111, 152, 175, 182, 109, 6, 23, 144, 255, 169, 136, 213, 84, 1, 61, 4, 127, 63] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [106, 197, 200, 97, 57, 51, 221, 194, 63, 84, 188, 151, 68, 175, 111, 152, 175, 182, 109, 6, 23, 144, 255, 169, 136, 213, 84, 1, 61, 4, 127, 63] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [106, 197, 200, 97, 57, 51, 221, 194, 63, 84, 188, 151, 68, 175, 111, 152, 175, 182, 109, 6, 23, 144, 255, 169, 136, 213, 84, 1, 61, 4, 127, 63] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 105, 110, 100, 111, 119, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [106, 197, 200, 97, 57, 51, 221, 194, 63, 84, 188, 151, 68, 175, 111, 152, 175, 182, 109, 6, 23, 144, 255, 169, 136, 213, 84, 1, 61, 4, 127, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [69, 163, 229, 231, 231, 126, 1, 184, 237, 164, 177, 137, 98, 149, 216, 208, 31, 224, 83, 118, 176, 236, 54, 85, 106, 77, 178, 109, 79, 224, 78, 145], legacy_session_id: SessionId { l: 32, id: [102, 204, 196, 151, 46, 22, 84, 0, 252, 38, 153, 243, 235, 131, 162, 225, 152, 110, 158, 150, 146, 180, 52, 24, 149, 172, 106, 239, 220, 64, 155, 196] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 105, 110, 100, 111, 119, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [106, 197, 200, 97, 57, 51, 221, 194, 63, 84, 188, 151, 68, 175, 111, 152, 175, 182, 109, 6, 23, 144, 255, 169, 136, 213, 84, 1, 61, 4, 127, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [69, 163, 229, 231, 231, 126, 1, 184, 237, 164, 177, 137, 98, 149, 216, 208, 31, 224, 83, 118, 176, 236, 54, 85, 106, 77, 178, 109, 79, 224, 78, 145], legacy_session_id: SessionId { l: 32, id: [102, 204, 196, 151, 46, 22, 84, 0, 252, 38, 153, 243, 235, 131, 162, 225, 152, 110, 158, 150, 146, 180, 52, 24, 149, 172, 106, 239, 220, 64, 155, 196] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 105, 110, 100, 111, 119, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [106, 197, 200, 97, 57, 51, 221, 194, 63, 84, 188, 151, 68, 175, 111, 152, 175, 182, 109, 6, 23, 144, 255, 169, 136, 213, 84, 1, 61, 4, 127, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [69, 163, 229, 231, 231, 126, 1, 184, 237, 164, 177, 137, 98, 149, 216, 208, 31, 224, 83, 118, 176, 236, 54, 85, 106, 77, 178, 109, 79, 224, 78, 145], legacy_session_id: SessionId { l: 32, id: [102, 204, 196, 151, 46, 22, 84, 0, 252, 38, 153, 243, 235, 131, 162, 225, 152, 110, 158, 150, 146, 180, 52, 24, 149, 172, 106, 239, 220, 64, 155, 196] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [119, 105, 110, 100, 111, 119, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [106, 197, 200, 97, 57, 51, 221, 194, 63, 84, 188, 151, 68, 175, 111, 152, 175, 182, 109, 6, 23, 144, 255, 169, 136, 213, 84, 1, 61, 4, 127, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: github.io
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [125, 250, 216, 165, 154, 241, 3, 201, 168, 91, 144, 133, 48, 114, 13, 88, 74, 88, 8, 66, 101, 140, 158, 142, 44, 179, 192, 41, 228, 32, 180, 54] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [103, 105, 116, 104, 117, 98, 46, 105, 111] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [103, 105, 116, 104, 117, 98, 46, 105, 111] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [103, 105, 116, 104, 117, 98, 46, 105, 111] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 105, 116, 104, 117, 98, 46, 105, 111] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 105, 116, 104, 117, 98, 46, 105, 111] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 105, 116, 104, 117, 98, 46, 105, 111] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 105, 116, 104, 117, 98, 46, 105, 111] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [30, 206, 42, 41, 240, 132, 8, 244, 130, 168, 43, 197, 87, 194, 163, 191, 236, 86, 210, 249, 38, 74, 234, 22, 60, 157, 252, 2, 70, 74, 103, 111] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [30, 206, 42, 41, 240, 132, 8, 244, 130, 168, 43, 197, 87, 194, 163, 191, 236, 86, 210, 249, 38, 74, 234, 22, 60, 157, 252, 2, 70, 74, 103, 111] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [30, 206, 42, 41, 240, 132, 8, 244, 130, 168, 43, 197, 87, 194, 163, 191, 236, 86, 210, 249, 38, 74, 234, 22, 60, 157, 252, 2, 70, 74, 103, 111] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [30, 206, 42, 41, 240, 132, 8, 244, 130, 168, 43, 197, 87, 194, 163, 191, 236, 86, 210, 249, 38, 74, 234, 22, 60, 157, 252, 2, 70, 74, 103, 111] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 105, 116, 104, 117, 98, 46, 105, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [30, 206, 42, 41, 240, 132, 8, 244, 130, 168, 43, 197, 87, 194, 163, 191, 236, 86, 210, 249, 38, 74, 234, 22, 60, 157, 252, 2, 70, 74, 103, 111] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [216, 32, 224, 180, 112, 91, 245, 116, 224, 19, 16, 110, 98, 248, 138, 85, 229, 32, 138, 170, 205, 211, 47, 141, 245, 229, 92, 83, 4, 147, 178, 98], legacy_session_id: SessionId { l: 32, id: [125, 250, 216, 165, 154, 241, 3, 201, 168, 91, 144, 133, 48, 114, 13, 88, 74, 88, 8, 66, 101, 140, 158, 142, 44, 179, 192, 41, 228, 32, 180, 54] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 105, 116, 104, 117, 98, 46, 105, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [30, 206, 42, 41, 240, 132, 8, 244, 130, 168, 43, 197, 87, 194, 163, 191, 236, 86, 210, 249, 38, 74, 234, 22, 60, 157, 252, 2, 70, 74, 103, 111] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [216, 32, 224, 180, 112, 91, 245, 116, 224, 19, 16, 110, 98, 248, 138, 85, 229, 32, 138, 170, 205, 211, 47, 141, 245, 229, 92, 83, 4, 147, 178, 98], legacy_session_id: SessionId { l: 32, id: [125, 250, 216, 165, 154, 241, 3, 201, 168, 91, 144, 133, 48, 114, 13, 88, 74, 88, 8, 66, 101, 140, 158, 142, 44, 179, 192, 41, 228, 32, 180, 54] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 105, 116, 104, 117, 98, 46, 105, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [30, 206, 42, 41, 240, 132, 8, 244, 130, 168, 43, 197, 87, 194, 163, 191, 236, 86, 210, 249, 38, 74, 234, 22, 60, 157, 252, 2, 70, 74, 103, 111] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [216, 32, 224, 180, 112, 91, 245, 116, 224, 19, 16, 110, 98, 248, 138, 85, 229, 32, 138, 170, 205, 211, 47, 141, 245, 229, 92, 83, 4, 147, 178, 98], legacy_session_id: SessionId { l: 32, id: [125, 250, 216, 165, 154, 241, 3, 201, 168, 91, 144, 133, 48, 114, 13, 88, 74, 88, 8, 66, 101, 140, 158, 142, 44, 179, 192, 41, 228, 32, 180, 54] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [103, 105, 116, 104, 117, 98, 46, 105, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [30, 206, 42, 41, 240, 132, 8, 244, 130, 168, 43, 197, 87, 194, 163, 191, 236, 86, 210, 249, 38, 74, 234, 22, 60, 157, 252, 2, 70, 74, 103, 111] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: t-online.de
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [148, 0, 36, 235, 4, 231, 218, 111, 47, 11, 30, 26, 155, 114, 235, 97, 114, 115, 99, 242, 24, 32, 48, 216, 206, 23, 241, 231, 10, 6, 100, 6] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [116, 45, 111, 110, 108, 105, 110, 101, 46, 100, 101] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [116, 45, 111, 110, 108, 105, 110, 101, 46, 100, 101] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [116, 45, 111, 110, 108, 105, 110, 101, 46, 100, 101] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 45, 111, 110, 108, 105, 110, 101, 46, 100, 101] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 45, 111, 110, 108, 105, 110, 101, 46, 100, 101] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 45, 111, 110, 108, 105, 110, 101, 46, 100, 101] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 45, 111, 110, 108, 105, 110, 101, 46, 100, 101] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [148, 167, 65, 200, 58, 237, 33, 73, 49, 60, 58, 23, 238, 199, 87, 63, 163, 155, 40, 156, 104, 221, 72, 121, 59, 133, 36, 30, 97, 9, 158, 81] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [148, 167, 65, 200, 58, 237, 33, 73, 49, 60, 58, 23, 238, 199, 87, 63, 163, 155, 40, 156, 104, 221, 72, 121, 59, 133, 36, 30, 97, 9, 158, 81] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [148, 167, 65, 200, 58, 237, 33, 73, 49, 60, 58, 23, 238, 199, 87, 63, 163, 155, 40, 156, 104, 221, 72, 121, 59, 133, 36, 30, 97, 9, 158, 81] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [148, 167, 65, 200, 58, 237, 33, 73, 49, 60, 58, 23, 238, 199, 87, 63, 163, 155, 40, 156, 104, 221, 72, 121, 59, 133, 36, 30, 97, 9, 158, 81] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 45, 111, 110, 108, 105, 110, 101, 46, 100, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [148, 167, 65, 200, 58, 237, 33, 73, 49, 60, 58, 23, 238, 199, 87, 63, 163, 155, 40, 156, 104, 221, 72, 121, 59, 133, 36, 30, 97, 9, 158, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [35, 211, 63, 174, 123, 202, 208, 90, 240, 160, 154, 56, 116, 42, 116, 168, 107, 68, 85, 199, 46, 130, 142, 145, 205, 58, 241, 89, 24, 174, 60, 33], legacy_session_id: SessionId { l: 32, id: [148, 0, 36, 235, 4, 231, 218, 111, 47, 11, 30, 26, 155, 114, 235, 97, 114, 115, 99, 242, 24, 32, 48, 216, 206, 23, 241, 231, 10, 6, 100, 6] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 45, 111, 110, 108, 105, 110, 101, 46, 100, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [148, 167, 65, 200, 58, 237, 33, 73, 49, 60, 58, 23, 238, 199, 87, 63, 163, 155, 40, 156, 104, 221, 72, 121, 59, 133, 36, 30, 97, 9, 158, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [35, 211, 63, 174, 123, 202, 208, 90, 240, 160, 154, 56, 116, 42, 116, 168, 107, 68, 85, 199, 46, 130, 142, 145, 205, 58, 241, 89, 24, 174, 60, 33], legacy_session_id: SessionId { l: 32, id: [148, 0, 36, 235, 4, 231, 218, 111, 47, 11, 30, 26, 155, 114, 235, 97, 114, 115, 99, 242, 24, 32, 48, 216, 206, 23, 241, 231, 10, 6, 100, 6] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 45, 111, 110, 108, 105, 110, 101, 46, 100, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [148, 167, 65, 200, 58, 237, 33, 73, 49, 60, 58, 23, 238, 199, 87, 63, 163, 155, 40, 156, 104, 221, 72, 121, 59, 133, 36, 30, 97, 9, 158, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [35, 211, 63, 174, 123, 202, 208, 90, 240, 160, 154, 56, 116, 42, 116, 168, 107, 68, 85, 199, 46, 130, 142, 145, 205, 58, 241, 89, 24, 174, 60, 33], legacy_session_id: SessionId { l: 32, id: [148, 0, 36, 235, 4, 231, 218, 111, 47, 11, 30, 26, 155, 114, 235, 97, 114, 115, 99, 242, 24, 32, 48, 216, 206, 23, 241, 231, 10, 6, 100, 6] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 45, 111, 110, 108, 105, 110, 101, 46, 100, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [148, 167, 65, 200, 58, 237, 33, 73, 49, 60, 58, 23, 238, 199, 87, 63, 163, 155, 40, 156, 104, 221, 72, 121, 59, 133, 36, 30, 97, 9, 158, 81] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: app-analytics-services.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [184, 38, 173, 167, 62, 145, 161, 247, 222, 34, 192, 178, 180, 224, 235, 112, 159, 87, 85, 159, 3, 110, 38, 56, 251, 161, 127, 215, 146, 86, 242, 43] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((28, Opaque1Ffff { l: 26, data: [97, 112, 112, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 45, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }))
+[trace] HostName: Ok((28, Opaque1Ffff { l: 26, data: [97, 112, 112, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 45, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((28, HostName(Opaque1Ffff { l: 26, data: [97, 112, 112, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 45, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((29, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 26, data: [97, 112, 112, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 45, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((31, ServerNameList { l: 29, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 26, data: [97, 112, 112, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 45, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((31, ServerName(ServerNameList { l: 29, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 26, data: [97, 112, 112, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 45, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((35, ClientHelloExtension { extension_type: 0, ext_len: 31, extension_data: ServerName(ServerNameList { l: 29, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 26, data: [97, 112, 112, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 45, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [206, 170, 128, 237, 226, 151, 29, 142, 240, 185, 166, 181, 1, 14, 244, 64, 176, 175, 77, 122, 73, 60, 179, 43, 29, 138, 96, 55, 254, 102, 0, 93] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [206, 170, 128, 237, 226, 151, 29, 142, 240, 185, 166, 181, 1, 14, 244, 64, 176, 175, 77, 122, 73, 60, 179, 43, 29, 138, 96, 55, 254, 102, 0, 93] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [206, 170, 128, 237, 226, 151, 29, 142, 240, 185, 166, 181, 1, 14, 244, 64, 176, 175, 77, 122, 73, 60, 179, 43, 29, 138, 96, 55, 254, 102, 0, 93] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [206, 170, 128, 237, 226, 151, 29, 142, 240, 185, 166, 181, 1, 14, 244, 64, 176, 175, 77, 122, 73, 60, 179, 43, 29, 138, 96, 55, 254, 102, 0, 93] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((205, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((205, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((209, ClientHelloExtension { extension_type: 21, ext_len: 205, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 31, extension_data: ServerName(ServerNameList { l: 29, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 26, data: [97, 112, 112, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 45, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [206, 170, 128, 237, 226, 151, 29, 142, 240, 185, 166, 181, 1, 14, 244, 64, 176, 175, 77, 122, 73, 60, 179, 43, 29, 138, 96, 55, 254, 102, 0, 93] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 205, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [7, 8, 138, 238, 247, 25, 122, 108, 209, 182, 170, 142, 104, 206, 163, 151, 230, 21, 15, 150, 14, 171, 106, 128, 136, 67, 177, 175, 218, 213, 185, 95], legacy_session_id: SessionId { l: 32, id: [184, 38, 173, 167, 62, 145, 161, 247, 222, 34, 192, 178, 180, 224, 235, 112, 159, 87, 85, 159, 3, 110, 38, 56, 251, 161, 127, 215, 146, 86, 242, 43] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 31, extension_data: ServerName(ServerNameList { l: 29, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 26, data: [97, 112, 112, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 45, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [206, 170, 128, 237, 226, 151, 29, 142, 240, 185, 166, 181, 1, 14, 244, 64, 176, 175, 77, 122, 73, 60, 179, 43, 29, 138, 96, 55, 254, 102, 0, 93] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 205, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [7, 8, 138, 238, 247, 25, 122, 108, 209, 182, 170, 142, 104, 206, 163, 151, 230, 21, 15, 150, 14, 171, 106, 128, 136, 67, 177, 175, 218, 213, 185, 95], legacy_session_id: SessionId { l: 32, id: [184, 38, 173, 167, 62, 145, 161, 247, 222, 34, 192, 178, 180, 224, 235, 112, 159, 87, 85, 159, 3, 110, 38, 56, 251, 161, 127, 215, 146, 86, 242, 43] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 31, extension_data: ServerName(ServerNameList { l: 29, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 26, data: [97, 112, 112, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 45, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [206, 170, 128, 237, 226, 151, 29, 142, 240, 185, 166, 181, 1, 14, 244, 64, 176, 175, 77, 122, 73, 60, 179, 43, 29, 138, 96, 55, 254, 102, 0, 93] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 205, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [7, 8, 138, 238, 247, 25, 122, 108, 209, 182, 170, 142, 104, 206, 163, 151, 230, 21, 15, 150, 14, 171, 106, 128, 136, 67, 177, 175, 218, 213, 185, 95], legacy_session_id: SessionId { l: 32, id: [184, 38, 173, 167, 62, 145, 161, 247, 222, 34, 192, 178, 180, 224, 235, 112, 159, 87, 85, 159, 3, 110, 38, 56, 251, 161, 127, 215, 146, 86, 242, 43] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 31, extension_data: ServerName(ServerNameList { l: 29, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 26, data: [97, 112, 112, 45, 97, 110, 97, 108, 121, 116, 105, 99, 115, 45, 115, 101, 114, 118, 105, 99, 101, 115, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [206, 170, 128, 237, 226, 151, 29, 142, 240, 185, 166, 181, 1, 14, 244, 64, 176, 175, 77, 122, 73, 60, 179, 43, 29, 138, 96, 55, 254, 102, 0, 93] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 205, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: userapi.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [201, 206, 227, 104, 30, 1, 87, 225, 172, 129, 39, 149, 4, 223, 142, 102, 39, 178, 147, 126, 57, 22, 245, 99, 58, 135, 200, 44, 241, 201, 39, 60] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [117, 115, 101, 114, 97, 112, 105, 46, 99, 111, 109] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [117, 115, 101, 114, 97, 112, 105, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [117, 115, 101, 114, 97, 112, 105, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 115, 101, 114, 97, 112, 105, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 115, 101, 114, 97, 112, 105, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 115, 101, 114, 97, 112, 105, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 115, 101, 114, 97, 112, 105, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [7, 224, 99, 162, 196, 116, 93, 88, 66, 171, 177, 147, 38, 82, 8, 224, 176, 14, 71, 65, 98, 154, 201, 77, 162, 135, 38, 41, 246, 203, 115, 35] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 224, 99, 162, 196, 116, 93, 88, 66, 171, 177, 147, 38, 82, 8, 224, 176, 14, 71, 65, 98, 154, 201, 77, 162, 135, 38, 41, 246, 203, 115, 35] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 224, 99, 162, 196, 116, 93, 88, 66, 171, 177, 147, 38, 82, 8, 224, 176, 14, 71, 65, 98, 154, 201, 77, 162, 135, 38, 41, 246, 203, 115, 35] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 224, 99, 162, 196, 116, 93, 88, 66, 171, 177, 147, 38, 82, 8, 224, 176, 14, 71, 65, 98, 154, 201, 77, 162, 135, 38, 41, 246, 203, 115, 35] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 115, 101, 114, 97, 112, 105, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 224, 99, 162, 196, 116, 93, 88, 66, 171, 177, 147, 38, 82, 8, 224, 176, 14, 71, 65, 98, 154, 201, 77, 162, 135, 38, 41, 246, 203, 115, 35] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [228, 166, 49, 73, 245, 33, 80, 56, 59, 178, 11, 45, 206, 93, 227, 174, 104, 238, 49, 184, 64, 175, 75, 205, 156, 100, 246, 21, 194, 24, 82, 103], legacy_session_id: SessionId { l: 32, id: [201, 206, 227, 104, 30, 1, 87, 225, 172, 129, 39, 149, 4, 223, 142, 102, 39, 178, 147, 126, 57, 22, 245, 99, 58, 135, 200, 44, 241, 201, 39, 60] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 115, 101, 114, 97, 112, 105, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 224, 99, 162, 196, 116, 93, 88, 66, 171, 177, 147, 38, 82, 8, 224, 176, 14, 71, 65, 98, 154, 201, 77, 162, 135, 38, 41, 246, 203, 115, 35] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [228, 166, 49, 73, 245, 33, 80, 56, 59, 178, 11, 45, 206, 93, 227, 174, 104, 238, 49, 184, 64, 175, 75, 205, 156, 100, 246, 21, 194, 24, 82, 103], legacy_session_id: SessionId { l: 32, id: [201, 206, 227, 104, 30, 1, 87, 225, 172, 129, 39, 149, 4, 223, 142, 102, 39, 178, 147, 126, 57, 22, 245, 99, 58, 135, 200, 44, 241, 201, 39, 60] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 115, 101, 114, 97, 112, 105, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 224, 99, 162, 196, 116, 93, 88, 66, 171, 177, 147, 38, 82, 8, 224, 176, 14, 71, 65, 98, 154, 201, 77, 162, 135, 38, 41, 246, 203, 115, 35] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [228, 166, 49, 73, 245, 33, 80, 56, 59, 178, 11, 45, 206, 93, 227, 174, 104, 238, 49, 184, 64, 175, 75, 205, 156, 100, 246, 21, 194, 24, 82, 103], legacy_session_id: SessionId { l: 32, id: [201, 206, 227, 104, 30, 1, 87, 225, 172, 129, 39, 149, 4, 223, 142, 102, 39, 178, 147, 126, 57, 22, 245, 99, 58, 135, 200, 44, 241, 201, 39, 60] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [117, 115, 101, 114, 97, 112, 105, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [7, 224, 99, 162, 196, 116, 93, 88, 66, 171, 177, 147, 38, 82, 8, 224, 176, 14, 71, 65, 98, 154, 201, 77, 162, 135, 38, 41, 246, 203, 115, 35] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: nginx.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [143, 205, 219, 25, 220, 63, 67, 2, 199, 91, 239, 170, 174, 36, 195, 140, 181, 110, 221, 101, 123, 123, 118, 3, 69, 4, 77, 42, 214, 47, 222, 153] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [77, 109, 239, 77, 172, 147, 224, 106, 138, 152, 255, 181, 111, 28, 152, 150, 180, 225, 159, 169, 141, 65, 135, 194, 51, 226, 100, 40, 179, 213, 86, 98] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [77, 109, 239, 77, 172, 147, 224, 106, 138, 152, 255, 181, 111, 28, 152, 150, 180, 225, 159, 169, 141, 65, 135, 194, 51, 226, 100, 40, 179, 213, 86, 98] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [77, 109, 239, 77, 172, 147, 224, 106, 138, 152, 255, 181, 111, 28, 152, 150, 180, 225, 159, 169, 141, 65, 135, 194, 51, 226, 100, 40, 179, 213, 86, 98] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [77, 109, 239, 77, 172, 147, 224, 106, 138, 152, 255, 181, 111, 28, 152, 150, 180, 225, 159, 169, 141, 65, 135, 194, 51, 226, 100, 40, 179, 213, 86, 98] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [77, 109, 239, 77, 172, 147, 224, 106, 138, 152, 255, 181, 111, 28, 152, 150, 180, 225, 159, 169, 141, 65, 135, 194, 51, 226, 100, 40, 179, 213, 86, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [53, 107, 44, 210, 150, 98, 231, 230, 102, 230, 168, 68, 208, 157, 221, 38, 54, 158, 91, 183, 159, 239, 215, 233, 98, 6, 63, 155, 80, 171, 160, 122], legacy_session_id: SessionId { l: 32, id: [143, 205, 219, 25, 220, 63, 67, 2, 199, 91, 239, 170, 174, 36, 195, 140, 181, 110, 221, 101, 123, 123, 118, 3, 69, 4, 77, 42, 214, 47, 222, 153] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [77, 109, 239, 77, 172, 147, 224, 106, 138, 152, 255, 181, 111, 28, 152, 150, 180, 225, 159, 169, 141, 65, 135, 194, 51, 226, 100, 40, 179, 213, 86, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [53, 107, 44, 210, 150, 98, 231, 230, 102, 230, 168, 68, 208, 157, 221, 38, 54, 158, 91, 183, 159, 239, 215, 233, 98, 6, 63, 155, 80, 171, 160, 122], legacy_session_id: SessionId { l: 32, id: [143, 205, 219, 25, 220, 63, 67, 2, 199, 91, 239, 170, 174, 36, 195, 140, 181, 110, 221, 101, 123, 123, 118, 3, 69, 4, 77, 42, 214, 47, 222, 153] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [77, 109, 239, 77, 172, 147, 224, 106, 138, 152, 255, 181, 111, 28, 152, 150, 180, 225, 159, 169, 141, 65, 135, 194, 51, 226, 100, 40, 179, 213, 86, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [53, 107, 44, 210, 150, 98, 231, 230, 102, 230, 168, 68, 208, 157, 221, 38, 54, 158, 91, 183, 159, 239, 215, 233, 98, 6, 63, 155, 80, 171, 160, 122], legacy_session_id: SessionId { l: 32, id: [143, 205, 219, 25, 220, 63, 67, 2, 199, 91, 239, 170, 174, 36, 195, 140, 181, 110, 221, 101, 123, 123, 118, 3, 69, 4, 77, 42, 214, 47, 222, 153] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [77, 109, 239, 77, 172, 147, 224, 106, 138, 152, 255, 181, 111, 28, 152, 150, 180, 225, 159, 169, 141, 65, 135, 194, 51, 226, 100, 40, 179, 213, 86, 98] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [143, 205, 219, 25, 220, 63, 67, 2, 199, 91, 239, 170, 174, 36, 195, 140, 181, 110, 221, 101, 123, 123, 118, 3, 69, 4, 77, 42, 214, 47, 222, 153] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 23))
+[trace] KeyShareEntry: Ok((69, KeyShareEntry { group: 23, l: 65, key_exchange: [4, 141, 200, 124, 231, 229, 245, 199, 255, 6, 131, 157, 173, 94, 214, 100, 17, 242, 35, 237, 108, 168, 222, 153, 191, 90, 244, 229, 24, 104, 61, 68, 223, 239, 131, 17, 33, 186, 206, 177, 73, 60, 108, 21, 200, 29, 190, 75, 214, 117, 91, 123, 227, 210, 0, 131, 35, 125, 250, 131, 117, 200, 60, 155, 17] }))
+[trace] KeyShareClientHello: Ok((71, KeyShareClientHello { l: 69, list: RepeatResult([KeyShareEntry { group: 23, l: 65, key_exchange: [4, 141, 200, 124, 231, 229, 245, 199, 255, 6, 131, 157, 173, 94, 214, 100, 17, 242, 35, 237, 108, 168, 222, 153, 191, 90, 244, 229, 24, 104, 61, 68, 223, 239, 131, 17, 33, 186, 206, 177, 73, 60, 108, 21, 200, 29, 190, 75, 214, 117, 91, 123, 227, 210, 0, 131, 35, 125, 250, 131, 117, 200, 60, 155, 17] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((71, KeyShare(KeyShareClientHello { l: 69, list: RepeatResult([KeyShareEntry { group: 23, l: 65, key_exchange: [4, 141, 200, 124, 231, 229, 245, 199, 255, 6, 131, 157, 173, 94, 214, 100, 17, 242, 35, 237, 108, 168, 222, 153, 191, 90, 244, 229, 24, 104, 61, 68, 223, 239, 131, 17, 33, 186, 206, 177, 73, 60, 108, 21, 200, 29, 190, 75, 214, 117, 91, 123, 227, 210, 0, 131, 35, 125, 250, 131, 117, 200, 60, 155, 17] }]) })))
+[trace] ClientHelloExtension: Ok((75, ClientHelloExtension { extension_type: 51, ext_len: 71, extension_data: KeyShare(KeyShareClientHello { l: 69, list: RepeatResult([KeyShareEntry { group: 23, l: 65, key_exchange: [4, 141, 200, 124, 231, 229, 245, 199, 255, 6, 131, 157, 173, 94, 214, 100, 17, 242, 35, 237, 108, 168, 222, 153, 191, 90, 244, 229, 24, 104, 61, 68, 223, 239, 131, 17, 33, 186, 206, 177, 73, 60, 108, 21, 200, 29, 190, 75, 214, 117, 91, 123, 227, 210, 0, 131, 35, 125, 250, 131, 117, 200, 60, 155, 17] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((189, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((189, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((193, ClientHelloExtension { extension_type: 21, ext_len: 189, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 71, extension_data: KeyShare(KeyShareClientHello { l: 69, list: RepeatResult([KeyShareEntry { group: 23, l: 65, key_exchange: [4, 141, 200, 124, 231, 229, 245, 199, 255, 6, 131, 157, 173, 94, 214, 100, 17, 242, 35, 237, 108, 168, 222, 153, 191, 90, 244, 229, 24, 104, 61, 68, 223, 239, 131, 17, 33, 186, 206, 177, 73, 60, 108, 21, 200, 29, 190, 75, 214, 117, 91, 123, 227, 210, 0, 131, 35, 125, 250, 131, 117, 200, 60, 155, 17] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 189, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [53, 107, 44, 210, 150, 98, 231, 230, 102, 230, 168, 68, 208, 157, 221, 38, 54, 158, 91, 183, 159, 239, 215, 233, 98, 6, 63, 155, 80, 171, 160, 122], legacy_session_id: SessionId { l: 32, id: [143, 205, 219, 25, 220, 63, 67, 2, 199, 91, 239, 170, 174, 36, 195, 140, 181, 110, 221, 101, 123, 123, 118, 3, 69, 4, 77, 42, 214, 47, 222, 153] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 71, extension_data: KeyShare(KeyShareClientHello { l: 69, list: RepeatResult([KeyShareEntry { group: 23, l: 65, key_exchange: [4, 141, 200, 124, 231, 229, 245, 199, 255, 6, 131, 157, 173, 94, 214, 100, 17, 242, 35, 237, 108, 168, 222, 153, 191, 90, 244, 229, 24, 104, 61, 68, 223, 239, 131, 17, 33, 186, 206, 177, 73, 60, 108, 21, 200, 29, 190, 75, 214, 117, 91, 123, 227, 210, 0, 131, 35, 125, 250, 131, 117, 200, 60, 155, 17] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 189, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [53, 107, 44, 210, 150, 98, 231, 230, 102, 230, 168, 68, 208, 157, 221, 38, 54, 158, 91, 183, 159, 239, 215, 233, 98, 6, 63, 155, 80, 171, 160, 122], legacy_session_id: SessionId { l: 32, id: [143, 205, 219, 25, 220, 63, 67, 2, 199, 91, 239, 170, 174, 36, 195, 140, 181, 110, 221, 101, 123, 123, 118, 3, 69, 4, 77, 42, 214, 47, 222, 153] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 71, extension_data: KeyShare(KeyShareClientHello { l: 69, list: RepeatResult([KeyShareEntry { group: 23, l: 65, key_exchange: [4, 141, 200, 124, 231, 229, 245, 199, 255, 6, 131, 157, 173, 94, 214, 100, 17, 242, 35, 237, 108, 168, 222, 153, 191, 90, 244, 229, 24, 104, 61, 68, 223, 239, 131, 17, 33, 186, 206, 177, 73, 60, 108, 21, 200, 29, 190, 75, 214, 117, 91, 123, 227, 210, 0, 131, 35, 125, 250, 131, 117, 200, 60, 155, 17] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 189, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [53, 107, 44, 210, 150, 98, 231, 230, 102, 230, 168, 68, 208, 157, 221, 38, 54, 158, 91, 183, 159, 239, 215, 233, 98, 6, 63, 155, 80, 171, 160, 122], legacy_session_id: SessionId { l: 32, id: [143, 205, 219, 25, 220, 63, 67, 2, 199, 91, 239, 170, 174, 36, 195, 140, 181, 110, 221, 101, 123, 123, 118, 3, 69, 4, 77, 42, 214, 47, 222, 153] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [110, 103, 105, 110, 120, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 71, extension_data: KeyShare(KeyShareClientHello { l: 69, list: RepeatResult([KeyShareEntry { group: 23, l: 65, key_exchange: [4, 141, 200, 124, 231, 229, 245, 199, 255, 6, 131, 157, 173, 94, 214, 100, 17, 242, 35, 237, 108, 168, 222, 153, 191, 90, 244, 229, 24, 104, 61, 68, 223, 239, 131, 17, 33, 186, 206, 177, 73, 60, 108, 21, 200, 29, 190, 75, 214, 117, 91, 123, 227, 210, 0, 131, 35, 125, 250, 131, 117, 200, 60, 155, 17] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 189, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: app-measurement.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [56, 176, 245, 54, 147, 66, 6, 250, 11, 148, 4, 124, 46, 46, 246, 43, 209, 219, 146, 234, 232, 133, 160, 125, 4, 148, 213, 250, 88, 63, 177, 16] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((21, Opaque1Ffff { l: 19, data: [97, 112, 112, 45, 109, 101, 97, 115, 117, 114, 101, 109, 101, 110, 116, 46, 99, 111, 109] }))
+[trace] HostName: Ok((21, Opaque1Ffff { l: 19, data: [97, 112, 112, 45, 109, 101, 97, 115, 117, 114, 101, 109, 101, 110, 116, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((21, HostName(Opaque1Ffff { l: 19, data: [97, 112, 112, 45, 109, 101, 97, 115, 117, 114, 101, 109, 101, 110, 116, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((22, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 19, data: [97, 112, 112, 45, 109, 101, 97, 115, 117, 114, 101, 109, 101, 110, 116, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((24, ServerNameList { l: 22, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 19, data: [97, 112, 112, 45, 109, 101, 97, 115, 117, 114, 101, 109, 101, 110, 116, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((24, ServerName(ServerNameList { l: 22, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 19, data: [97, 112, 112, 45, 109, 101, 97, 115, 117, 114, 101, 109, 101, 110, 116, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((28, ClientHelloExtension { extension_type: 0, ext_len: 24, extension_data: ServerName(ServerNameList { l: 22, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 19, data: [97, 112, 112, 45, 109, 101, 97, 115, 117, 114, 101, 109, 101, 110, 116, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [150, 151, 115, 23, 94, 29, 251, 120, 99, 17, 89, 117, 212, 202, 58, 144, 45, 126, 118, 30, 101, 83, 34, 210, 6, 181, 111, 155, 144, 96, 215, 62] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [150, 151, 115, 23, 94, 29, 251, 120, 99, 17, 89, 117, 212, 202, 58, 144, 45, 126, 118, 30, 101, 83, 34, 210, 6, 181, 111, 155, 144, 96, 215, 62] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [150, 151, 115, 23, 94, 29, 251, 120, 99, 17, 89, 117, 212, 202, 58, 144, 45, 126, 118, 30, 101, 83, 34, 210, 6, 181, 111, 155, 144, 96, 215, 62] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [150, 151, 115, 23, 94, 29, 251, 120, 99, 17, 89, 117, 212, 202, 58, 144, 45, 126, 118, 30, 101, 83, 34, 210, 6, 181, 111, 155, 144, 96, 215, 62] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((212, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((212, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((216, ClientHelloExtension { extension_type: 21, ext_len: 212, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 24, extension_data: ServerName(ServerNameList { l: 22, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 19, data: [97, 112, 112, 45, 109, 101, 97, 115, 117, 114, 101, 109, 101, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [150, 151, 115, 23, 94, 29, 251, 120, 99, 17, 89, 117, 212, 202, 58, 144, 45, 126, 118, 30, 101, 83, 34, 210, 6, 181, 111, 155, 144, 96, 215, 62] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 212, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [103, 172, 255, 100, 203, 88, 219, 165, 192, 89, 240, 57, 214, 55, 74, 107, 240, 168, 166, 181, 169, 77, 24, 51, 67, 37, 215, 236, 27, 158, 208, 157], legacy_session_id: SessionId { l: 32, id: [56, 176, 245, 54, 147, 66, 6, 250, 11, 148, 4, 124, 46, 46, 246, 43, 209, 219, 146, 234, 232, 133, 160, 125, 4, 148, 213, 250, 88, 63, 177, 16] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 24, extension_data: ServerName(ServerNameList { l: 22, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 19, data: [97, 112, 112, 45, 109, 101, 97, 115, 117, 114, 101, 109, 101, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [150, 151, 115, 23, 94, 29, 251, 120, 99, 17, 89, 117, 212, 202, 58, 144, 45, 126, 118, 30, 101, 83, 34, 210, 6, 181, 111, 155, 144, 96, 215, 62] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 212, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [103, 172, 255, 100, 203, 88, 219, 165, 192, 89, 240, 57, 214, 55, 74, 107, 240, 168, 166, 181, 169, 77, 24, 51, 67, 37, 215, 236, 27, 158, 208, 157], legacy_session_id: SessionId { l: 32, id: [56, 176, 245, 54, 147, 66, 6, 250, 11, 148, 4, 124, 46, 46, 246, 43, 209, 219, 146, 234, 232, 133, 160, 125, 4, 148, 213, 250, 88, 63, 177, 16] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 24, extension_data: ServerName(ServerNameList { l: 22, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 19, data: [97, 112, 112, 45, 109, 101, 97, 115, 117, 114, 101, 109, 101, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [150, 151, 115, 23, 94, 29, 251, 120, 99, 17, 89, 117, 212, 202, 58, 144, 45, 126, 118, 30, 101, 83, 34, 210, 6, 181, 111, 155, 144, 96, 215, 62] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 212, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [103, 172, 255, 100, 203, 88, 219, 165, 192, 89, 240, 57, 214, 55, 74, 107, 240, 168, 166, 181, 169, 77, 24, 51, 67, 37, 215, 236, 27, 158, 208, 157], legacy_session_id: SessionId { l: 32, id: [56, 176, 245, 54, 147, 66, 6, 250, 11, 148, 4, 124, 46, 46, 246, 43, 209, 219, 146, 234, 232, 133, 160, 125, 4, 148, 213, 250, 88, 63, 177, 16] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 24, extension_data: ServerName(ServerNameList { l: 22, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 19, data: [97, 112, 112, 45, 109, 101, 97, 115, 117, 114, 101, 109, 101, 110, 116, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [150, 151, 115, 23, 94, 29, 251, 120, 99, 17, 89, 117, 212, 202, 58, 144, 45, 126, 118, 30, 101, 83, 34, 210, 6, 181, 111, 155, 144, 96, 215, 62] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 212, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: sentry.io
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [204, 206, 169, 45, 144, 204, 56, 12, 187, 225, 8, 59, 126, 174, 67, 251, 169, 152, 223, 44, 141, 181, 144, 213, 6, 242, 137, 184, 134, 74, 106, 165] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((11, Opaque1Ffff { l: 9, data: [115, 101, 110, 116, 114, 121, 46, 105, 111] }))
+[trace] HostName: Ok((11, Opaque1Ffff { l: 9, data: [115, 101, 110, 116, 114, 121, 46, 105, 111] }))
+[trace] ServerNameName: Ok((11, HostName(Opaque1Ffff { l: 9, data: [115, 101, 110, 116, 114, 121, 46, 105, 111] })))
+[trace] ServerName: Ok((12, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 101, 110, 116, 114, 121, 46, 105, 111] }) }))
+[trace] ServerNameList: Ok((14, ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 101, 110, 116, 114, 121, 46, 105, 111] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((14, ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 101, 110, 116, 114, 121, 46, 105, 111] }) }]) })))
+[trace] ClientHelloExtension: Ok((18, ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 101, 110, 116, 114, 121, 46, 105, 111] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [20, 138, 202, 45, 199, 111, 146, 159, 141, 101, 89, 4, 75, 210, 145, 128, 109, 26, 150, 246, 65, 34, 108, 50, 62, 141, 61, 199, 9, 193, 250, 15] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [20, 138, 202, 45, 199, 111, 146, 159, 141, 101, 89, 4, 75, 210, 145, 128, 109, 26, 150, 246, 65, 34, 108, 50, 62, 141, 61, 199, 9, 193, 250, 15] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [20, 138, 202, 45, 199, 111, 146, 159, 141, 101, 89, 4, 75, 210, 145, 128, 109, 26, 150, 246, 65, 34, 108, 50, 62, 141, 61, 199, 9, 193, 250, 15] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [20, 138, 202, 45, 199, 111, 146, 159, 141, 101, 89, 4, 75, 210, 145, 128, 109, 26, 150, 246, 65, 34, 108, 50, 62, 141, 61, 199, 9, 193, 250, 15] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((222, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((222, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((226, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 101, 110, 116, 114, 121, 46, 105, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [20, 138, 202, 45, 199, 111, 146, 159, 141, 101, 89, 4, 75, 210, 145, 128, 109, 26, 150, 246, 65, 34, 108, 50, 62, 141, 61, 199, 9, 193, 250, 15] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [68, 38, 66, 161, 169, 179, 127, 171, 72, 83, 67, 195, 152, 106, 97, 33, 157, 45, 83, 170, 136, 161, 54, 46, 203, 63, 147, 159, 154, 232, 33, 130], legacy_session_id: SessionId { l: 32, id: [204, 206, 169, 45, 144, 204, 56, 12, 187, 225, 8, 59, 126, 174, 67, 251, 169, 152, 223, 44, 141, 181, 144, 213, 6, 242, 137, 184, 134, 74, 106, 165] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 101, 110, 116, 114, 121, 46, 105, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [20, 138, 202, 45, 199, 111, 146, 159, 141, 101, 89, 4, 75, 210, 145, 128, 109, 26, 150, 246, 65, 34, 108, 50, 62, 141, 61, 199, 9, 193, 250, 15] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [68, 38, 66, 161, 169, 179, 127, 171, 72, 83, 67, 195, 152, 106, 97, 33, 157, 45, 83, 170, 136, 161, 54, 46, 203, 63, 147, 159, 154, 232, 33, 130], legacy_session_id: SessionId { l: 32, id: [204, 206, 169, 45, 144, 204, 56, 12, 187, 225, 8, 59, 126, 174, 67, 251, 169, 152, 223, 44, 141, 181, 144, 213, 6, 242, 137, 184, 134, 74, 106, 165] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 101, 110, 116, 114, 121, 46, 105, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [20, 138, 202, 45, 199, 111, 146, 159, 141, 101, 89, 4, 75, 210, 145, 128, 109, 26, 150, 246, 65, 34, 108, 50, 62, 141, 61, 199, 9, 193, 250, 15] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [68, 38, 66, 161, 169, 179, 127, 171, 72, 83, 67, 195, 152, 106, 97, 33, 157, 45, 83, 170, 136, 161, 54, 46, 203, 63, 147, 159, 154, 232, 33, 130], legacy_session_id: SessionId { l: 32, id: [204, 206, 169, 45, 144, 204, 56, 12, 187, 225, 8, 59, 126, 174, 67, 251, 169, 152, 223, 44, 141, 181, 144, 213, 6, 242, 137, 184, 134, 74, 106, 165] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 14, extension_data: ServerName(ServerNameList { l: 12, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 9, data: [115, 101, 110, 116, 114, 121, 46, 105, 111] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [20, 138, 202, 45, 199, 111, 146, 159, 141, 101, 89, 4, 75, 210, 145, 128, 109, 26, 150, 246, 65, 34, 108, 50, 62, 141, 61, 199, 9, 193, 250, 15] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 222, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: tumblr.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [65, 160, 10, 3, 171, 80, 222, 14, 251, 102, 151, 112, 123, 223, 76, 252, 190, 72, 242, 111, 166, 164, 182, 56, 190, 212, 231, 126, 217, 236, 186, 159] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [116, 117, 109, 98, 108, 114, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [116, 117, 109, 98, 108, 114, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [116, 117, 109, 98, 108, 114, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 117, 109, 98, 108, 114, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 117, 109, 98, 108, 114, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 117, 109, 98, 108, 114, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 117, 109, 98, 108, 114, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [72, 77, 97, 153, 125, 148, 8, 144, 92, 197, 73, 41, 140, 102, 15, 41, 101, 41, 165, 63, 146, 26, 221, 188, 205, 87, 212, 222, 229, 121, 170, 63] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [72, 77, 97, 153, 125, 148, 8, 144, 92, 197, 73, 41, 140, 102, 15, 41, 101, 41, 165, 63, 146, 26, 221, 188, 205, 87, 212, 222, 229, 121, 170, 63] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [72, 77, 97, 153, 125, 148, 8, 144, 92, 197, 73, 41, 140, 102, 15, 41, 101, 41, 165, 63, 146, 26, 221, 188, 205, 87, 212, 222, 229, 121, 170, 63] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [72, 77, 97, 153, 125, 148, 8, 144, 92, 197, 73, 41, 140, 102, 15, 41, 101, 41, 165, 63, 146, 26, 221, 188, 205, 87, 212, 222, 229, 121, 170, 63] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 117, 109, 98, 108, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [72, 77, 97, 153, 125, 148, 8, 144, 92, 197, 73, 41, 140, 102, 15, 41, 101, 41, 165, 63, 146, 26, 221, 188, 205, 87, 212, 222, 229, 121, 170, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [116, 152, 36, 40, 117, 189, 199, 212, 126, 125, 238, 63, 166, 1, 214, 120, 190, 101, 121, 73, 230, 63, 72, 9, 197, 236, 155, 82, 198, 225, 172, 212], legacy_session_id: SessionId { l: 32, id: [65, 160, 10, 3, 171, 80, 222, 14, 251, 102, 151, 112, 123, 223, 76, 252, 190, 72, 242, 111, 166, 164, 182, 56, 190, 212, 231, 126, 217, 236, 186, 159] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 117, 109, 98, 108, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [72, 77, 97, 153, 125, 148, 8, 144, 92, 197, 73, 41, 140, 102, 15, 41, 101, 41, 165, 63, 146, 26, 221, 188, 205, 87, 212, 222, 229, 121, 170, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [116, 152, 36, 40, 117, 189, 199, 212, 126, 125, 238, 63, 166, 1, 214, 120, 190, 101, 121, 73, 230, 63, 72, 9, 197, 236, 155, 82, 198, 225, 172, 212], legacy_session_id: SessionId { l: 32, id: [65, 160, 10, 3, 171, 80, 222, 14, 251, 102, 151, 112, 123, 223, 76, 252, 190, 72, 242, 111, 166, 164, 182, 56, 190, 212, 231, 126, 217, 236, 186, 159] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 117, 109, 98, 108, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [72, 77, 97, 153, 125, 148, 8, 144, 92, 197, 73, 41, 140, 102, 15, 41, 101, 41, 165, 63, 146, 26, 221, 188, 205, 87, 212, 222, 229, 121, 170, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [116, 152, 36, 40, 117, 189, 199, 212, 126, 125, 238, 63, 166, 1, 214, 120, 190, 101, 121, 73, 230, 63, 72, 9, 197, 236, 155, 82, 198, 225, 172, 212], legacy_session_id: SessionId { l: 32, id: [65, 160, 10, 3, 171, 80, 222, 14, 251, 102, 151, 112, 123, 223, 76, 252, 190, 72, 242, 111, 166, 164, 182, 56, 190, 212, 231, 126, 217, 236, 186, 159] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [116, 117, 109, 98, 108, 114, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [72, 77, 97, 153, 125, 148, 8, 144, 92, 197, 73, 41, 140, 102, 15, 41, 101, 41, 165, 63, 146, 26, 221, 188, 205, 87, 212, 222, 229, 121, 170, 63] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: criteo.com
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [93, 102, 34, 124, 126, 204, 163, 211, 147, 197, 57, 58, 79, 138, 73, 69, 97, 102, 66, 152, 50, 5, 116, 229, 189, 68, 112, 99, 223, 11, 98, 235] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [99, 114, 105, 116, 101, 111, 46, 99, 111, 109] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [99, 114, 105, 116, 101, 111, 46, 99, 111, 109] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [99, 114, 105, 116, 101, 111, 46, 99, 111, 109] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [99, 114, 105, 116, 101, 111, 46, 99, 111, 109] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [99, 114, 105, 116, 101, 111, 46, 99, 111, 109] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [99, 114, 105, 116, 101, 111, 46, 99, 111, 109] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [99, 114, 105, 116, 101, 111, 46, 99, 111, 109] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [214, 4, 211, 15, 156, 93, 137, 174, 101, 228, 171, 218, 44, 60, 94, 145, 125, 253, 75, 182, 233, 101, 248, 203, 114, 81, 8, 32, 196, 198, 192, 41] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [214, 4, 211, 15, 156, 93, 137, 174, 101, 228, 171, 218, 44, 60, 94, 145, 125, 253, 75, 182, 233, 101, 248, 203, 114, 81, 8, 32, 196, 198, 192, 41] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [214, 4, 211, 15, 156, 93, 137, 174, 101, 228, 171, 218, 44, 60, 94, 145, 125, 253, 75, 182, 233, 101, 248, 203, 114, 81, 8, 32, 196, 198, 192, 41] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [214, 4, 211, 15, 156, 93, 137, 174, 101, 228, 171, 218, 44, 60, 94, 145, 125, 253, 75, 182, 233, 101, 248, 203, 114, 81, 8, 32, 196, 198, 192, 41] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [99, 114, 105, 116, 101, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [214, 4, 211, 15, 156, 93, 137, 174, 101, 228, 171, 218, 44, 60, 94, 145, 125, 253, 75, 182, 233, 101, 248, 203, 114, 81, 8, 32, 196, 198, 192, 41] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [231, 103, 0, 199, 130, 199, 158, 3, 44, 229, 127, 139, 119, 117, 189, 159, 230, 59, 129, 238, 75, 21, 109, 84, 183, 182, 190, 78, 240, 226, 80, 221], legacy_session_id: SessionId { l: 32, id: [93, 102, 34, 124, 126, 204, 163, 211, 147, 197, 57, 58, 79, 138, 73, 69, 97, 102, 66, 152, 50, 5, 116, 229, 189, 68, 112, 99, 223, 11, 98, 235] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [99, 114, 105, 116, 101, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [214, 4, 211, 15, 156, 93, 137, 174, 101, 228, 171, 218, 44, 60, 94, 145, 125, 253, 75, 182, 233, 101, 248, 203, 114, 81, 8, 32, 196, 198, 192, 41] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [231, 103, 0, 199, 130, 199, 158, 3, 44, 229, 127, 139, 119, 117, 189, 159, 230, 59, 129, 238, 75, 21, 109, 84, 183, 182, 190, 78, 240, 226, 80, 221], legacy_session_id: SessionId { l: 32, id: [93, 102, 34, 124, 126, 204, 163, 211, 147, 197, 57, 58, 79, 138, 73, 69, 97, 102, 66, 152, 50, 5, 116, 229, 189, 68, 112, 99, 223, 11, 98, 235] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [99, 114, 105, 116, 101, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [214, 4, 211, 15, 156, 93, 137, 174, 101, 228, 171, 218, 44, 60, 94, 145, 125, 253, 75, 182, 233, 101, 248, 203, 114, 81, 8, 32, 196, 198, 192, 41] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [231, 103, 0, 199, 130, 199, 158, 3, 44, 229, 127, 139, 119, 117, 189, 159, 230, 59, 129, 238, 75, 21, 109, 84, 183, 182, 190, 78, 240, 226, 80, 221], legacy_session_id: SessionId { l: 32, id: [93, 102, 34, 124, 126, 204, 163, 211, 147, 197, 57, 58, 79, 138, 73, 69, 97, 102, 66, 152, 50, 5, 116, 229, 189, 68, 112, 99, 223, 11, 98, 235] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [99, 114, 105, 116, 101, 111, 46, 99, 111, 109] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [214, 4, 211, 15, 156, 93, 137, 174, 101, 228, 171, 218, 44, 60, 94, 145, 125, 253, 75, 182, 233, 101, 248, 203, 114, 81, 8, 32, 196, 198, 192, 41] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: dns.google
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [40, 208, 157, 38, 81, 104, 141, 106, 253, 176, 0, 104, 14, 133, 26, 122, 65, 71, 55, 198, 162, 172, 44, 189, 30, 225, 193, 133, 239, 44, 129, 37] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((12, Opaque1Ffff { l: 10, data: [100, 110, 115, 46, 103, 111, 111, 103, 108, 101] }))
+[trace] HostName: Ok((12, Opaque1Ffff { l: 10, data: [100, 110, 115, 46, 103, 111, 111, 103, 108, 101] }))
+[trace] ServerNameName: Ok((12, HostName(Opaque1Ffff { l: 10, data: [100, 110, 115, 46, 103, 111, 111, 103, 108, 101] })))
+[trace] ServerName: Ok((13, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [100, 110, 115, 46, 103, 111, 111, 103, 108, 101] }) }))
+[trace] ServerNameList: Ok((15, ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [100, 110, 115, 46, 103, 111, 111, 103, 108, 101] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((15, ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [100, 110, 115, 46, 103, 111, 111, 103, 108, 101] }) }]) })))
+[trace] ClientHelloExtension: Ok((19, ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [100, 110, 115, 46, 103, 111, 111, 103, 108, 101] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [251, 76, 237, 217, 232, 245, 176, 220, 65, 87, 228, 248, 80, 38, 114, 254, 59, 60, 36, 126, 112, 162, 36, 230, 45, 108, 51, 162, 117, 103, 251, 50] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [251, 76, 237, 217, 232, 245, 176, 220, 65, 87, 228, 248, 80, 38, 114, 254, 59, 60, 36, 126, 112, 162, 36, 230, 45, 108, 51, 162, 117, 103, 251, 50] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [251, 76, 237, 217, 232, 245, 176, 220, 65, 87, 228, 248, 80, 38, 114, 254, 59, 60, 36, 126, 112, 162, 36, 230, 45, 108, 51, 162, 117, 103, 251, 50] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [251, 76, 237, 217, 232, 245, 176, 220, 65, 87, 228, 248, 80, 38, 114, 254, 59, 60, 36, 126, 112, 162, 36, 230, 45, 108, 51, 162, 117, 103, 251, 50] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((221, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((221, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((225, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [100, 110, 115, 46, 103, 111, 111, 103, 108, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [251, 76, 237, 217, 232, 245, 176, 220, 65, 87, 228, 248, 80, 38, 114, 254, 59, 60, 36, 126, 112, 162, 36, 230, 45, 108, 51, 162, 117, 103, 251, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [107, 70, 153, 74, 22, 214, 39, 236, 79, 60, 150, 47, 239, 201, 33, 53, 203, 90, 59, 164, 29, 197, 110, 9, 49, 189, 123, 222, 176, 79, 209, 37], legacy_session_id: SessionId { l: 32, id: [40, 208, 157, 38, 81, 104, 141, 106, 253, 176, 0, 104, 14, 133, 26, 122, 65, 71, 55, 198, 162, 172, 44, 189, 30, 225, 193, 133, 239, 44, 129, 37] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [100, 110, 115, 46, 103, 111, 111, 103, 108, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [251, 76, 237, 217, 232, 245, 176, 220, 65, 87, 228, 248, 80, 38, 114, 254, 59, 60, 36, 126, 112, 162, 36, 230, 45, 108, 51, 162, 117, 103, 251, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [107, 70, 153, 74, 22, 214, 39, 236, 79, 60, 150, 47, 239, 201, 33, 53, 203, 90, 59, 164, 29, 197, 110, 9, 49, 189, 123, 222, 176, 79, 209, 37], legacy_session_id: SessionId { l: 32, id: [40, 208, 157, 38, 81, 104, 141, 106, 253, 176, 0, 104, 14, 133, 26, 122, 65, 71, 55, 198, 162, 172, 44, 189, 30, 225, 193, 133, 239, 44, 129, 37] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [100, 110, 115, 46, 103, 111, 111, 103, 108, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [251, 76, 237, 217, 232, 245, 176, 220, 65, 87, 228, 248, 80, 38, 114, 254, 59, 60, 36, 126, 112, 162, 36, 230, 45, 108, 51, 162, 117, 103, 251, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [107, 70, 153, 74, 22, 214, 39, 236, 79, 60, 150, 47, 239, 201, 33, 53, 203, 90, 59, 164, 29, 197, 110, 9, 49, 189, 123, 222, 176, 79, 209, 37], legacy_session_id: SessionId { l: 32, id: [40, 208, 157, 38, 81, 104, 141, 106, 253, 176, 0, 104, 14, 133, 26, 122, 65, 71, 55, 198, 162, 172, 44, 189, 30, 225, 193, 133, 239, 44, 129, 37] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 15, extension_data: ServerName(ServerNameList { l: 13, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 10, data: [100, 110, 115, 46, 103, 111, 111, 103, 108, 101] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [251, 76, 237, 217, 232, 245, 176, 220, 65, 87, 228, 248, 80, 38, 114, 254, 59, 60, 36, 126, 112, 162, 36, 230, 45, 108, 51, 162, 117, 103, 251, 50] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 221, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: myfritz.net
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [98, 127, 196, 228, 87, 58, 255, 24, 118, 154, 198, 208, 228, 167, 1, 11, 61, 229, 161, 206, 252, 152, 215, 19, 45, 191, 179, 161, 117, 91, 190, 69] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [109, 121, 102, 114, 105, 116, 122, 46, 110, 101, 116] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [109, 121, 102, 114, 105, 116, 122, 46, 110, 101, 116] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [109, 121, 102, 114, 105, 116, 122, 46, 110, 101, 116] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 121, 102, 114, 105, 116, 122, 46, 110, 101, 116] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 121, 102, 114, 105, 116, 122, 46, 110, 101, 116] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 121, 102, 114, 105, 116, 122, 46, 110, 101, 116] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 121, 102, 114, 105, 116, 122, 46, 110, 101, 116] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [253, 104, 56, 228, 81, 43, 244, 190, 117, 253, 144, 119, 77, 87, 6, 104, 37, 38, 139, 211, 32, 33, 104, 140, 143, 10, 50, 60, 43, 66, 255, 56] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [253, 104, 56, 228, 81, 43, 244, 190, 117, 253, 144, 119, 77, 87, 6, 104, 37, 38, 139, 211, 32, 33, 104, 140, 143, 10, 50, 60, 43, 66, 255, 56] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [253, 104, 56, 228, 81, 43, 244, 190, 117, 253, 144, 119, 77, 87, 6, 104, 37, 38, 139, 211, 32, 33, 104, 140, 143, 10, 50, 60, 43, 66, 255, 56] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [253, 104, 56, 228, 81, 43, 244, 190, 117, 253, 144, 119, 77, 87, 6, 104, 37, 38, 139, 211, 32, 33, 104, 140, 143, 10, 50, 60, 43, 66, 255, 56] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 121, 102, 114, 105, 116, 122, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [253, 104, 56, 228, 81, 43, 244, 190, 117, 253, 144, 119, 77, 87, 6, 104, 37, 38, 139, 211, 32, 33, 104, 140, 143, 10, 50, 60, 43, 66, 255, 56] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [120, 135, 170, 87, 135, 23, 112, 180, 167, 219, 44, 146, 118, 208, 246, 237, 150, 190, 39, 252, 169, 52, 252, 238, 59, 247, 25, 132, 153, 196, 5, 180], legacy_session_id: SessionId { l: 32, id: [98, 127, 196, 228, 87, 58, 255, 24, 118, 154, 198, 208, 228, 167, 1, 11, 61, 229, 161, 206, 252, 152, 215, 19, 45, 191, 179, 161, 117, 91, 190, 69] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 121, 102, 114, 105, 116, 122, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [253, 104, 56, 228, 81, 43, 244, 190, 117, 253, 144, 119, 77, 87, 6, 104, 37, 38, 139, 211, 32, 33, 104, 140, 143, 10, 50, 60, 43, 66, 255, 56] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [120, 135, 170, 87, 135, 23, 112, 180, 167, 219, 44, 146, 118, 208, 246, 237, 150, 190, 39, 252, 169, 52, 252, 238, 59, 247, 25, 132, 153, 196, 5, 180], legacy_session_id: SessionId { l: 32, id: [98, 127, 196, 228, 87, 58, 255, 24, 118, 154, 198, 208, 228, 167, 1, 11, 61, 229, 161, 206, 252, 152, 215, 19, 45, 191, 179, 161, 117, 91, 190, 69] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 121, 102, 114, 105, 116, 122, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [253, 104, 56, 228, 81, 43, 244, 190, 117, 253, 144, 119, 77, 87, 6, 104, 37, 38, 139, 211, 32, 33, 104, 140, 143, 10, 50, 60, 43, 66, 255, 56] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [120, 135, 170, 87, 135, 23, 112, 180, 167, 219, 44, 146, 118, 208, 246, 237, 150, 190, 39, 252, 169, 52, 252, 238, 59, 247, 25, 132, 153, 196, 5, 180], legacy_session_id: SessionId { l: 32, id: [98, 127, 196, 228, 87, 58, 255, 24, 118, 154, 198, 208, 228, 167, 1, 11, 61, 229, 161, 206, 252, 152, 215, 19, 45, 191, 179, 161, 117, 91, 190, 69] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [109, 121, 102, 114, 105, 116, 122, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [253, 104, 56, 228, 81, 43, 244, 190, 117, 253, 144, 119, 77, 87, 6, 104, 37, 38, 139, 211, 32, 33, 104, 140, 143, 10, 50, 60, 43, 66, 255, 56] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+domain: telekom.net
+[trace] HandshakeType: Ok((1, ClientHello))
+[trace] SessionId: Ok((33, SessionId { l: 32, id: [106, 141, 67, 85, 152, 186, 189, 252, 11, 70, 18, 87, 19, 102, 235, 94, 202, 165, 229, 109, 220, 249, 234, 101, 116, 251, 131, 26, 24, 215, 146, 47] }))
+[trace] CipherSuite: Ok((2, 4866))
+[trace] CipherSuite: Ok((2, 4867))
+[trace] CipherSuite: Ok((2, 4865))
+[trace] CipherSuite: Ok((2, 49196))
+[trace] CipherSuite: Ok((2, 49200))
+[trace] CipherSuite: Ok((2, 49195))
+[trace] CipherSuite: Ok((2, 49199))
+[trace] CipherSuite: Ok((2, 52393))
+[trace] CipherSuite: Ok((2, 52392))
+[trace] CipherSuite: Ok((2, 49188))
+[trace] CipherSuite: Ok((2, 49192))
+[trace] CipherSuite: Ok((2, 49187))
+[trace] CipherSuite: Ok((2, 49191))
+[trace] CipherSuite: Ok((2, 159))
+[trace] CipherSuite: Ok((2, 158))
+[trace] CipherSuite: Ok((2, 107))
+[trace] CipherSuite: Ok((2, 103))
+[trace] CipherSuite: Ok((2, 255))
+[trace] CipherSuiteList: Ok((38, CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }))
+[trace] Opaque1Ff: Ok((2, Opaque1Ff { l: 1, data: [0] }))
+[trace] ExtensionType: Ok((2, 0))
+[trace] NameType: Ok((1, 0))
+[trace] Opaque1Ffff: Ok((13, Opaque1Ffff { l: 11, data: [116, 101, 108, 101, 107, 111, 109, 46, 110, 101, 116] }))
+[trace] HostName: Ok((13, Opaque1Ffff { l: 11, data: [116, 101, 108, 101, 107, 111, 109, 46, 110, 101, 116] }))
+[trace] ServerNameName: Ok((13, HostName(Opaque1Ffff { l: 11, data: [116, 101, 108, 101, 107, 111, 109, 46, 110, 101, 116] })))
+[trace] ServerName: Ok((14, ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 101, 108, 101, 107, 111, 109, 46, 110, 101, 116] }) }))
+[trace] ServerNameList: Ok((16, ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 101, 108, 101, 107, 111, 109, 46, 110, 101, 116] }) }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((16, ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 101, 108, 101, 107, 111, 109, 46, 110, 101, 116] }) }]) })))
+[trace] ClientHelloExtension: Ok((20, ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 101, 108, 101, 107, 111, 109, 46, 110, 101, 116] }) }]) }) }))
+[trace] ExtensionType: Ok((2, 11))
+[trace] ClientHelloExtensionRest: Ok((4, Unrecognized([3, 0, 1, 2])))
+[trace] ClientHelloExtensionExtensionData: Ok((4, Unrecognized(Unrecognized([3, 0, 1, 2]))))
+[trace] ClientHelloExtension: Ok((8, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }))
+[trace] ExtensionType: Ok((2, 10))
+[trace] NamedGroup: Ok((2, 29))
+[trace] NamedGroup: Ok((2, 23))
+[trace] NamedGroup: Ok((2, 30))
+[trace] NamedGroup: Ok((2, 25))
+[trace] NamedGroup: Ok((2, 24))
+[trace] NamedGroup: Ok((2, 256))
+[trace] NamedGroup: Ok((2, 257))
+[trace] NamedGroup: Ok((2, 258))
+[trace] NamedGroup: Ok((2, 259))
+[trace] NamedGroup: Ok((2, 260))
+[trace] NamedGroupList: Ok((22, NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((22, SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) })))
+[trace] ClientHelloExtension: Ok((26, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }))
+[trace] ExtensionType: Ok((2, 35))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 22))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 23))
+[trace] ClientHelloExtensionRest: Ok((0, Unrecognized([])))
+[trace] ClientHelloExtensionExtensionData: Ok((0, Unrecognized(Unrecognized([]))))
+[trace] ClientHelloExtension: Ok((4, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }))
+[trace] ExtensionType: Ok((2, 13))
+[trace] SignatureScheme: Ok((2, 1027))
+[trace] SignatureScheme: Ok((2, 1283))
+[trace] SignatureScheme: Ok((2, 1539))
+[trace] SignatureScheme: Ok((2, 2055))
+[trace] SignatureScheme: Ok((2, 2056))
+[trace] SignatureScheme: Ok((2, 2074))
+[trace] SignatureScheme: Ok((2, 2075))
+[trace] SignatureScheme: Ok((2, 2076))
+[trace] SignatureScheme: Ok((2, 2057))
+[trace] SignatureScheme: Ok((2, 2058))
+[trace] SignatureScheme: Ok((2, 2059))
+[trace] SignatureScheme: Ok((2, 2052))
+[trace] SignatureScheme: Ok((2, 2053))
+[trace] SignatureScheme: Ok((2, 2054))
+[trace] SignatureScheme: Ok((2, 1025))
+[trace] SignatureScheme: Ok((2, 1281))
+[trace] SignatureScheme: Ok((2, 1537))
+[trace] SignatureScheme: Ok((2, 771))
+[trace] SignatureScheme: Ok((2, 769))
+[trace] SignatureScheme: Ok((2, 770))
+[trace] SignatureScheme: Ok((2, 1026))
+[trace] SignatureScheme: Ok((2, 1282))
+[trace] SignatureScheme: Ok((2, 1538))
+[trace] SignatureSchemeList: Ok((48, SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((48, SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) })))
+[trace] ClientHelloExtension: Ok((52, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }))
+[trace] ExtensionType: Ok((2, 43))
+[trace] ProtocolVersion: Ok((2, 772))
+[trace] ProtocolVersion: Ok((2, 771))
+[trace] SupportedVersionsClient: Ok((5, SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((5, SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) })))
+[trace] ClientHelloExtension: Ok((9, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }))
+[trace] ExtensionType: Ok((2, 45))
+[trace] PskKeyExchangeMode: Ok((1, 1))
+[trace] PskKeyExchangeModes: Ok((2, PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((2, PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) })))
+[trace] ClientHelloExtension: Ok((6, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }))
+[trace] ExtensionType: Ok((2, 51))
+[trace] NamedGroup: Ok((2, 29))
+[trace] KeyShareEntry: Ok((36, KeyShareEntry { group: 29, l: 32, key_exchange: [217, 215, 198, 179, 250, 114, 226, 25, 165, 164, 40, 250, 84, 52, 66, 192, 194, 60, 224, 120, 136, 209, 119, 46, 176, 242, 91, 194, 77, 114, 143, 126] }))
+[trace] KeyShareClientHello: Ok((38, KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 215, 198, 179, 250, 114, 226, 25, 165, 164, 40, 250, 84, 52, 66, 192, 194, 60, 224, 120, 136, 209, 119, 46, 176, 242, 91, 194, 77, 114, 143, 126] }]) }))
+[trace] ClientHelloExtensionExtensionData: Ok((38, KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 215, 198, 179, 250, 114, 226, 25, 165, 164, 40, 250, 84, 52, 66, 192, 194, 60, 224, 120, 136, 209, 119, 46, 176, 242, 91, 194, 77, 114, 143, 126] }]) })))
+[trace] ClientHelloExtension: Ok((42, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 215, 198, 179, 250, 114, 226, 25, 165, 164, 40, 250, 84, 52, 66, 192, 194, 60, 224, 120, 136, 209, 119, 46, 176, 242, 91, 194, 77, 114, 143, 126] }]) }) }))
+[trace] ExtensionType: Ok((2, 21))
+[trace] ClientHelloExtensionRest: Ok((220, Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+[trace] ClientHelloExtensionExtensionData: Ok((220, Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))))
+[trace] ClientHelloExtension: Ok((224, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }))
+[trace] ClientExtensions: Ok((401, ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 101, 108, 101, 107, 111, 109, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 215, 198, 179, 250, 114, 226, 25, 165, 164, 40, 250, 84, 52, 66, 192, 194, 60, 224, 120, 136, 209, 119, 46, 176, 242, 91, 194, 77, 114, 143, 126] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) }))
+[trace] ClientHello: Ok((508, ClientHello { legacy_version: 771, random: [45, 243, 35, 168, 99, 107, 241, 88, 198, 139, 91, 230, 61, 28, 198, 162, 56, 90, 6, 67, 55, 63, 160, 3, 243, 97, 223, 136, 144, 228, 109, 161], legacy_session_id: SessionId { l: 32, id: [106, 141, 67, 85, 152, 186, 189, 252, 11, 70, 18, 87, 19, 102, 235, 94, 202, 165, 229, 109, 220, 249, 234, 101, 116, 251, 131, 26, 24, 215, 146, 47] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 101, 108, 101, 107, 111, 109, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 215, 198, 179, 250, 114, 226, 25, 165, 164, 40, 250, 84, 52, 66, 192, 194, 60, 224, 120, 136, 209, 119, 46, 176, 242, 91, 194, 77, 114, 143, 126] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }))
+[trace] HandshakeMsg: Ok((508, ClientHello(ClientHello { legacy_version: 771, random: [45, 243, 35, 168, 99, 107, 241, 88, 198, 139, 91, 230, 61, 28, 198, 162, 56, 90, 6, 67, 55, 63, 160, 3, 243, 97, 223, 136, 144, 228, 109, 161], legacy_session_id: SessionId { l: 32, id: [106, 141, 67, 85, 152, 186, 189, 252, 11, 70, 18, 87, 19, 102, 235, 94, 202, 165, 229, 109, 220, 249, 234, 101, 116, 251, 131, 26, 24, 215, 146, 47] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 101, 108, 101, 107, 111, 109, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 215, 198, 179, 250, 114, 226, 25, 165, 164, 40, 250, 84, 52, 66, 192, 194, 60, 224, 120, 136, 209, 119, 46, 176, 242, 91, 194, 77, 114, 143, 126] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } })))
+[trace] Handshake: Ok((512, Handshake { msg_type: ClientHello, length: u24([0, 1, 252]), msg: ClientHello(ClientHello { legacy_version: 771, random: [45, 243, 35, 168, 99, 107, 241, 88, 198, 139, 91, 230, 61, 28, 198, 162, 56, 90, 6, 67, 55, 63, 160, 3, 243, 97, 223, 136, 144, 228, 109, 161], legacy_session_id: SessionId { l: 32, id: [106, 141, 67, 85, 152, 186, 189, 252, 11, 70, 18, 87, 19, 102, 235, 94, 202, 165, 229, 109, 220, 249, 234, 101, 116, 251, 131, 26, 24, 215, 146, 47] }, cipher_suites: CipherSuiteList { l: 36, list: RepeatResult([4866, 4867, 4865, 49196, 49200, 49195, 49199, 52393, 52392, 49188, 49192, 49187, 49191, 159, 158, 107, 103, 255]) }, legacy_compression_methods: Opaque1Ff { l: 1, data: [0] }, extensions: ClientExtensions { l: 399, list: RepeatResult([ClientHelloExtension { extension_type: 0, ext_len: 16, extension_data: ServerName(ServerNameList { l: 14, list: RepeatResult([ServerName { name_type: 0, name: HostName(Opaque1Ffff { l: 11, data: [116, 101, 108, 101, 107, 111, 109, 46, 110, 101, 116] }) }]) }) }, ClientHelloExtension { extension_type: 11, ext_len: 4, extension_data: Unrecognized(Unrecognized([3, 0, 1, 2])) }, ClientHelloExtension { extension_type: 10, ext_len: 22, extension_data: SupportedGroups(NamedGroupList { l: 20, list: RepeatResult([29, 23, 30, 25, 24, 256, 257, 258, 259, 260]) }) }, ClientHelloExtension { extension_type: 35, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 22, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 23, ext_len: 0, extension_data: Unrecognized(Unrecognized([])) }, ClientHelloExtension { extension_type: 13, ext_len: 48, extension_data: SignatureAlgorithms(SignatureSchemeList { l: 46, list: RepeatResult([1027, 1283, 1539, 2055, 2056, 2074, 2075, 2076, 2057, 2058, 2059, 2052, 2053, 2054, 1025, 1281, 1537, 771, 769, 770, 1026, 1282, 1538]) }) }, ClientHelloExtension { extension_type: 43, ext_len: 5, extension_data: SupportedVersions(SupportedVersionsClient { l: 4, list: RepeatResult([772, 771]) }) }, ClientHelloExtension { extension_type: 45, ext_len: 2, extension_data: PskKeyExchangeModes(PskKeyExchangeModes { l: 1, list: RepeatResult([1]) }) }, ClientHelloExtension { extension_type: 51, ext_len: 38, extension_data: KeyShare(KeyShareClientHello { l: 36, list: RepeatResult([KeyShareEntry { group: 29, l: 32, key_exchange: [217, 215, 198, 179, 250, 114, 226, 25, 165, 164, 40, 250, 84, 52, 66, 192, 194, 60, 224, 120, 136, 209, 119, 46, 176, 242, 91, 194, 77, 114, 143, 126] }]) }) }, ClientHelloExtension { extension_type: 21, ext_len: 220, extension_data: Unrecognized(Padding([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])) }]) } }) }))
+[trace] HandshakeType: Err(TryMapFailed)
+[trace] Handshake: Err(TryMapFailed)
+=====================================
+Failed to parse message: Handshake { parsed: HandshakeMessagePayload { typ: ClientKeyExchange, payload: ClientKeyExchange(207feda9bcfa1672fd9fff4cba9cc369bdc90e74b6b04efb3c0b98487f296e407f) }, encoded: 10000021207feda9bcfa1672fd9fff4cba9cc369bdc90e74b6b04efb3c0b98487f296e407f }
+=====================================
+Rustls successfully parsed 121 client messages
+Vestls Successfully parsed 107 client messages
+Successfully parsed 0 server messages
diff --git a/vest-dsl/tls/src/tls_combinators.rs b/vest-dsl/tls/src/tls_combinators.rs
index 54fca9ba..f141f5c9 100644
--- a/vest-dsl/tls/src/tls_combinators.rs
+++ b/vest-dsl/tls/src/tls_combinators.rs
@@ -35,451 +35,413 @@ macro_rules! impl_wrapper_combinator {
 }
 verus!{
 
-pub struct SpecOpaque1Ffff {
-    pub l: u16,
-    pub data: Seq<u8>,
+pub spec const SPEC_AlertLevel_Warning: u8 = 1;
+pub spec const SPEC_AlertLevel_Fatal: u8 = 2;
+pub exec static EXEC_AlertLevel_Warning: u8 ensures EXEC_AlertLevel_Warning == SPEC_AlertLevel_Warning { 1 }
+pub exec static EXEC_AlertLevel_Fatal: u8 ensures EXEC_AlertLevel_Fatal == SPEC_AlertLevel_Fatal { 2 }
+
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum AlertLevel {
+    Warning = 1,
+Fatal = 2
 }
+pub type SpecAlertLevel = AlertLevel;
 
-pub type SpecOpaque1FfffInner = (u16, Seq<u8>);
+pub type AlertLevelInner = u8;
 
+pub type AlertLevelInnerRef<'a> = &'a u8;
 
-impl SpecFrom<SpecOpaque1Ffff> for SpecOpaque1FfffInner {
-    open spec fn spec_from(m: SpecOpaque1Ffff) -> SpecOpaque1FfffInner {
-        (m.l, m.data)
-    }
-}
+impl View for AlertLevel {
+    type V = Self;
 
-impl SpecFrom<SpecOpaque1FfffInner> for SpecOpaque1Ffff {
-    open spec fn spec_from(m: SpecOpaque1FfffInner) -> SpecOpaque1Ffff {
-        let (l, data) = m;
-        SpecOpaque1Ffff { l, data }
+    open spec fn view(&self) -> Self::V {
+        *self
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Opaque1Ffff<'a> {
-    pub l: u16,
-    pub data: &'a [u8],
+impl SpecTryFrom<AlertLevelInner> for AlertLevel {
+    type Error = ();
+
+    open spec fn spec_try_from(v: AlertLevelInner) -> Result<AlertLevel, ()> {
+        match v {
+            1u8 => Ok(AlertLevel::Warning),
+            2u8 => Ok(AlertLevel::Fatal),
+            _ => Err(()),
+        }
+    }
 }
 
-impl View for Opaque1Ffff<'_> {
-    type V = SpecOpaque1Ffff;
+impl SpecTryFrom<AlertLevel> for AlertLevelInner {
+    type Error = ();
 
-    open spec fn view(&self) -> Self::V {
-        SpecOpaque1Ffff {
-            l: self.l@,
-            data: self.data@,
+    open spec fn spec_try_from(v: AlertLevel) -> Result<AlertLevelInner, ()> {
+        match v {
+            AlertLevel::Warning => Ok(SPEC_AlertLevel_Warning),
+            AlertLevel::Fatal => Ok(SPEC_AlertLevel_Fatal),
         }
     }
 }
-pub type Opaque1FfffInner<'a> = (u16, &'a [u8]);
 
-pub type Opaque1FfffInnerRef<'a> = (&'a u16, &'a &'a [u8]);
-impl<'a> From<&'a Opaque1Ffff<'a>> for Opaque1FfffInnerRef<'a> {
-    fn ex_from(m: &'a Opaque1Ffff) -> Opaque1FfffInnerRef<'a> {
-        (&m.l, &m.data)
+impl TryFrom<AlertLevelInner> for AlertLevel {
+    type Error = ();
+
+    fn ex_try_from(v: AlertLevelInner) -> Result<AlertLevel, ()> {
+        match v {
+            1u8 => Ok(AlertLevel::Warning),
+            2u8 => Ok(AlertLevel::Fatal),
+            _ => Err(()),
+        }
     }
 }
 
-impl<'a> From<Opaque1FfffInner<'a>> for Opaque1Ffff<'a> {
-    fn ex_from(m: Opaque1FfffInner) -> Opaque1Ffff {
-        let (l, data) = m;
-        Opaque1Ffff { l, data }
+impl<'a> TryFrom<&'a AlertLevel> for AlertLevelInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a AlertLevel) -> Result<AlertLevelInnerRef<'a>, ()> {
+        match v {
+            AlertLevel::Warning => Ok(&EXEC_AlertLevel_Warning),
+            AlertLevel::Fatal => Ok(&EXEC_AlertLevel_Fatal),
+        }
     }
 }
 
-pub struct Opaque1FfffMapper;
-impl View for Opaque1FfffMapper {
+pub struct AlertLevelMapper;
+
+impl View for AlertLevelMapper {
     type V = Self;
+
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for Opaque1FfffMapper {
-    type Src = SpecOpaque1FfffInner;
-    type Dst = SpecOpaque1Ffff;
+
+impl SpecPartialIso for AlertLevelMapper {
+    type Src = AlertLevelInner;
+    type Dst = AlertLevel;
 }
-impl SpecIsoProof for Opaque1FfffMapper {
+
+impl SpecPartialIsoProof for AlertLevelMapper {
     proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
     }
+
     proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
     }
 }
-impl<'a> Iso<'a> for Opaque1FfffMapper {
-    type Src = Opaque1FfffInner<'a>;
-    type Dst = Opaque1Ffff<'a>;
-    type RefSrc = Opaque1FfffInnerRef<'a>;
+
+impl<'a> PartialIso<'a> for AlertLevelMapper {
+    type Src = AlertLevelInner;
+    type Dst = AlertLevel;
+    type RefSrc = AlertLevelInnerRef<'a>;
 }
 
-pub struct SpecOpaque1FfffCombinator(pub SpecOpaque1FfffCombinatorAlias);
 
-impl SpecCombinator for SpecOpaque1FfffCombinator {
-    type Type = SpecOpaque1Ffff;
+pub struct SpecAlertLevelCombinator(pub SpecAlertLevelCombinatorAlias);
+
+impl SpecCombinator for SpecAlertLevelCombinator {
+    type Type = SpecAlertLevel;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOpaque1FfffCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOpaque1FfffCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecAlertLevelCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecAlertLevelCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOpaque1FfffCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate17626095872143391426>, bytes::Variable>, Opaque1FfffMapper>;
-pub struct Predicate17626095872143391426;
-impl View for Predicate17626095872143391426 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u16> for Predicate17626095872143391426 {
-    fn apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 1 && i <= 65535)
-    }
-}
-impl SpecPred<u16> for Predicate17626095872143391426 {
-    open spec fn spec_apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 1 && i <= 65535)
-    }
-}
+pub type SpecAlertLevelCombinatorAlias = TryMap<U8, AlertLevelMapper>;
 
-pub struct Opaque1FfffCombinator(pub Opaque1FfffCombinatorAlias);
+pub struct AlertLevelCombinator(pub AlertLevelCombinatorAlias);
 
-impl View for Opaque1FfffCombinator {
-    type V = SpecOpaque1FfffCombinator;
-    open spec fn view(&self) -> Self::V { SpecOpaque1FfffCombinator(self.0@) }
+impl View for AlertLevelCombinator {
+    type V = SpecAlertLevelCombinator;
+    open spec fn view(&self) -> Self::V { SpecAlertLevelCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque1FfffCombinator {
-    type Type = Opaque1Ffff<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AlertLevelCombinator {
+    type Type = AlertLevel;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type Opaque1FfffCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate17626095872143391426>, bytes::Variable, Opaque1FfffCont0>, Opaque1FfffMapper>;
-
-
-pub open spec fn spec_opaque_1_ffff() -> SpecOpaque1FfffCombinator {
-    SpecOpaque1FfffCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate17626095872143391426 }, |deps| spec_opaque1_ffff_cont0(deps)),
-        mapper: Opaque1FfffMapper,
-    })
-}
-
-pub open spec fn spec_opaque1_ffff_cont0(deps: u16) -> bytes::Variable {
-    let l = deps;
-    bytes::Variable(l.spec_into())
 }
+pub type AlertLevelCombinatorAlias = TryMap<U8, AlertLevelMapper>;
 
-impl View for Opaque1FfffCont0 {
-    type V = spec_fn(u16) -> bytes::Variable;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_opaque1_ffff_cont0(deps)
-        }
-    }
+pub open spec fn spec_alert_level() -> SpecAlertLevelCombinator {
+    SpecAlertLevelCombinator(TryMap { inner: U8, mapper: AlertLevelMapper })
 }
 
                 
-pub fn opaque_1_ffff<'a>() -> (o: Opaque1FfffCombinator)
-    ensures o@ == spec_opaque_1_ffff(),
+pub fn alert_level<'a>() -> (o: AlertLevelCombinator)
+    ensures o@ == spec_alert_level(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = Opaque1FfffCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate17626095872143391426 }, Opaque1FfffCont0),
-        mapper: Opaque1FfffMapper,
-    });
-    assert({
-        &&& combinator@ == spec_opaque_1_ffff()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = AlertLevelCombinator(TryMap { inner: U8, mapper: AlertLevelMapper });
+    // assert({
+    //     &&& combinator@ == spec_alert_level()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_opaque_1_ffff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque1FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_alert_level<'a>(input: &'a [u8]) -> (res: PResult<<AlertLevelCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_opaque_1_ffff().spec_parse(input@) == Some((n as int, v@)),
-        spec_opaque_1_ffff().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_alert_level().spec_parse(input@) == Some((n as int, v@)),
+        spec_alert_level().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_opaque_1_ffff().spec_parse(input@) is None,
-        spec_opaque_1_ffff().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_alert_level().spec_parse(input@) is None,
+        spec_alert_level().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = opaque_1_ffff();
+    let combinator = alert_level();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_opaque_1_ffff<'a>(v: <Opaque1FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_alert_level<'a>(v: <AlertLevelCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_opaque_1_ffff().wf(v@),
+        spec_alert_level().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_opaque_1_ffff().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_1_ffff().spec_serialize(v@))
+            &&& n == spec_alert_level().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_alert_level().spec_serialize(v@))
         },
 {
-    let combinator = opaque_1_ffff();
+    let combinator = alert_level();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn opaque_1_ffff_len<'a>(v: <Opaque1FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn alert_level_len<'a>(v: <AlertLevelCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_opaque_1_ffff().wf(v@),
-        spec_opaque_1_ffff().spec_serialize(v@).len() <= usize::MAX,
+        spec_alert_level().wf(v@),
+        spec_alert_level().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_opaque_1_ffff().spec_serialize(v@).len(),
+        serialize_len == spec_alert_level().spec_serialize(v@).len(),
 {
-    let combinator = opaque_1_ffff();
+    let combinator = alert_level();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct Opaque1FfffCont0;
-type Opaque1FfffCont0Type<'a, 'b> = &'b u16;
-type Opaque1FfffCont0SType<'a, 'x> = &'x u16;
-type Opaque1FfffCont0Input<'a, 'b, 'x> = POrSType<Opaque1FfffCont0Type<'a, 'b>, Opaque1FfffCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<Opaque1FfffCont0Input<'a, 'b, 'x>> for Opaque1FfffCont0 {
-    type Output = bytes::Variable;
+                
+pub type SpecEmpty = Seq<u8>;
+pub type Empty<'a> = &'a [u8];
+pub type EmptyRef<'a> = &'a &'a [u8];
 
-    open spec fn requires(&self, deps: Opaque1FfffCont0Input<'a, 'b, 'x>) -> bool { true }
 
-    open spec fn ensures(&self, deps: Opaque1FfffCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_opaque1_ffff_cont0(deps@)
-    }
+pub struct SpecEmptyCombinator(pub SpecEmptyCombinatorAlias);
 
-    fn apply(&self, deps: Opaque1FfffCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                bytes::Variable(l.ex_into())
-            }
-        }
-    }
-}
-                
-pub type SpecResponderId = SpecOpaque1Ffff;
-pub type ResponderId<'a> = Opaque1Ffff<'a>;
-pub type ResponderIdRef<'a> = &'a Opaque1Ffff<'a>;
-
-
-pub struct SpecResponderIdCombinator(pub SpecResponderIdCombinatorAlias);
-
-impl SpecCombinator for SpecResponderIdCombinator {
-    type Type = SpecResponderId;
+impl SpecCombinator for SpecEmptyCombinator {
+    type Type = SpecEmpty;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecResponderIdCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecResponderIdCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecEmptyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEmptyCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecResponderIdCombinatorAlias = SpecOpaque1FfffCombinator;
+pub type SpecEmptyCombinatorAlias = bytes::Fixed<0>;
 
-pub struct ResponderIdCombinator(pub ResponderIdCombinatorAlias);
+pub struct EmptyCombinator(pub EmptyCombinatorAlias);
 
-impl View for ResponderIdCombinator {
-    type V = SpecResponderIdCombinator;
-    open spec fn view(&self) -> Self::V { SpecResponderIdCombinator(self.0@) }
+impl View for EmptyCombinator {
+    type V = SpecEmptyCombinator;
+    open spec fn view(&self) -> Self::V { SpecEmptyCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ResponderIdCombinator {
-    type Type = ResponderId<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EmptyCombinator {
+    type Type = Empty<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ResponderIdCombinatorAlias = Opaque1FfffCombinator;
+}
+pub type EmptyCombinatorAlias = bytes::Fixed<0>;
 
 
-pub open spec fn spec_responder_id() -> SpecResponderIdCombinator {
-    SpecResponderIdCombinator(spec_opaque_1_ffff())
+pub open spec fn spec_empty() -> SpecEmptyCombinator {
+    SpecEmptyCombinator(bytes::Fixed::<0>)
 }
 
                 
-pub fn responder_id<'a>() -> (o: ResponderIdCombinator)
-    ensures o@ == spec_responder_id(),
+pub fn empty<'a>() -> (o: EmptyCombinator)
+    ensures o@ == spec_empty(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ResponderIdCombinator(opaque_1_ffff());
-    assert({
-        &&& combinator@ == spec_responder_id()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = EmptyCombinator(bytes::Fixed::<0>);
+    // assert({
+    //     &&& combinator@ == spec_empty()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_responder_id<'a>(input: &'a [u8]) -> (res: PResult<<ResponderIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_empty<'a>(input: &'a [u8]) -> (res: PResult<<EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_responder_id().spec_parse(input@) == Some((n as int, v@)),
-        spec_responder_id().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_empty().spec_parse(input@) == Some((n as int, v@)),
+        spec_empty().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_responder_id().spec_parse(input@) is None,
-        spec_responder_id().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_empty().spec_parse(input@) is None,
+        spec_empty().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = responder_id();
+    let combinator = empty();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_responder_id<'a>(v: <ResponderIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_empty<'a>(v: <EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_responder_id().wf(v@),
+        spec_empty().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& 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@))
+            &&& n == spec_empty().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_empty().spec_serialize(v@))
         },
 {
-    let combinator = responder_id();
+    let combinator = empty();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn responder_id_len<'a>(v: <ResponderIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn empty_len<'a>(v: <EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_responder_id().wf(v@),
-        spec_responder_id().spec_serialize(v@).len() <= usize::MAX,
+        spec_empty().wf(v@),
+        spec_empty().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_responder_id().spec_serialize(v@).len(),
+        serialize_len == spec_empty().spec_serialize(v@).len(),
 {
-    let combinator = responder_id();
+    let combinator = empty();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecResponderIdList {
+pub struct SpecOpaque0Ffff {
     pub l: u16,
-    pub list: Seq<SpecResponderId>,
+    pub data: Seq<u8>,
 }
 
-pub type SpecResponderIdListInner = (u16, Seq<SpecResponderId>);
+pub type SpecOpaque0FfffInner = (u16, Seq<u8>);
 
 
-impl SpecFrom<SpecResponderIdList> for SpecResponderIdListInner {
-    open spec fn spec_from(m: SpecResponderIdList) -> SpecResponderIdListInner {
-        (m.l, m.list)
+impl SpecFrom<SpecOpaque0Ffff> for SpecOpaque0FfffInner {
+    open spec fn spec_from(m: SpecOpaque0Ffff) -> SpecOpaque0FfffInner {
+        (m.l, m.data)
     }
 }
 
-impl SpecFrom<SpecResponderIdListInner> for SpecResponderIdList {
-    open spec fn spec_from(m: SpecResponderIdListInner) -> SpecResponderIdList {
-        let (l, list) = m;
-        SpecResponderIdList { l, list }
+impl SpecFrom<SpecOpaque0FfffInner> for SpecOpaque0Ffff {
+    open spec fn spec_from(m: SpecOpaque0FfffInner) -> SpecOpaque0Ffff {
+        let (l, data) = m;
+        SpecOpaque0Ffff { l, data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ResponderIdList<'a> {
+pub struct Opaque0Ffff<'a> {
     pub l: u16,
-    pub list: RepeatResult<ResponderId<'a>>,
+    pub data: &'a [u8],
 }
 
-impl View for ResponderIdList<'_> {
-    type V = SpecResponderIdList;
+impl View for Opaque0Ffff<'_> {
+    type V = SpecOpaque0Ffff;
 
     open spec fn view(&self) -> Self::V {
-        SpecResponderIdList {
+        SpecOpaque0Ffff {
             l: self.l@,
-            list: self.list@,
+            data: self.data@,
         }
     }
 }
-pub type ResponderIdListInner<'a> = (u16, RepeatResult<ResponderId<'a>>);
+pub type Opaque0FfffInner<'a> = (u16, &'a [u8]);
 
-pub type ResponderIdListInnerRef<'a> = (&'a u16, &'a RepeatResult<ResponderId<'a>>);
-impl<'a> From<&'a ResponderIdList<'a>> for ResponderIdListInnerRef<'a> {
-    fn ex_from(m: &'a ResponderIdList) -> ResponderIdListInnerRef<'a> {
-        (&m.l, &m.list)
+pub type Opaque0FfffInnerRef<'a> = (&'a u16, &'a &'a [u8]);
+impl<'a> From<&'a Opaque0Ffff<'a>> for Opaque0FfffInnerRef<'a> {
+    fn ex_from(m: &'a Opaque0Ffff) -> Opaque0FfffInnerRef<'a> {
+        (&m.l, &m.data)
     }
 }
 
-impl<'a> From<ResponderIdListInner<'a>> for ResponderIdList<'a> {
-    fn ex_from(m: ResponderIdListInner) -> ResponderIdList {
-        let (l, list) = m;
-        ResponderIdList { l, list }
+impl<'a> From<Opaque0FfffInner<'a>> for Opaque0Ffff<'a> {
+    fn ex_from(m: Opaque0FfffInner) -> Opaque0Ffff {
+        let (l, data) = m;
+        Opaque0Ffff { l, data }
     }
 }
 
-pub struct ResponderIdListMapper;
-impl View for ResponderIdListMapper {
+pub struct Opaque0FfffMapper;
+impl View for Opaque0FfffMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ResponderIdListMapper {
-    type Src = SpecResponderIdListInner;
-    type Dst = SpecResponderIdList;
+impl SpecIso for Opaque0FfffMapper {
+    type Src = SpecOpaque0FfffInner;
+    type Dst = SpecOpaque0Ffff;
 }
-impl SpecIsoProof for ResponderIdListMapper {
+impl SpecIsoProof for Opaque0FfffMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -487,420 +449,182 @@ impl SpecIsoProof for ResponderIdListMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ResponderIdListMapper {
-    type Src = ResponderIdListInner<'a>;
-    type Dst = ResponderIdList<'a>;
-    type RefSrc = ResponderIdListInnerRef<'a>;
+impl<'a> Iso<'a> for Opaque0FfffMapper {
+    type Src = Opaque0FfffInner<'a>;
+    type Dst = Opaque0Ffff<'a>;
+    type RefSrc = Opaque0FfffInnerRef<'a>;
 }
 
-pub struct SpecResponderIdListCombinator(pub SpecResponderIdListCombinatorAlias);
+pub struct SpecOpaque0FfffCombinator(pub SpecOpaque0FfffCombinatorAlias);
 
-impl SpecCombinator for SpecResponderIdListCombinator {
-    type Type = SpecResponderIdList;
+impl SpecCombinator for SpecOpaque0FfffCombinator {
+    type Type = SpecOpaque0Ffff;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecResponderIdListCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecResponderIdListCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOpaque0FfffCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOpaque0FfffCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecResponderIdListCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecResponderIdCombinator>>>, ResponderIdListMapper>;
+pub type SpecOpaque0FfffCombinatorAlias = Mapped<SpecPair<U16Be, bytes::Variable>, Opaque0FfffMapper>;
 
-pub struct ResponderIdListCombinator(pub ResponderIdListCombinatorAlias);
+pub struct Opaque0FfffCombinator(pub Opaque0FfffCombinatorAlias);
 
-impl View for ResponderIdListCombinator {
-    type V = SpecResponderIdListCombinator;
-    open spec fn view(&self) -> Self::V { SpecResponderIdListCombinator(self.0@) }
+impl View for Opaque0FfffCombinator {
+    type V = SpecOpaque0FfffCombinator;
+    open spec fn view(&self) -> Self::V { SpecOpaque0FfffCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ResponderIdListCombinator {
-    type Type = ResponderIdList<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque0FfffCombinator {
+    type Type = Opaque0Ffff<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ResponderIdListCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<ResponderIdCombinator>>, ResponderIdListCont0>, ResponderIdListMapper>;
+}
+pub type Opaque0FfffCombinatorAlias = Mapped<Pair<U16Be, bytes::Variable, Opaque0FfffCont0>, Opaque0FfffMapper>;
 
 
-pub open spec fn spec_responder_id_list() -> SpecResponderIdListCombinator {
-    SpecResponderIdListCombinator(
+pub open spec fn spec_opaque_0_ffff() -> SpecOpaque0FfffCombinator {
+    SpecOpaque0FfffCombinator(
     Mapped {
-        inner: Pair::spec_new(U16Be, |deps| spec_responder_id_list_cont0(deps)),
-        mapper: ResponderIdListMapper,
+        inner: Pair::spec_new(U16Be, |deps| spec_opaque0_ffff_cont0(deps)),
+        mapper: Opaque0FfffMapper,
     })
 }
 
-pub open spec fn spec_responder_id_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecResponderIdCombinator>> {
+pub open spec fn spec_opaque0_ffff_cont0(deps: u16) -> bytes::Variable {
     let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_responder_id()))
+    bytes::Variable((usize::spec_from(l)) as usize)
 }
 
-impl View for ResponderIdListCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecResponderIdCombinator>>;
+impl View for Opaque0FfffCont0 {
+    type V = spec_fn(u16) -> bytes::Variable;
 
     open spec fn view(&self) -> Self::V {
         |deps: u16| {
-            spec_responder_id_list_cont0(deps)
+            spec_opaque0_ffff_cont0(deps)
         }
     }
 }
 
                 
-pub fn responder_id_list<'a>() -> (o: ResponderIdListCombinator)
-    ensures o@ == spec_responder_id_list(),
+pub fn opaque_0_ffff<'a>() -> (o: Opaque0FfffCombinator)
+    ensures o@ == spec_opaque_0_ffff(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ResponderIdListCombinator(
+    let combinator = Opaque0FfffCombinator(
     Mapped {
-        inner: Pair::new(U16Be, ResponderIdListCont0),
-        mapper: ResponderIdListMapper,
-    });
-    assert({
-        &&& combinator@ == spec_responder_id_list()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(U16Be, Opaque0FfffCont0),
+        mapper: Opaque0FfffMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_opaque_0_ffff()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_responder_id_list<'a>(input: &'a [u8]) -> (res: PResult<<ResponderIdListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_opaque_0_ffff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque0FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_responder_id_list().spec_parse(input@) == Some((n as int, v@)),
-        spec_responder_id_list().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_opaque_0_ffff().spec_parse(input@) == Some((n as int, v@)),
+        spec_opaque_0_ffff().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_responder_id_list().spec_parse(input@) is None,
-        spec_responder_id_list().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_opaque_0_ffff().spec_parse(input@) is None,
+        spec_opaque_0_ffff().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = responder_id_list();
+    let combinator = opaque_0_ffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_responder_id_list<'a>(v: <ResponderIdListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_opaque_0_ffff<'a>(v: <Opaque0FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_responder_id_list().wf(v@),
+        spec_opaque_0_ffff().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& 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@))
+            &&& n == spec_opaque_0_ffff().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_0_ffff().spec_serialize(v@))
         },
 {
-    let combinator = responder_id_list();
+    let combinator = opaque_0_ffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn responder_id_list_len<'a>(v: <ResponderIdListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn opaque_0_ffff_len<'a>(v: <Opaque0FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_responder_id_list().wf(v@),
-        spec_responder_id_list().spec_serialize(v@).len() <= usize::MAX,
+        spec_opaque_0_ffff().wf(v@),
+        spec_opaque_0_ffff().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_responder_id_list().spec_serialize(v@).len(),
+        serialize_len == spec_opaque_0_ffff().spec_serialize(v@).len(),
 {
-    let combinator = responder_id_list();
+    let combinator = opaque_0_ffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ResponderIdListCont0;
-type ResponderIdListCont0Type<'a, 'b> = &'b u16;
-type ResponderIdListCont0SType<'a, 'x> = &'x u16;
-type ResponderIdListCont0Input<'a, 'b, 'x> = POrSType<ResponderIdListCont0Type<'a, 'b>, ResponderIdListCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ResponderIdListCont0Input<'a, 'b, 'x>> for ResponderIdListCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<ResponderIdCombinator>>;
+pub struct Opaque0FfffCont0;
+type Opaque0FfffCont0Type<'a, 'b> = &'b u16;
+type Opaque0FfffCont0SType<'a, 'x> = &'x u16;
+type Opaque0FfffCont0Input<'a, 'b, 'x> = POrSType<Opaque0FfffCont0Type<'a, 'b>, Opaque0FfffCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Opaque0FfffCont0Input<'a, 'b, 'x>> for Opaque0FfffCont0 {
+    type Output = bytes::Variable;
 
-    open spec fn requires(&self, deps: ResponderIdListCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: Opaque0FfffCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U16Be).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: ResponderIdListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_responder_id_list_cont0(deps@)
+    open spec fn ensures(&self, deps: Opaque0FfffCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_opaque0_ffff_cont0(deps@)
     }
 
-    fn apply(&self, deps: ResponderIdListCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: Opaque0FfffCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(responder_id()))
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(responder_id()))
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
-
-pub struct SpecOpaque0Ffff {
-    pub l: u16,
-    pub data: Seq<u8>,
-}
-
-pub type SpecOpaque0FfffInner = (u16, Seq<u8>);
-
-
-impl SpecFrom<SpecOpaque0Ffff> for SpecOpaque0FfffInner {
-    open spec fn spec_from(m: SpecOpaque0Ffff) -> SpecOpaque0FfffInner {
-        (m.l, m.data)
-    }
-}
-
-impl SpecFrom<SpecOpaque0FfffInner> for SpecOpaque0Ffff {
-    open spec fn spec_from(m: SpecOpaque0FfffInner) -> SpecOpaque0Ffff {
-        let (l, data) = m;
-        SpecOpaque0Ffff { l, data }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct Opaque0Ffff<'a> {
-    pub l: u16,
-    pub data: &'a [u8],
-}
-
-impl View for Opaque0Ffff<'_> {
-    type V = SpecOpaque0Ffff;
-
-    open spec fn view(&self) -> Self::V {
-        SpecOpaque0Ffff {
-            l: self.l@,
-            data: self.data@,
-        }
-    }
-}
-pub type Opaque0FfffInner<'a> = (u16, &'a [u8]);
-
-pub type Opaque0FfffInnerRef<'a> = (&'a u16, &'a &'a [u8]);
-impl<'a> From<&'a Opaque0Ffff<'a>> for Opaque0FfffInnerRef<'a> {
-    fn ex_from(m: &'a Opaque0Ffff) -> Opaque0FfffInnerRef<'a> {
-        (&m.l, &m.data)
-    }
-}
-
-impl<'a> From<Opaque0FfffInner<'a>> for Opaque0Ffff<'a> {
-    fn ex_from(m: Opaque0FfffInner) -> Opaque0Ffff {
-        let (l, data) = m;
-        Opaque0Ffff { l, data }
-    }
-}
-
-pub struct Opaque0FfffMapper;
-impl View for Opaque0FfffMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for Opaque0FfffMapper {
-    type Src = SpecOpaque0FfffInner;
-    type Dst = SpecOpaque0Ffff;
-}
-impl SpecIsoProof for Opaque0FfffMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for Opaque0FfffMapper {
-    type Src = Opaque0FfffInner<'a>;
-    type Dst = Opaque0Ffff<'a>;
-    type RefSrc = Opaque0FfffInnerRef<'a>;
-}
-
-pub struct SpecOpaque0FfffCombinator(pub SpecOpaque0FfffCombinatorAlias);
-
-impl SpecCombinator for SpecOpaque0FfffCombinator {
-    type Type = SpecOpaque0Ffff;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecOpaque0FfffCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOpaque0FfffCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
-}
-pub type SpecOpaque0FfffCombinatorAlias = Mapped<SpecPair<U16Be, bytes::Variable>, Opaque0FfffMapper>;
-
-pub struct Opaque0FfffCombinator(pub Opaque0FfffCombinatorAlias);
-
-impl View for Opaque0FfffCombinator {
-    type V = SpecOpaque0FfffCombinator;
-    open spec fn view(&self) -> Self::V { SpecOpaque0FfffCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque0FfffCombinator {
-    type Type = Opaque0Ffff<'a>;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type Opaque0FfffCombinatorAlias = Mapped<Pair<U16Be, bytes::Variable, Opaque0FfffCont0>, Opaque0FfffMapper>;
-
-
-pub open spec fn spec_opaque_0_ffff() -> SpecOpaque0FfffCombinator {
-    SpecOpaque0FfffCombinator(
-    Mapped {
-        inner: Pair::spec_new(U16Be, |deps| spec_opaque0_ffff_cont0(deps)),
-        mapper: Opaque0FfffMapper,
-    })
-}
-
-pub open spec fn spec_opaque0_ffff_cont0(deps: u16) -> bytes::Variable {
-    let l = deps;
-    bytes::Variable(l.spec_into())
-}
-
-impl View for Opaque0FfffCont0 {
-    type V = spec_fn(u16) -> bytes::Variable;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_opaque0_ffff_cont0(deps)
-        }
-    }
-}
-
-                
-pub fn opaque_0_ffff<'a>() -> (o: Opaque0FfffCombinator)
-    ensures o@ == spec_opaque_0_ffff(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = Opaque0FfffCombinator(
-    Mapped {
-        inner: Pair::new(U16Be, Opaque0FfffCont0),
-        mapper: Opaque0FfffMapper,
-    });
-    assert({
-        &&& combinator@ == spec_opaque_0_ffff()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
-
-pub fn parse_opaque_0_ffff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque0FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_opaque_0_ffff().spec_parse(input@) == Some((n as int, v@)),
-        spec_opaque_0_ffff().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_opaque_0_ffff().spec_parse(input@) is None,
-        spec_opaque_0_ffff().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = opaque_0_ffff();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
-}
-
-pub fn serialize_opaque_0_ffff<'a>(v: <Opaque0FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_opaque_0_ffff().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_opaque_0_ffff().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_0_ffff().spec_serialize(v@))
-        },
-{
-    let combinator = opaque_0_ffff();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
-}
-
-pub fn opaque_0_ffff_len<'a>(v: <Opaque0FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_opaque_0_ffff().wf(v@),
-        spec_opaque_0_ffff().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_opaque_0_ffff().spec_serialize(v@).len(),
-{
-    let combinator = opaque_0_ffff();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
-}
-
-pub struct Opaque0FfffCont0;
-type Opaque0FfffCont0Type<'a, 'b> = &'b u16;
-type Opaque0FfffCont0SType<'a, 'x> = &'x u16;
-type Opaque0FfffCont0Input<'a, 'b, 'x> = POrSType<Opaque0FfffCont0Type<'a, 'b>, Opaque0FfffCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<Opaque0FfffCont0Input<'a, 'b, 'x>> for Opaque0FfffCont0 {
-    type Output = bytes::Variable;
-
-    open spec fn requires(&self, deps: Opaque0FfffCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: Opaque0FfffCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_opaque0_ffff_cont0(deps@)
-    }
-
-    fn apply(&self, deps: Opaque0FfffCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                bytes::Variable(l.ex_into())
-            }
-        }
-    }
-}
-                
-pub type SpecOcspExtensions = SpecOpaque0Ffff;
-pub type OcspExtensions<'a> = Opaque0Ffff<'a>;
-pub type OcspExtensionsRef<'a> = &'a Opaque0Ffff<'a>;
+pub type SpecOcspExtensions = SpecOpaque0Ffff;
+pub type OcspExtensions<'a> = Opaque0Ffff<'a>;
+pub type OcspExtensionsRef<'a> = &'a Opaque0Ffff<'a>;
 
 
 pub struct SpecOcspExtensionsCombinator(pub SpecOcspExtensionsCombinatorAlias);
@@ -911,13 +635,13 @@ impl SpecCombinator for SpecOcspExtensionsCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecOcspExtensionsCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecOcspExtensionsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -925,11 +649,11 @@ impl SecureSpecCombinator for SpecOcspExtensionsCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecOcspExtensionsCombinatorAlias = SpecOpaque0FfffCombinator;
@@ -945,13 +669,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OcspExtensionsCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type OcspExtensionsCombinatorAlias = Opaque0FfffCombinator;
 
 
@@ -966,11 +690,11 @@ pub fn ocsp_extensions<'a>() -> (o: OcspExtensionsCombinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = OcspExtensionsCombinator(opaque_0_ffff());
-    assert({
-        &&& combinator@ == spec_ocsp_extensions()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_ocsp_extensions()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -1016,642 +740,664 @@ pub fn ocsp_extensions_len<'a>(v: <OcspExtensionsCombinator as Combinator<'a, &'
 }
 
                 
-
-pub struct SpecOscpStatusRequest {
-    pub responder_id_list: SpecResponderIdList,
-    pub extensions: SpecOcspExtensions,
-}
-
-pub type SpecOscpStatusRequestInner = (SpecResponderIdList, SpecOcspExtensions);
-
-
-impl SpecFrom<SpecOscpStatusRequest> for SpecOscpStatusRequestInner {
-    open spec fn spec_from(m: SpecOscpStatusRequest) -> SpecOscpStatusRequestInner {
-        (m.responder_id_list, m.extensions)
-    }
-}
-
-impl SpecFrom<SpecOscpStatusRequestInner> for SpecOscpStatusRequest {
-    open spec fn spec_from(m: SpecOscpStatusRequestInner) -> SpecOscpStatusRequest {
-        let (responder_id_list, extensions) = m;
-        SpecOscpStatusRequest { responder_id_list, extensions }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct OscpStatusRequest<'a> {
-    pub responder_id_list: ResponderIdList<'a>,
-    pub extensions: OcspExtensions<'a>,
-}
-
-impl View for OscpStatusRequest<'_> {
-    type V = SpecOscpStatusRequest;
-
-    open spec fn view(&self) -> Self::V {
-        SpecOscpStatusRequest {
-            responder_id_list: self.responder_id_list@,
-            extensions: self.extensions@,
-        }
-    }
-}
-pub type OscpStatusRequestInner<'a> = (ResponderIdList<'a>, OcspExtensions<'a>);
-
-pub type OscpStatusRequestInnerRef<'a> = (&'a ResponderIdList<'a>, &'a OcspExtensions<'a>);
-impl<'a> From<&'a OscpStatusRequest<'a>> for OscpStatusRequestInnerRef<'a> {
-    fn ex_from(m: &'a OscpStatusRequest) -> OscpStatusRequestInnerRef<'a> {
-        (&m.responder_id_list, &m.extensions)
-    }
+pub mod ExtensionType {
+    use super::*;
+    pub spec const SPEC_ServerName: u16 = 0;
+    pub spec const SPEC_MaxFragmentLength: u16 = 1;
+    pub spec const SPEC_StatusRequest: u16 = 5;
+    pub spec const SPEC_SupportedGroups: u16 = 10;
+    pub spec const SPEC_ECPointFormats: u16 = 11;
+    pub spec const SPEC_SignatureAlgorithms: u16 = 13;
+    pub spec const SPEC_UseSRTP: u16 = 14;
+    pub spec const SPEC_Heartbeat: u16 = 15;
+    pub spec const SPEC_ApplicationLayerProtocolNegotiation: u16 = 16;
+    pub spec const SPEC_SignedCertificateTimeStamp: u16 = 18;
+    pub spec const SPEC_ClientCertificateType: u16 = 19;
+    pub spec const SPEC_ServerCertificateType: u16 = 20;
+    pub spec const SPEC_Padding: u16 = 21;
+    pub spec const SPEC_EncryptThenMac: u16 = 22;
+    pub spec const SPEC_ExtendedMasterSecret: u16 = 23;
+    pub spec const SPEC_SessionTicket: u16 = 35;
+    pub spec const SPEC_PreSharedKey: u16 = 41;
+    pub spec const SPEC_EarlyData: u16 = 42;
+    pub spec const SPEC_SupportedVersions: u16 = 43;
+    pub spec const SPEC_Cookie: u16 = 44;
+    pub spec const SPEC_PskKeyExchangeModes: u16 = 45;
+    pub spec const SPEC_CertificateAuthorities: u16 = 47;
+    pub spec const SPEC_OidFilters: u16 = 48;
+    pub spec const SPEC_PostHandshakeAuth: u16 = 49;
+    pub spec const SPEC_SignatureAlgorithmsCert: u16 = 50;
+    pub spec const SPEC_KeyShare: u16 = 51;
+    pub spec const SPEC_Dummy: u16 = 65535;
+    pub exec const ServerName: u16 ensures ServerName == SPEC_ServerName { 0 }
+    pub exec const MaxFragmentLength: u16 ensures MaxFragmentLength == SPEC_MaxFragmentLength { 1 }
+    pub exec const StatusRequest: u16 ensures StatusRequest == SPEC_StatusRequest { 5 }
+    pub exec const SupportedGroups: u16 ensures SupportedGroups == SPEC_SupportedGroups { 10 }
+    pub exec const ECPointFormats: u16 ensures ECPointFormats == SPEC_ECPointFormats { 11 }
+    pub exec const SignatureAlgorithms: u16 ensures SignatureAlgorithms == SPEC_SignatureAlgorithms { 13 }
+    pub exec const UseSRTP: u16 ensures UseSRTP == SPEC_UseSRTP { 14 }
+    pub exec const Heartbeat: u16 ensures Heartbeat == SPEC_Heartbeat { 15 }
+    pub exec const ApplicationLayerProtocolNegotiation: u16 ensures ApplicationLayerProtocolNegotiation == SPEC_ApplicationLayerProtocolNegotiation { 16 }
+    pub exec const SignedCertificateTimeStamp: u16 ensures SignedCertificateTimeStamp == SPEC_SignedCertificateTimeStamp { 18 }
+    pub exec const ClientCertificateType: u16 ensures ClientCertificateType == SPEC_ClientCertificateType { 19 }
+    pub exec const ServerCertificateType: u16 ensures ServerCertificateType == SPEC_ServerCertificateType { 20 }
+    pub exec const Padding: u16 ensures Padding == SPEC_Padding { 21 }
+    pub exec const EncryptThenMac: u16 ensures EncryptThenMac == SPEC_EncryptThenMac { 22 }
+    pub exec const ExtendedMasterSecret: u16 ensures ExtendedMasterSecret == SPEC_ExtendedMasterSecret { 23 }
+    pub exec const SessionTicket: u16 ensures SessionTicket == SPEC_SessionTicket { 35 }
+    pub exec const PreSharedKey: u16 ensures PreSharedKey == SPEC_PreSharedKey { 41 }
+    pub exec const EarlyData: u16 ensures EarlyData == SPEC_EarlyData { 42 }
+    pub exec const SupportedVersions: u16 ensures SupportedVersions == SPEC_SupportedVersions { 43 }
+    pub exec const Cookie: u16 ensures Cookie == SPEC_Cookie { 44 }
+    pub exec const PskKeyExchangeModes: u16 ensures PskKeyExchangeModes == SPEC_PskKeyExchangeModes { 45 }
+    pub exec const CertificateAuthorities: u16 ensures CertificateAuthorities == SPEC_CertificateAuthorities { 47 }
+    pub exec const OidFilters: u16 ensures OidFilters == SPEC_OidFilters { 48 }
+    pub exec const PostHandshakeAuth: u16 ensures PostHandshakeAuth == SPEC_PostHandshakeAuth { 49 }
+    pub exec const SignatureAlgorithmsCert: u16 ensures SignatureAlgorithmsCert == SPEC_SignatureAlgorithmsCert { 50 }
+    pub exec const KeyShare: u16 ensures KeyShare == SPEC_KeyShare { 51 }
+    pub exec const Dummy: u16 ensures Dummy == SPEC_Dummy { 65535 }
 }
 
-impl<'a> From<OscpStatusRequestInner<'a>> for OscpStatusRequest<'a> {
-    fn ex_from(m: OscpStatusRequestInner) -> OscpStatusRequest {
-        let (responder_id_list, extensions) = m;
-        OscpStatusRequest { responder_id_list, extensions }
-    }
-}
 
-pub struct OscpStatusRequestMapper;
-impl View for OscpStatusRequestMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for OscpStatusRequestMapper {
-    type Src = SpecOscpStatusRequestInner;
-    type Dst = SpecOscpStatusRequest;
-}
-impl SpecIsoProof for OscpStatusRequestMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for OscpStatusRequestMapper {
-    type Src = OscpStatusRequestInner<'a>;
-    type Dst = OscpStatusRequest<'a>;
-    type RefSrc = OscpStatusRequestInnerRef<'a>;
-}
-type SpecOscpStatusRequestCombinatorAlias1 = (SpecResponderIdListCombinator, SpecOcspExtensionsCombinator);
-pub struct SpecOscpStatusRequestCombinator(pub SpecOscpStatusRequestCombinatorAlias);
+pub struct SpecExtensionTypeCombinator(pub SpecExtensionTypeCombinatorAlias);
 
-impl SpecCombinator for SpecOscpStatusRequestCombinator {
-    type Type = SpecOscpStatusRequest;
+impl SpecCombinator for SpecExtensionTypeCombinator {
+    type Type = u16;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOscpStatusRequestCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOscpStatusRequestCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecExtensionTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecExtensionTypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOscpStatusRequestCombinatorAlias = Mapped<SpecOscpStatusRequestCombinatorAlias1, OscpStatusRequestMapper>;
-type OscpStatusRequestCombinatorAlias1 = (ResponderIdListCombinator, OcspExtensionsCombinator);
-pub struct OscpStatusRequestCombinator1(pub OscpStatusRequestCombinatorAlias1);
-impl View for OscpStatusRequestCombinator1 {
-    type V = SpecOscpStatusRequestCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(OscpStatusRequestCombinator1, OscpStatusRequestCombinatorAlias1);
+pub type SpecExtensionTypeCombinatorAlias = U16Be;
 
-pub struct OscpStatusRequestCombinator(pub OscpStatusRequestCombinatorAlias);
+pub struct ExtensionTypeCombinator(pub ExtensionTypeCombinatorAlias);
 
-impl View for OscpStatusRequestCombinator {
-    type V = SpecOscpStatusRequestCombinator;
-    open spec fn view(&self) -> Self::V { SpecOscpStatusRequestCombinator(self.0@) }
+impl View for ExtensionTypeCombinator {
+    type V = SpecExtensionTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecExtensionTypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OscpStatusRequestCombinator {
-    type Type = OscpStatusRequest<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExtensionTypeCombinator {
+    type Type = u16;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type OscpStatusRequestCombinatorAlias = Mapped<OscpStatusRequestCombinator1, OscpStatusRequestMapper>;
+}
+pub type ExtensionTypeCombinatorAlias = U16Be;
 
 
-pub open spec fn spec_oscp_status_request() -> SpecOscpStatusRequestCombinator {
-    SpecOscpStatusRequestCombinator(
-    Mapped {
-        inner: (spec_responder_id_list(), spec_ocsp_extensions()),
-        mapper: OscpStatusRequestMapper,
-    })
+pub open spec fn spec_extension_type() -> SpecExtensionTypeCombinator {
+    SpecExtensionTypeCombinator(U16Be)
 }
 
                 
-pub fn oscp_status_request<'a>() -> (o: OscpStatusRequestCombinator)
-    ensures o@ == spec_oscp_status_request(),
+pub fn extension_type<'a>() -> (o: ExtensionTypeCombinator)
+    ensures o@ == spec_extension_type(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = OscpStatusRequestCombinator(
-    Mapped {
-        inner: OscpStatusRequestCombinator1((responder_id_list(), ocsp_extensions())),
-        mapper: OscpStatusRequestMapper,
-    });
-    assert({
-        &&& combinator@ == spec_oscp_status_request()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ExtensionTypeCombinator(U16Be);
+    // assert({
+    //     &&& combinator@ == spec_extension_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_oscp_status_request<'a>(input: &'a [u8]) -> (res: PResult<<OscpStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_extension_type<'a>(input: &'a [u8]) -> (res: PResult<<ExtensionTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_oscp_status_request().spec_parse(input@) == Some((n as int, v@)),
-        spec_oscp_status_request().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_extension_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_extension_type().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_oscp_status_request().spec_parse(input@) is None,
-        spec_oscp_status_request().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_extension_type().spec_parse(input@) is None,
+        spec_extension_type().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = oscp_status_request();
+    let combinator = extension_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_oscp_status_request<'a>(v: <OscpStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_extension_type<'a>(v: <ExtensionTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_oscp_status_request().wf(v@),
+        spec_extension_type().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_oscp_status_request().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_oscp_status_request().spec_serialize(v@))
+            &&& n == spec_extension_type().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_extension_type().spec_serialize(v@))
         },
 {
-    let combinator = oscp_status_request();
+    let combinator = extension_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn oscp_status_request_len<'a>(v: <OscpStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn extension_type_len<'a>(v: <ExtensionTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_oscp_status_request().wf(v@),
-        spec_oscp_status_request().spec_serialize(v@).len() <= usize::MAX,
+        spec_extension_type().wf(v@),
+        spec_extension_type().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_oscp_status_request().spec_serialize(v@).len(),
+        serialize_len == spec_extension_type().spec_serialize(v@).len(),
 {
-    let combinator = oscp_status_request();
+    let combinator = extension_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub mod NameType {
+pub mod SignatureScheme {
     use super::*;
-    pub spec const SPEC_HostName: u8 = 0;
-    pub exec const HostName: u8 ensures HostName == SPEC_HostName { 0 }
+    pub spec const SPEC_RSA_PKCS1_MD5: u16 = 257;
+    pub spec const SPEC_RSA_PKCS1_SHA1: u16 = 513;
+    pub spec const SPEC_ECDSA_MD5: u16 = 259;
+    pub spec const SPEC_ECDSA_SHA1: u16 = 515;
+    pub spec const SPEC_RSA_PKCS1_SHA256: u16 = 1025;
+    pub spec const SPEC_RSA_PKCS1_SHA384: u16 = 1281;
+    pub spec const SPEC_RSA_PKCS1_SHA512: u16 = 1537;
+    pub spec const SPEC_ECDSA_SECP256R1_SHA256: u16 = 1027;
+    pub spec const SPEC_ECDSA_SECP384R1_SHA384: u16 = 1283;
+    pub spec const SPEC_ECDSA_SECP521R1_SHA512: u16 = 1539;
+    pub spec const SPEC_RSA_PSS_RSAE_SHA256: u16 = 2052;
+    pub spec const SPEC_RSA_PSS_RSAE_SHA384: u16 = 2053;
+    pub spec const SPEC_RSA_PSS_RSAE_SHA512: u16 = 2054;
+    pub spec const SPEC_ED25519: u16 = 2055;
+    pub spec const SPEC_ED448: u16 = 2056;
+    pub spec const SPEC_RSA_PSS_PSS_SHA256: u16 = 2057;
+    pub spec const SPEC_RSA_PSS_PSS_SHA384: u16 = 2058;
+    pub spec const SPEC_RSA_PSS_PSS_SHA512: u16 = 2059;
+    pub exec const RSA_PKCS1_MD5: u16 ensures RSA_PKCS1_MD5 == SPEC_RSA_PKCS1_MD5 { 257 }
+    pub exec const RSA_PKCS1_SHA1: u16 ensures RSA_PKCS1_SHA1 == SPEC_RSA_PKCS1_SHA1 { 513 }
+    pub exec const ECDSA_MD5: u16 ensures ECDSA_MD5 == SPEC_ECDSA_MD5 { 259 }
+    pub exec const ECDSA_SHA1: u16 ensures ECDSA_SHA1 == SPEC_ECDSA_SHA1 { 515 }
+    pub exec const RSA_PKCS1_SHA256: u16 ensures RSA_PKCS1_SHA256 == SPEC_RSA_PKCS1_SHA256 { 1025 }
+    pub exec const RSA_PKCS1_SHA384: u16 ensures RSA_PKCS1_SHA384 == SPEC_RSA_PKCS1_SHA384 { 1281 }
+    pub exec const RSA_PKCS1_SHA512: u16 ensures RSA_PKCS1_SHA512 == SPEC_RSA_PKCS1_SHA512 { 1537 }
+    pub exec const ECDSA_SECP256R1_SHA256: u16 ensures ECDSA_SECP256R1_SHA256 == SPEC_ECDSA_SECP256R1_SHA256 { 1027 }
+    pub exec const ECDSA_SECP384R1_SHA384: u16 ensures ECDSA_SECP384R1_SHA384 == SPEC_ECDSA_SECP384R1_SHA384 { 1283 }
+    pub exec const ECDSA_SECP521R1_SHA512: u16 ensures ECDSA_SECP521R1_SHA512 == SPEC_ECDSA_SECP521R1_SHA512 { 1539 }
+    pub exec const RSA_PSS_RSAE_SHA256: u16 ensures RSA_PSS_RSAE_SHA256 == SPEC_RSA_PSS_RSAE_SHA256 { 2052 }
+    pub exec const RSA_PSS_RSAE_SHA384: u16 ensures RSA_PSS_RSAE_SHA384 == SPEC_RSA_PSS_RSAE_SHA384 { 2053 }
+    pub exec const RSA_PSS_RSAE_SHA512: u16 ensures RSA_PSS_RSAE_SHA512 == SPEC_RSA_PSS_RSAE_SHA512 { 2054 }
+    pub exec const ED25519: u16 ensures ED25519 == SPEC_ED25519 { 2055 }
+    pub exec const ED448: u16 ensures ED448 == SPEC_ED448 { 2056 }
+    pub exec const RSA_PSS_PSS_SHA256: u16 ensures RSA_PSS_PSS_SHA256 == SPEC_RSA_PSS_PSS_SHA256 { 2057 }
+    pub exec const RSA_PSS_PSS_SHA384: u16 ensures RSA_PSS_PSS_SHA384 == SPEC_RSA_PSS_PSS_SHA384 { 2058 }
+    pub exec const RSA_PSS_PSS_SHA512: u16 ensures RSA_PSS_PSS_SHA512 == SPEC_RSA_PSS_PSS_SHA512 { 2059 }
 }
 
 
-pub struct SpecNameTypeCombinator(pub SpecNameTypeCombinatorAlias);
+pub struct SpecSignatureSchemeCombinator(pub SpecSignatureSchemeCombinatorAlias);
 
-impl SpecCombinator for SpecNameTypeCombinator {
-    type Type = u8;
+impl SpecCombinator for SpecSignatureSchemeCombinator {
+    type Type = u16;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecNameTypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecNameTypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSignatureSchemeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSignatureSchemeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecNameTypeCombinatorAlias = U8;
+pub type SpecSignatureSchemeCombinatorAlias = U16Be;
 
-pub struct NameTypeCombinator(pub NameTypeCombinatorAlias);
+pub struct SignatureSchemeCombinator(pub SignatureSchemeCombinatorAlias);
 
-impl View for NameTypeCombinator {
-    type V = SpecNameTypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecNameTypeCombinator(self.0@) }
+impl View for SignatureSchemeCombinator {
+    type V = SpecSignatureSchemeCombinator;
+    open spec fn view(&self) -> Self::V { SpecSignatureSchemeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NameTypeCombinator {
-    type Type = u8;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SignatureSchemeCombinator {
+    type Type = u16;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type NameTypeCombinatorAlias = U8;
+}
+pub type SignatureSchemeCombinatorAlias = U16Be;
 
 
-pub open spec fn spec_name_type() -> SpecNameTypeCombinator {
-    SpecNameTypeCombinator(U8)
+pub open spec fn spec_signature_scheme() -> SpecSignatureSchemeCombinator {
+    SpecSignatureSchemeCombinator(U16Be)
 }
 
                 
-pub fn name_type<'a>() -> (o: NameTypeCombinator)
-    ensures o@ == spec_name_type(),
+pub fn signature_scheme<'a>() -> (o: SignatureSchemeCombinator)
+    ensures o@ == spec_signature_scheme(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = NameTypeCombinator(U8);
-    assert({
-        &&& combinator@ == spec_name_type()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = SignatureSchemeCombinator(U16Be);
+    // assert({
+    //     &&& combinator@ == spec_signature_scheme()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_name_type<'a>(input: &'a [u8]) -> (res: PResult<<NameTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_signature_scheme<'a>(input: &'a [u8]) -> (res: PResult<<SignatureSchemeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_name_type().spec_parse(input@) == Some((n as int, v@)),
-        spec_name_type().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_signature_scheme().spec_parse(input@) == Some((n as int, v@)),
+        spec_signature_scheme().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_name_type().spec_parse(input@) is None,
-        spec_name_type().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_signature_scheme().spec_parse(input@) is None,
+        spec_signature_scheme().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = name_type();
+    let combinator = signature_scheme();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_name_type<'a>(v: <NameTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_signature_scheme<'a>(v: <SignatureSchemeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_name_type().wf(v@),
+        spec_signature_scheme().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_name_type().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_name_type().spec_serialize(v@))
+            &&& n == spec_signature_scheme().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_signature_scheme().spec_serialize(v@))
         },
 {
-    let combinator = name_type();
+    let combinator = signature_scheme();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn name_type_len<'a>(v: <NameTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn signature_scheme_len<'a>(v: <SignatureSchemeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_name_type().wf(v@),
-        spec_name_type().spec_serialize(v@).len() <= usize::MAX,
+        spec_signature_scheme().wf(v@),
+        spec_signature_scheme().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_name_type().spec_serialize(v@).len(),
+        serialize_len == spec_signature_scheme().spec_serialize(v@).len(),
 {
-    let combinator = name_type();
+    let combinator = signature_scheme();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub mod ProtocolVersion {
-    use super::*;
-    pub spec const SPEC_SSLv3: u16 = 768;
-    pub spec const SPEC_TLSv1_0: u16 = 769;
-    pub spec const SPEC_TLSv1_1: u16 = 770;
-    pub spec const SPEC_TLSv1_2: u16 = 771;
-    pub spec const SPEC_TLSv1_3: u16 = 772;
-    pub exec const SSLv3: u16 ensures SSLv3 == SPEC_SSLv3 { 768 }
-    pub exec const TLSv1_0: u16 ensures TLSv1_0 == SPEC_TLSv1_0 { 769 }
-    pub exec const TLSv1_1: u16 ensures TLSv1_1 == SPEC_TLSv1_1 { 770 }
-    pub exec const TLSv1_2: u16 ensures TLSv1_2 == SPEC_TLSv1_2 { 771 }
-    pub exec const TLSv1_3: u16 ensures TLSv1_3 == SPEC_TLSv1_3 { 772 }
+
+pub struct SpecSignatureSchemeList {
+    pub l: u16,
+    pub list: Seq<u16>,
 }
 
+pub type SpecSignatureSchemeListInner = (u16, Seq<u16>);
 
-pub struct SpecProtocolVersionCombinator(pub SpecProtocolVersionCombinatorAlias);
 
-impl SpecCombinator for SpecProtocolVersionCombinator {
-    type Type = u16;
+impl SpecFrom<SpecSignatureSchemeList> for SpecSignatureSchemeListInner {
+    open spec fn spec_from(m: SpecSignatureSchemeList) -> SpecSignatureSchemeListInner {
+        (m.l, m.list)
+    }
+}
+
+impl SpecFrom<SpecSignatureSchemeListInner> for SpecSignatureSchemeList {
+    open spec fn spec_from(m: SpecSignatureSchemeListInner) -> SpecSignatureSchemeList {
+        let (l, list) = m;
+        SpecSignatureSchemeList { l, list }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct SignatureSchemeList {
+    pub l: u16,
+    pub list: RepeatResult<u16>,
+}
+
+impl View for SignatureSchemeList {
+    type V = SpecSignatureSchemeList;
+
+    open spec fn view(&self) -> Self::V {
+        SpecSignatureSchemeList {
+            l: self.l@,
+            list: self.list@,
+        }
+    }
+}
+pub type SignatureSchemeListInner = (u16, RepeatResult<u16>);
+
+pub type SignatureSchemeListInnerRef<'a> = (&'a u16, &'a RepeatResult<u16>);
+impl<'a> From<&'a SignatureSchemeList> for SignatureSchemeListInnerRef<'a> {
+    fn ex_from(m: &'a SignatureSchemeList) -> SignatureSchemeListInnerRef<'a> {
+        (&m.l, &m.list)
+    }
+}
+
+impl From<SignatureSchemeListInner> for SignatureSchemeList {
+    fn ex_from(m: SignatureSchemeListInner) -> SignatureSchemeList {
+        let (l, list) = m;
+        SignatureSchemeList { l, list }
+    }
+}
+
+pub struct SignatureSchemeListMapper;
+impl View for SignatureSchemeListMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for SignatureSchemeListMapper {
+    type Src = SpecSignatureSchemeListInner;
+    type Dst = SpecSignatureSchemeList;
+}
+impl SpecIsoProof for SignatureSchemeListMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for SignatureSchemeListMapper {
+    type Src = SignatureSchemeListInner;
+    type Dst = SignatureSchemeList;
+    type RefSrc = SignatureSchemeListInnerRef<'a>;
+}
+
+pub struct SpecSignatureSchemeListCombinator(pub SpecSignatureSchemeListCombinatorAlias);
+
+impl SpecCombinator for SpecSignatureSchemeListCombinator {
+    type Type = SpecSignatureSchemeList;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecProtocolVersionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecProtocolVersionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSignatureSchemeListCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSignatureSchemeListCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecProtocolVersionCombinatorAlias = U16Be;
+pub type SpecSignatureSchemeListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate15206902916018849611>, AndThen<bytes::Variable, Repeat<SpecSignatureSchemeCombinator>>>, SignatureSchemeListMapper>;
+pub struct Predicate15206902916018849611;
+impl View for Predicate15206902916018849611 {
+    type V = Self;
 
-pub struct ProtocolVersionCombinator(pub ProtocolVersionCombinatorAlias);
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate15206902916018849611 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 2 && i <= 65534)
+    }
+}
+impl SpecPred<u16> for Predicate15206902916018849611 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 2 && i <= 65534)
+    }
+}
 
-impl View for ProtocolVersionCombinator {
-    type V = SpecProtocolVersionCombinator;
-    open spec fn view(&self) -> Self::V { SpecProtocolVersionCombinator(self.0@) }
+pub struct SignatureSchemeListCombinator(pub SignatureSchemeListCombinatorAlias);
+
+impl View for SignatureSchemeListCombinator {
+    type V = SpecSignatureSchemeListCombinator;
+    open spec fn view(&self) -> Self::V { SpecSignatureSchemeListCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProtocolVersionCombinator {
-    type Type = u16;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SignatureSchemeListCombinator {
+    type Type = SignatureSchemeList;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ProtocolVersionCombinatorAlias = U16Be;
+}
+pub type SignatureSchemeListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate15206902916018849611>, AndThen<bytes::Variable, Repeat<SignatureSchemeCombinator>>, SignatureSchemeListCont0>, SignatureSchemeListMapper>;
 
 
-pub open spec fn spec_protocol_version() -> SpecProtocolVersionCombinator {
-    SpecProtocolVersionCombinator(U16Be)
+pub open spec fn spec_signature_scheme_list() -> SpecSignatureSchemeListCombinator {
+    SpecSignatureSchemeListCombinator(
+    Mapped {
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate15206902916018849611 }, |deps| spec_signature_scheme_list_cont0(deps)),
+        mapper: SignatureSchemeListMapper,
+    })
+}
+
+pub open spec fn spec_signature_scheme_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecSignatureSchemeCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_signature_scheme()))
+}
+
+impl View for SignatureSchemeListCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecSignatureSchemeCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_signature_scheme_list_cont0(deps)
+        }
+    }
 }
 
                 
-pub fn protocol_version<'a>() -> (o: ProtocolVersionCombinator)
-    ensures o@ == spec_protocol_version(),
+pub fn signature_scheme_list<'a>() -> (o: SignatureSchemeListCombinator)
+    ensures o@ == spec_signature_scheme_list(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ProtocolVersionCombinator(U16Be);
-    assert({
-        &&& combinator@ == spec_protocol_version()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = SignatureSchemeListCombinator(
+    Mapped {
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate15206902916018849611 }, SignatureSchemeListCont0),
+        mapper: SignatureSchemeListMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_signature_scheme_list()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_protocol_version<'a>(input: &'a [u8]) -> (res: PResult<<ProtocolVersionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_signature_scheme_list<'a>(input: &'a [u8]) -> (res: PResult<<SignatureSchemeListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_protocol_version().spec_parse(input@) == Some((n as int, v@)),
-        spec_protocol_version().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_signature_scheme_list().spec_parse(input@) == Some((n as int, v@)),
+        spec_signature_scheme_list().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_protocol_version().spec_parse(input@) is None,
-        spec_protocol_version().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_signature_scheme_list().spec_parse(input@) is None,
+        spec_signature_scheme_list().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = protocol_version();
+    let combinator = signature_scheme_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_protocol_version<'a>(v: <ProtocolVersionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_signature_scheme_list<'a>(v: <SignatureSchemeListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_protocol_version().wf(v@),
+        spec_signature_scheme_list().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_protocol_version().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_protocol_version().spec_serialize(v@))
+            &&& n == spec_signature_scheme_list().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_signature_scheme_list().spec_serialize(v@))
         },
 {
-    let combinator = protocol_version();
+    let combinator = signature_scheme_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn protocol_version_len<'a>(v: <ProtocolVersionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn signature_scheme_list_len<'a>(v: <SignatureSchemeListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_protocol_version().wf(v@),
-        spec_protocol_version().spec_serialize(v@).len() <= usize::MAX,
+        spec_signature_scheme_list().wf(v@),
+        spec_signature_scheme_list().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_protocol_version().spec_serialize(v@).len(),
+        serialize_len == spec_signature_scheme_list().spec_serialize(v@).len(),
 {
-    let combinator = protocol_version();
+    let combinator = signature_scheme_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
+pub struct SignatureSchemeListCont0;
+type SignatureSchemeListCont0Type<'a, 'b> = &'b u16;
+type SignatureSchemeListCont0SType<'a, 'x> = &'x u16;
+type SignatureSchemeListCont0Input<'a, 'b, 'x> = POrSType<SignatureSchemeListCont0Type<'a, 'b>, SignatureSchemeListCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<SignatureSchemeListCont0Input<'a, 'b, 'x>> for SignatureSchemeListCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<SignatureSchemeCombinator>>;
 
+    open spec fn requires(&self, deps: SignatureSchemeListCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate15206902916018849611 }).wf(deps@)
+        }
 
-pub struct SpecSupportedVersionsServerCombinator(pub SpecSupportedVersionsServerCombinatorAlias);
+    open spec fn ensures(&self, deps: SignatureSchemeListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_signature_scheme_list_cont0(deps@)
+    }
 
-impl SpecCombinator for SpecSupportedVersionsServerCombinator {
-    type Type = u16;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecSupportedVersionsServerCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSupportedVersionsServerCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
-}
-pub type SpecSupportedVersionsServerCombinatorAlias = SpecProtocolVersionCombinator;
-
-pub struct SupportedVersionsServerCombinator(pub SupportedVersionsServerCombinatorAlias);
-
-impl View for SupportedVersionsServerCombinator {
-    type V = SpecSupportedVersionsServerCombinator;
-    open spec fn view(&self) -> Self::V { SpecSupportedVersionsServerCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SupportedVersionsServerCombinator {
-    type Type = u16;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SupportedVersionsServerCombinatorAlias = ProtocolVersionCombinator;
-
-
-pub open spec fn spec_supported_versions_server() -> SpecSupportedVersionsServerCombinator {
-    SpecSupportedVersionsServerCombinator(spec_protocol_version())
-}
-
-                
-pub fn supported_versions_server<'a>() -> (o: SupportedVersionsServerCombinator)
-    ensures o@ == spec_supported_versions_server(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = SupportedVersionsServerCombinator(protocol_version());
-    assert({
-        &&& combinator@ == spec_supported_versions_server()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
-
-pub fn parse_supported_versions_server<'a>(input: &'a [u8]) -> (res: PResult<<SupportedVersionsServerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_supported_versions_server().spec_parse(input@) == Some((n as int, v@)),
-        spec_supported_versions_server().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_supported_versions_server().spec_parse(input@) is None,
-        spec_supported_versions_server().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = supported_versions_server();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
-}
-
-pub fn serialize_supported_versions_server<'a>(v: <SupportedVersionsServerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_supported_versions_server().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_supported_versions_server().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_supported_versions_server().spec_serialize(v@))
-        },
-{
-    let combinator = supported_versions_server();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
-}
-
-pub fn supported_versions_server_len<'a>(v: <SupportedVersionsServerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_supported_versions_server().wf(v@),
-        spec_supported_versions_server().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_supported_versions_server().spec_serialize(v@).len(),
-{
-    let combinator = supported_versions_server();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+    fn apply(&self, deps: SignatureSchemeListCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(signature_scheme()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(signature_scheme()))
+            }
+        }
+    }
 }
-
                 
 
-pub struct SpecSessionId {
-    pub l: u8,
-    pub id: Seq<u8>,
+pub struct SpecOpaque1Ffff {
+    pub l: u16,
+    pub data: Seq<u8>,
 }
 
-pub type SpecSessionIdInner = (u8, Seq<u8>);
+pub type SpecOpaque1FfffInner = (u16, Seq<u8>);
 
 
-impl SpecFrom<SpecSessionId> for SpecSessionIdInner {
-    open spec fn spec_from(m: SpecSessionId) -> SpecSessionIdInner {
-        (m.l, m.id)
+impl SpecFrom<SpecOpaque1Ffff> for SpecOpaque1FfffInner {
+    open spec fn spec_from(m: SpecOpaque1Ffff) -> SpecOpaque1FfffInner {
+        (m.l, m.data)
     }
 }
 
-impl SpecFrom<SpecSessionIdInner> for SpecSessionId {
-    open spec fn spec_from(m: SpecSessionIdInner) -> SpecSessionId {
-        let (l, id) = m;
-        SpecSessionId { l, id }
+impl SpecFrom<SpecOpaque1FfffInner> for SpecOpaque1Ffff {
+    open spec fn spec_from(m: SpecOpaque1FfffInner) -> SpecOpaque1Ffff {
+        let (l, data) = m;
+        SpecOpaque1Ffff { l, data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct SessionId<'a> {
-    pub l: u8,
-    pub id: &'a [u8],
+pub struct Opaque1Ffff<'a> {
+    pub l: u16,
+    pub data: &'a [u8],
 }
 
-impl View for SessionId<'_> {
-    type V = SpecSessionId;
+impl View for Opaque1Ffff<'_> {
+    type V = SpecOpaque1Ffff;
 
     open spec fn view(&self) -> Self::V {
-        SpecSessionId {
+        SpecOpaque1Ffff {
             l: self.l@,
-            id: self.id@,
+            data: self.data@,
         }
     }
 }
-pub type SessionIdInner<'a> = (u8, &'a [u8]);
+pub type Opaque1FfffInner<'a> = (u16, &'a [u8]);
 
-pub type SessionIdInnerRef<'a> = (&'a u8, &'a &'a [u8]);
-impl<'a> From<&'a SessionId<'a>> for SessionIdInnerRef<'a> {
-    fn ex_from(m: &'a SessionId) -> SessionIdInnerRef<'a> {
-        (&m.l, &m.id)
+pub type Opaque1FfffInnerRef<'a> = (&'a u16, &'a &'a [u8]);
+impl<'a> From<&'a Opaque1Ffff<'a>> for Opaque1FfffInnerRef<'a> {
+    fn ex_from(m: &'a Opaque1Ffff) -> Opaque1FfffInnerRef<'a> {
+        (&m.l, &m.data)
     }
 }
 
-impl<'a> From<SessionIdInner<'a>> for SessionId<'a> {
-    fn ex_from(m: SessionIdInner) -> SessionId {
-        let (l, id) = m;
-        SessionId { l, id }
+impl<'a> From<Opaque1FfffInner<'a>> for Opaque1Ffff<'a> {
+    fn ex_from(m: Opaque1FfffInner) -> Opaque1Ffff {
+        let (l, data) = m;
+        Opaque1Ffff { l, data }
     }
 }
 
-pub struct SessionIdMapper;
-impl View for SessionIdMapper {
+pub struct Opaque1FfffMapper;
+impl View for Opaque1FfffMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for SessionIdMapper {
-    type Src = SpecSessionIdInner;
-    type Dst = SpecSessionId;
+impl SpecIso for Opaque1FfffMapper {
+    type Src = SpecOpaque1FfffInner;
+    type Dst = SpecOpaque1Ffff;
 }
-impl SpecIsoProof for SessionIdMapper {
+impl SpecIsoProof for Opaque1FfffMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -1659,509 +1405,383 @@ impl SpecIsoProof for SessionIdMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for SessionIdMapper {
-    type Src = SessionIdInner<'a>;
-    type Dst = SessionId<'a>;
-    type RefSrc = SessionIdInnerRef<'a>;
+impl<'a> Iso<'a> for Opaque1FfffMapper {
+    type Src = Opaque1FfffInner<'a>;
+    type Dst = Opaque1Ffff<'a>;
+    type RefSrc = Opaque1FfffInnerRef<'a>;
 }
 
-pub struct SpecSessionIdCombinator(pub SpecSessionIdCombinatorAlias);
+pub struct SpecOpaque1FfffCombinator(pub SpecOpaque1FfffCombinatorAlias);
 
-impl SpecCombinator for SpecSessionIdCombinator {
-    type Type = SpecSessionId;
+impl SpecCombinator for SpecOpaque1FfffCombinator {
+    type Type = SpecOpaque1Ffff;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecSessionIdCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSessionIdCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOpaque1FfffCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOpaque1FfffCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecSessionIdCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate14254733753739482027>, bytes::Variable>, SessionIdMapper>;
-pub struct Predicate14254733753739482027;
-impl View for Predicate14254733753739482027 {
+pub type SpecOpaque1FfffCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate17626095872143391426>, bytes::Variable>, Opaque1FfffMapper>;
+pub struct Predicate17626095872143391426;
+impl View for Predicate17626095872143391426 {
     type V = Self;
 
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl Pred<u8> for Predicate14254733753739482027 {
-    fn apply(&self, i: &u8) -> bool {
+impl Pred<u16> for Predicate17626095872143391426 {
+    fn apply(&self, i: &u16) -> bool {
         let i = (*i);
-        (i >= 0 && i <= 32)
+        (i >= 1 && i <= 65535)
     }
 }
-impl SpecPred<u8> for Predicate14254733753739482027 {
-    open spec fn spec_apply(&self, i: &u8) -> bool {
+impl SpecPred<u16> for Predicate17626095872143391426 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
         let i = (*i);
-        (i >= 0 && i <= 32)
+        (i >= 1 && i <= 65535)
     }
 }
 
-pub struct SessionIdCombinator(pub SessionIdCombinatorAlias);
+pub struct Opaque1FfffCombinator(pub Opaque1FfffCombinatorAlias);
 
-impl View for SessionIdCombinator {
-    type V = SpecSessionIdCombinator;
-    open spec fn view(&self) -> Self::V { SpecSessionIdCombinator(self.0@) }
+impl View for Opaque1FfffCombinator {
+    type V = SpecOpaque1FfffCombinator;
+    open spec fn view(&self) -> Self::V { SpecOpaque1FfffCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SessionIdCombinator {
-    type Type = SessionId<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque1FfffCombinator {
+    type Type = Opaque1Ffff<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SessionIdCombinatorAlias = Mapped<Pair<Refined<U8, Predicate14254733753739482027>, bytes::Variable, SessionIdCont0>, SessionIdMapper>;
+}
+pub type Opaque1FfffCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate17626095872143391426>, bytes::Variable, Opaque1FfffCont0>, Opaque1FfffMapper>;
 
 
-pub open spec fn spec_session_id() -> SpecSessionIdCombinator {
-    SpecSessionIdCombinator(
+pub open spec fn spec_opaque_1_ffff() -> SpecOpaque1FfffCombinator {
+    SpecOpaque1FfffCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate14254733753739482027 }, |deps| spec_session_id_cont0(deps)),
-        mapper: SessionIdMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate17626095872143391426 }, |deps| spec_opaque1_ffff_cont0(deps)),
+        mapper: Opaque1FfffMapper,
     })
 }
 
-pub open spec fn spec_session_id_cont0(deps: u8) -> bytes::Variable {
+pub open spec fn spec_opaque1_ffff_cont0(deps: u16) -> bytes::Variable {
     let l = deps;
-    bytes::Variable(l.spec_into())
+    bytes::Variable((usize::spec_from(l)) as usize)
 }
 
-impl View for SessionIdCont0 {
-    type V = spec_fn(u8) -> bytes::Variable;
+impl View for Opaque1FfffCont0 {
+    type V = spec_fn(u16) -> bytes::Variable;
 
     open spec fn view(&self) -> Self::V {
-        |deps: u8| {
-            spec_session_id_cont0(deps)
+        |deps: u16| {
+            spec_opaque1_ffff_cont0(deps)
         }
     }
 }
 
                 
-pub fn session_id<'a>() -> (o: SessionIdCombinator)
-    ensures o@ == spec_session_id(),
+pub fn opaque_1_ffff<'a>() -> (o: Opaque1FfffCombinator)
+    ensures o@ == spec_opaque_1_ffff(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = SessionIdCombinator(
+    let combinator = Opaque1FfffCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U8, predicate: Predicate14254733753739482027 }, SessionIdCont0),
-        mapper: SessionIdMapper,
-    });
-    assert({
-        &&& combinator@ == spec_session_id()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate17626095872143391426 }, Opaque1FfffCont0),
+        mapper: Opaque1FfffMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_opaque_1_ffff()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_session_id<'a>(input: &'a [u8]) -> (res: PResult<<SessionIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_opaque_1_ffff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque1FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_session_id().spec_parse(input@) == Some((n as int, v@)),
-        spec_session_id().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_opaque_1_ffff().spec_parse(input@) == Some((n as int, v@)),
+        spec_opaque_1_ffff().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_session_id().spec_parse(input@) is None,
-        spec_session_id().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_opaque_1_ffff().spec_parse(input@) is None,
+        spec_opaque_1_ffff().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = session_id();
+    let combinator = opaque_1_ffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_session_id<'a>(v: <SessionIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_opaque_1_ffff<'a>(v: <Opaque1FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_session_id().wf(v@),
+        spec_opaque_1_ffff().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_session_id().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_session_id().spec_serialize(v@))
+            &&& n == spec_opaque_1_ffff().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_1_ffff().spec_serialize(v@))
         },
 {
-    let combinator = session_id();
+    let combinator = opaque_1_ffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn session_id_len<'a>(v: <SessionIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn opaque_1_ffff_len<'a>(v: <Opaque1FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_session_id().wf(v@),
-        spec_session_id().spec_serialize(v@).len() <= usize::MAX,
+        spec_opaque_1_ffff().wf(v@),
+        spec_opaque_1_ffff().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_session_id().spec_serialize(v@).len(),
+        serialize_len == spec_opaque_1_ffff().spec_serialize(v@).len(),
 {
-    let combinator = session_id();
+    let combinator = opaque_1_ffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct SessionIdCont0;
-type SessionIdCont0Type<'a, 'b> = &'b u8;
-type SessionIdCont0SType<'a, 'x> = &'x u8;
-type SessionIdCont0Input<'a, 'b, 'x> = POrSType<SessionIdCont0Type<'a, 'b>, SessionIdCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<SessionIdCont0Input<'a, 'b, 'x>> for SessionIdCont0 {
+pub struct Opaque1FfffCont0;
+type Opaque1FfffCont0Type<'a, 'b> = &'b u16;
+type Opaque1FfffCont0SType<'a, 'x> = &'x u16;
+type Opaque1FfffCont0Input<'a, 'b, 'x> = POrSType<Opaque1FfffCont0Type<'a, 'b>, Opaque1FfffCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Opaque1FfffCont0Input<'a, 'b, 'x>> for Opaque1FfffCont0 {
     type Output = bytes::Variable;
 
-    open spec fn requires(&self, deps: SessionIdCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: Opaque1FfffCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate17626095872143391426 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: SessionIdCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_session_id_cont0(deps@)
+    open spec fn ensures(&self, deps: Opaque1FfffCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_opaque1_ffff_cont0(deps@)
     }
 
-    fn apply(&self, deps: SessionIdCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: Opaque1FfffCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                bytes::Variable(l.ex_into())
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
-
-pub spec const SPEC_ContentType_Invalid: u8 = 0;
-pub spec const SPEC_ContentType_ChangeCipherSpec: u8 = 20;
-pub spec const SPEC_ContentType_Alert: u8 = 21;
-pub spec const SPEC_ContentType_Handshake: u8 = 22;
-pub spec const SPEC_ContentType_ApplicationData: u8 = 23;
-pub exec static EXEC_ContentType_Invalid: u8 ensures EXEC_ContentType_Invalid == SPEC_ContentType_Invalid { 0 }
-pub exec static EXEC_ContentType_ChangeCipherSpec: u8 ensures EXEC_ContentType_ChangeCipherSpec == SPEC_ContentType_ChangeCipherSpec { 20 }
-pub exec static EXEC_ContentType_Alert: u8 ensures EXEC_ContentType_Alert == SPEC_ContentType_Alert { 21 }
-pub exec static EXEC_ContentType_Handshake: u8 ensures EXEC_ContentType_Handshake == SPEC_ContentType_Handshake { 22 }
-pub exec static EXEC_ContentType_ApplicationData: u8 ensures EXEC_ContentType_ApplicationData == SPEC_ContentType_ApplicationData { 23 }
-
-#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
-pub enum ContentType {
-    Invalid = 0,
-ChangeCipherSpec = 20,
-Alert = 21,
-Handshake = 22,
-ApplicationData = 23
-}
-pub type SpecContentType = ContentType;
-
-pub type ContentTypeInner = u8;
-
-pub type ContentTypeInnerRef<'a> = &'a u8;
-
-impl View for ContentType {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-
-impl SpecTryFrom<ContentTypeInner> for ContentType {
-    type Error = ();
-
-    open spec fn spec_try_from(v: ContentTypeInner) -> Result<ContentType, ()> {
-        match v {
-            0u8 => Ok(ContentType::Invalid),
-            20u8 => Ok(ContentType::ChangeCipherSpec),
-            21u8 => Ok(ContentType::Alert),
-            22u8 => Ok(ContentType::Handshake),
-            23u8 => Ok(ContentType::ApplicationData),
-            _ => Err(()),
-        }
-    }
-}
-
-impl SpecTryFrom<ContentType> for ContentTypeInner {
-    type Error = ();
-
-    open spec fn spec_try_from(v: ContentType) -> Result<ContentTypeInner, ()> {
-        match v {
-            ContentType::Invalid => Ok(SPEC_ContentType_Invalid),
-            ContentType::ChangeCipherSpec => Ok(SPEC_ContentType_ChangeCipherSpec),
-            ContentType::Alert => Ok(SPEC_ContentType_Alert),
-            ContentType::Handshake => Ok(SPEC_ContentType_Handshake),
-            ContentType::ApplicationData => Ok(SPEC_ContentType_ApplicationData),
-        }
-    }
-}
-
-impl TryFrom<ContentTypeInner> for ContentType {
-    type Error = ();
-
-    fn ex_try_from(v: ContentTypeInner) -> Result<ContentType, ()> {
-        match v {
-            0u8 => Ok(ContentType::Invalid),
-            20u8 => Ok(ContentType::ChangeCipherSpec),
-            21u8 => Ok(ContentType::Alert),
-            22u8 => Ok(ContentType::Handshake),
-            23u8 => Ok(ContentType::ApplicationData),
-            _ => Err(()),
-        }
-    }
-}
-
-impl<'a> TryFrom<&'a ContentType> for ContentTypeInnerRef<'a> {
-    type Error = ();
-
-    fn ex_try_from(v: &'a ContentType) -> Result<ContentTypeInnerRef<'a>, ()> {
-        match v {
-            ContentType::Invalid => Ok(&EXEC_ContentType_Invalid),
-            ContentType::ChangeCipherSpec => Ok(&EXEC_ContentType_ChangeCipherSpec),
-            ContentType::Alert => Ok(&EXEC_ContentType_Alert),
-            ContentType::Handshake => Ok(&EXEC_ContentType_Handshake),
-            ContentType::ApplicationData => Ok(&EXEC_ContentType_ApplicationData),
-        }
-    }
-}
-
-pub struct ContentTypeMapper;
-
-impl View for ContentTypeMapper {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-
-impl SpecPartialIso for ContentTypeMapper {
-    type Src = ContentTypeInner;
-    type Dst = ContentType;
-}
-
-impl SpecPartialIsoProof for ContentTypeMapper {
-    proof fn spec_iso(s: Self::Src) { 
-        assert(
-            Self::spec_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_rev_apply(v) is Ok
-            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
-        });
-    }
-
-    proof fn spec_iso_rev(s: Self::Dst) { 
-        assert(
-            Self::spec_rev_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_apply(v) is Ok
-            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
-        });
-    }
-}
-
-impl<'a> PartialIso<'a> for ContentTypeMapper {
-    type Src = ContentTypeInner;
-    type Dst = ContentType;
-    type RefSrc = ContentTypeInnerRef<'a>;
-}
+pub type SpecDistinguishedName = SpecOpaque1Ffff;
+pub type DistinguishedName<'a> = Opaque1Ffff<'a>;
+pub type DistinguishedNameRef<'a> = &'a Opaque1Ffff<'a>;
 
 
-pub struct SpecContentTypeCombinator(pub SpecContentTypeCombinatorAlias);
+pub struct SpecDistinguishedNameCombinator(pub SpecDistinguishedNameCombinatorAlias);
 
-impl SpecCombinator for SpecContentTypeCombinator {
-    type Type = SpecContentType;
+impl SpecCombinator for SpecDistinguishedNameCombinator {
+    type Type = SpecDistinguishedName;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecContentTypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecContentTypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecDistinguishedNameCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDistinguishedNameCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecContentTypeCombinatorAlias = TryMap<U8, ContentTypeMapper>;
+pub type SpecDistinguishedNameCombinatorAlias = SpecOpaque1FfffCombinator;
 
-pub struct ContentTypeCombinator(pub ContentTypeCombinatorAlias);
+pub struct DistinguishedNameCombinator(pub DistinguishedNameCombinatorAlias);
 
-impl View for ContentTypeCombinator {
-    type V = SpecContentTypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecContentTypeCombinator(self.0@) }
+impl View for DistinguishedNameCombinator {
+    type V = SpecDistinguishedNameCombinator;
+    open spec fn view(&self) -> Self::V { SpecDistinguishedNameCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ContentTypeCombinator {
-    type Type = ContentType;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DistinguishedNameCombinator {
+    type Type = DistinguishedName<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ContentTypeCombinatorAlias = TryMap<U8, ContentTypeMapper>;
+}
+pub type DistinguishedNameCombinatorAlias = Opaque1FfffCombinator;
 
 
-pub open spec fn spec_content_type() -> SpecContentTypeCombinator {
-    SpecContentTypeCombinator(TryMap { inner: U8, mapper: ContentTypeMapper })
+pub open spec fn spec_distinguished_name() -> SpecDistinguishedNameCombinator {
+    SpecDistinguishedNameCombinator(spec_opaque_1_ffff())
 }
 
                 
-pub fn content_type<'a>() -> (o: ContentTypeCombinator)
-    ensures o@ == spec_content_type(),
+pub fn distinguished_name<'a>() -> (o: DistinguishedNameCombinator)
+    ensures o@ == spec_distinguished_name(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ContentTypeCombinator(TryMap { inner: U8, mapper: ContentTypeMapper });
-    assert({
-        &&& combinator@ == spec_content_type()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = DistinguishedNameCombinator(opaque_1_ffff());
+    // assert({
+    //     &&& combinator@ == spec_distinguished_name()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_content_type<'a>(input: &'a [u8]) -> (res: PResult<<ContentTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_distinguished_name<'a>(input: &'a [u8]) -> (res: PResult<<DistinguishedNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_content_type().spec_parse(input@) == Some((n as int, v@)),
-        spec_content_type().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_distinguished_name().spec_parse(input@) == Some((n as int, v@)),
+        spec_distinguished_name().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_content_type().spec_parse(input@) is None,
-        spec_content_type().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_distinguished_name().spec_parse(input@) is None,
+        spec_distinguished_name().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = content_type();
+    let combinator = distinguished_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_content_type<'a>(v: <ContentTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_distinguished_name<'a>(v: <DistinguishedNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_content_type().wf(v@),
+        spec_distinguished_name().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& 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@))
+            &&& n == spec_distinguished_name().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_distinguished_name().spec_serialize(v@))
         },
 {
-    let combinator = content_type();
+    let combinator = distinguished_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn content_type_len<'a>(v: <ContentTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn distinguished_name_len<'a>(v: <DistinguishedNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_content_type().wf(v@),
-        spec_content_type().spec_serialize(v@).len() <= usize::MAX,
+        spec_distinguished_name().wf(v@),
+        spec_distinguished_name().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_content_type().spec_serialize(v@).len(),
+        serialize_len == spec_distinguished_name().spec_serialize(v@).len(),
 {
-    let combinator = content_type();
+    let combinator = distinguished_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecTlsPlaintext {
-    pub content_type: SpecContentType,
-    pub legacy_record_version: u16,
-    pub fragment: SpecOpaque0Ffff,
+pub struct SpecCertificateAuthoritiesExtension {
+    pub l: u16,
+    pub list: Seq<SpecDistinguishedName>,
 }
 
-pub type SpecTlsPlaintextInner = (SpecContentType, (u16, SpecOpaque0Ffff));
+pub type SpecCertificateAuthoritiesExtensionInner = (u16, Seq<SpecDistinguishedName>);
 
 
-impl SpecFrom<SpecTlsPlaintext> for SpecTlsPlaintextInner {
-    open spec fn spec_from(m: SpecTlsPlaintext) -> SpecTlsPlaintextInner {
-        (m.content_type, (m.legacy_record_version, m.fragment))
+impl SpecFrom<SpecCertificateAuthoritiesExtension> for SpecCertificateAuthoritiesExtensionInner {
+    open spec fn spec_from(m: SpecCertificateAuthoritiesExtension) -> SpecCertificateAuthoritiesExtensionInner {
+        (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecTlsPlaintextInner> for SpecTlsPlaintext {
-    open spec fn spec_from(m: SpecTlsPlaintextInner) -> SpecTlsPlaintext {
-        let (content_type, (legacy_record_version, fragment)) = m;
-        SpecTlsPlaintext { content_type, legacy_record_version, fragment }
+impl SpecFrom<SpecCertificateAuthoritiesExtensionInner> for SpecCertificateAuthoritiesExtension {
+    open spec fn spec_from(m: SpecCertificateAuthoritiesExtensionInner) -> SpecCertificateAuthoritiesExtension {
+        let (l, list) = m;
+        SpecCertificateAuthoritiesExtension { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct TlsPlaintext<'a> {
-    pub content_type: ContentType,
-    pub legacy_record_version: u16,
-    pub fragment: Opaque0Ffff<'a>,
+pub struct CertificateAuthoritiesExtension<'a> {
+    pub l: u16,
+    pub list: RepeatResult<DistinguishedName<'a>>,
 }
 
-impl View for TlsPlaintext<'_> {
-    type V = SpecTlsPlaintext;
+impl View for CertificateAuthoritiesExtension<'_> {
+    type V = SpecCertificateAuthoritiesExtension;
 
     open spec fn view(&self) -> Self::V {
-        SpecTlsPlaintext {
-            content_type: self.content_type@,
-            legacy_record_version: self.legacy_record_version@,
-            fragment: self.fragment@,
+        SpecCertificateAuthoritiesExtension {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
-pub type TlsPlaintextInner<'a> = (ContentType, (u16, Opaque0Ffff<'a>));
+pub type CertificateAuthoritiesExtensionInner<'a> = (u16, RepeatResult<DistinguishedName<'a>>);
 
-pub type TlsPlaintextInnerRef<'a> = (&'a ContentType, (&'a u16, &'a Opaque0Ffff<'a>));
-impl<'a> From<&'a TlsPlaintext<'a>> for TlsPlaintextInnerRef<'a> {
-    fn ex_from(m: &'a TlsPlaintext) -> TlsPlaintextInnerRef<'a> {
-        (&m.content_type, (&m.legacy_record_version, &m.fragment))
+pub type CertificateAuthoritiesExtensionInnerRef<'a> = (&'a u16, &'a RepeatResult<DistinguishedName<'a>>);
+impl<'a> From<&'a CertificateAuthoritiesExtension<'a>> for CertificateAuthoritiesExtensionInnerRef<'a> {
+    fn ex_from(m: &'a CertificateAuthoritiesExtension) -> CertificateAuthoritiesExtensionInnerRef<'a> {
+        (&m.l, &m.list)
     }
 }
 
-impl<'a> From<TlsPlaintextInner<'a>> for TlsPlaintext<'a> {
-    fn ex_from(m: TlsPlaintextInner) -> TlsPlaintext {
-        let (content_type, (legacy_record_version, fragment)) = m;
-        TlsPlaintext { content_type, legacy_record_version, fragment }
+impl<'a> From<CertificateAuthoritiesExtensionInner<'a>> for CertificateAuthoritiesExtension<'a> {
+    fn ex_from(m: CertificateAuthoritiesExtensionInner) -> CertificateAuthoritiesExtension {
+        let (l, list) = m;
+        CertificateAuthoritiesExtension { l, list }
     }
 }
 
-pub struct TlsPlaintextMapper;
-impl View for TlsPlaintextMapper {
+pub struct CertificateAuthoritiesExtensionMapper;
+impl View for CertificateAuthoritiesExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for TlsPlaintextMapper {
-    type Src = SpecTlsPlaintextInner;
-    type Dst = SpecTlsPlaintext;
+impl SpecIso for CertificateAuthoritiesExtensionMapper {
+    type Src = SpecCertificateAuthoritiesExtensionInner;
+    type Dst = SpecCertificateAuthoritiesExtension;
 }
-impl SpecIsoProof for TlsPlaintextMapper {
+impl SpecIsoProof for CertificateAuthoritiesExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -2169,708 +1789,836 @@ impl SpecIsoProof for TlsPlaintextMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for TlsPlaintextMapper {
-    type Src = TlsPlaintextInner<'a>;
-    type Dst = TlsPlaintext<'a>;
-    type RefSrc = TlsPlaintextInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateAuthoritiesExtensionMapper {
+    type Src = CertificateAuthoritiesExtensionInner<'a>;
+    type Dst = CertificateAuthoritiesExtension<'a>;
+    type RefSrc = CertificateAuthoritiesExtensionInnerRef<'a>;
 }
-type SpecTlsPlaintextCombinatorAlias1 = (SpecProtocolVersionCombinator, SpecOpaque0FfffCombinator);
-type SpecTlsPlaintextCombinatorAlias2 = (SpecContentTypeCombinator, SpecTlsPlaintextCombinatorAlias1);
-pub struct SpecTlsPlaintextCombinator(pub SpecTlsPlaintextCombinatorAlias);
 
-impl SpecCombinator for SpecTlsPlaintextCombinator {
-    type Type = SpecTlsPlaintext;
+pub struct SpecCertificateAuthoritiesExtensionCombinator(pub SpecCertificateAuthoritiesExtensionCombinatorAlias);
+
+impl SpecCombinator for SpecCertificateAuthoritiesExtensionCombinator {
+    type Type = SpecCertificateAuthoritiesExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTlsPlaintextCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTlsPlaintextCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateAuthoritiesExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateAuthoritiesExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTlsPlaintextCombinatorAlias = Mapped<SpecTlsPlaintextCombinatorAlias2, TlsPlaintextMapper>;
-type TlsPlaintextCombinatorAlias1 = (ProtocolVersionCombinator, Opaque0FfffCombinator);
-type TlsPlaintextCombinatorAlias2 = (ContentTypeCombinator, TlsPlaintextCombinator1);
-pub struct TlsPlaintextCombinator1(pub TlsPlaintextCombinatorAlias1);
-impl View for TlsPlaintextCombinator1 {
-    type V = SpecTlsPlaintextCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(TlsPlaintextCombinator1, TlsPlaintextCombinatorAlias1);
+pub type SpecCertificateAuthoritiesExtensionCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate7402808336413996182>, AndThen<bytes::Variable, Repeat<SpecDistinguishedNameCombinator>>>, CertificateAuthoritiesExtensionMapper>;
+pub struct Predicate7402808336413996182;
+impl View for Predicate7402808336413996182 {
+    type V = Self;
 
-pub struct TlsPlaintextCombinator2(pub TlsPlaintextCombinatorAlias2);
-impl View for TlsPlaintextCombinator2 {
-    type V = SpecTlsPlaintextCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate7402808336413996182 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 3 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate7402808336413996182 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 3 && i <= 65535)
+    }
 }
-impl_wrapper_combinator!(TlsPlaintextCombinator2, TlsPlaintextCombinatorAlias2);
 
-pub struct TlsPlaintextCombinator(pub TlsPlaintextCombinatorAlias);
+pub struct CertificateAuthoritiesExtensionCombinator(pub CertificateAuthoritiesExtensionCombinatorAlias);
 
-impl View for TlsPlaintextCombinator {
-    type V = SpecTlsPlaintextCombinator;
-    open spec fn view(&self) -> Self::V { SpecTlsPlaintextCombinator(self.0@) }
+impl View for CertificateAuthoritiesExtensionCombinator {
+    type V = SpecCertificateAuthoritiesExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateAuthoritiesExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TlsPlaintextCombinator {
-    type Type = TlsPlaintext<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateAuthoritiesExtensionCombinator {
+    type Type = CertificateAuthoritiesExtension<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TlsPlaintextCombinatorAlias = Mapped<TlsPlaintextCombinator2, TlsPlaintextMapper>;
+}
+pub type CertificateAuthoritiesExtensionCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate7402808336413996182>, AndThen<bytes::Variable, Repeat<DistinguishedNameCombinator>>, CertificateAuthoritiesExtensionCont0>, CertificateAuthoritiesExtensionMapper>;
 
 
-pub open spec fn spec_tls_plaintext() -> SpecTlsPlaintextCombinator {
-    SpecTlsPlaintextCombinator(
+pub open spec fn spec_certificate_authorities_extension() -> SpecCertificateAuthoritiesExtensionCombinator {
+    SpecCertificateAuthoritiesExtensionCombinator(
     Mapped {
-        inner: (spec_content_type(), (spec_protocol_version(), spec_opaque_0_ffff())),
-        mapper: TlsPlaintextMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate7402808336413996182 }, |deps| spec_certificate_authorities_extension_cont0(deps)),
+        mapper: CertificateAuthoritiesExtensionMapper,
     })
 }
 
+pub open spec fn spec_certificate_authorities_extension_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecDistinguishedNameCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_distinguished_name()))
+}
+
+impl View for CertificateAuthoritiesExtensionCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecDistinguishedNameCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_certificate_authorities_extension_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn tls_plaintext<'a>() -> (o: TlsPlaintextCombinator)
-    ensures o@ == spec_tls_plaintext(),
+pub fn certificate_authorities_extension<'a>() -> (o: CertificateAuthoritiesExtensionCombinator)
+    ensures o@ == spec_certificate_authorities_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = TlsPlaintextCombinator(
+    let combinator = CertificateAuthoritiesExtensionCombinator(
     Mapped {
-        inner: TlsPlaintextCombinator2((content_type(), TlsPlaintextCombinator1((protocol_version(), opaque_0_ffff())))),
-        mapper: TlsPlaintextMapper,
-    });
-    assert({
-        &&& combinator@ == spec_tls_plaintext()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate7402808336413996182 }, CertificateAuthoritiesExtensionCont0),
+        mapper: CertificateAuthoritiesExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_authorities_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_tls_plaintext<'a>(input: &'a [u8]) -> (res: PResult<<TlsPlaintextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_authorities_extension<'a>(input: &'a [u8]) -> (res: PResult<<CertificateAuthoritiesExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_tls_plaintext().spec_parse(input@) == Some((n as int, v@)),
-        spec_tls_plaintext().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_authorities_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_authorities_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_tls_plaintext().spec_parse(input@) is None,
-        spec_tls_plaintext().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_authorities_extension().spec_parse(input@) is None,
+        spec_certificate_authorities_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = tls_plaintext();
+    let combinator = certificate_authorities_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_tls_plaintext<'a>(v: <TlsPlaintextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_authorities_extension<'a>(v: <CertificateAuthoritiesExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_tls_plaintext().wf(v@),
+        spec_certificate_authorities_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_tls_plaintext().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_tls_plaintext().spec_serialize(v@))
+            &&& n == spec_certificate_authorities_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_authorities_extension().spec_serialize(v@))
         },
 {
-    let combinator = tls_plaintext();
+    let combinator = certificate_authorities_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn tls_plaintext_len<'a>(v: <TlsPlaintextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_authorities_extension_len<'a>(v: <CertificateAuthoritiesExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_tls_plaintext().wf(v@),
-        spec_tls_plaintext().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_authorities_extension().wf(v@),
+        spec_certificate_authorities_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_tls_plaintext().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_authorities_extension().spec_serialize(v@).len(),
 {
-    let combinator = tls_plaintext();
+    let combinator = certificate_authorities_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct CertificateAuthoritiesExtensionCont0;
+type CertificateAuthoritiesExtensionCont0Type<'a, 'b> = &'b u16;
+type CertificateAuthoritiesExtensionCont0SType<'a, 'x> = &'x u16;
+type CertificateAuthoritiesExtensionCont0Input<'a, 'b, 'x> = POrSType<CertificateAuthoritiesExtensionCont0Type<'a, 'b>, CertificateAuthoritiesExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CertificateAuthoritiesExtensionCont0Input<'a, 'b, 'x>> for CertificateAuthoritiesExtensionCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<DistinguishedNameCombinator>>;
+
+    open spec fn requires(&self, deps: CertificateAuthoritiesExtensionCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate7402808336413996182 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CertificateAuthoritiesExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_certificate_authorities_extension_cont0(deps@)
+    }
+
+    fn apply(&self, deps: CertificateAuthoritiesExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(distinguished_name()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(distinguished_name()))
+            }
+        }
+    }
+}
                 
-pub type SpecDistinguishedName = SpecOpaque1Ffff;
-pub type DistinguishedName<'a> = Opaque1Ffff<'a>;
-pub type DistinguishedNameRef<'a> = &'a Opaque1Ffff<'a>;
+pub type SpecResponderId = SpecOpaque1Ffff;
+pub type ResponderId<'a> = Opaque1Ffff<'a>;
+pub type ResponderIdRef<'a> = &'a Opaque1Ffff<'a>;
 
 
-pub struct SpecDistinguishedNameCombinator(pub SpecDistinguishedNameCombinatorAlias);
+pub struct SpecResponderIdCombinator(pub SpecResponderIdCombinatorAlias);
 
-impl SpecCombinator for SpecDistinguishedNameCombinator {
-    type Type = SpecDistinguishedName;
+impl SpecCombinator for SpecResponderIdCombinator {
+    type Type = SpecResponderId;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecDistinguishedNameCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecDistinguishedNameCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecResponderIdCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecResponderIdCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecDistinguishedNameCombinatorAlias = SpecOpaque1FfffCombinator;
+pub type SpecResponderIdCombinatorAlias = SpecOpaque1FfffCombinator;
 
-pub struct DistinguishedNameCombinator(pub DistinguishedNameCombinatorAlias);
+pub struct ResponderIdCombinator(pub ResponderIdCombinatorAlias);
 
-impl View for DistinguishedNameCombinator {
-    type V = SpecDistinguishedNameCombinator;
-    open spec fn view(&self) -> Self::V { SpecDistinguishedNameCombinator(self.0@) }
+impl View for ResponderIdCombinator {
+    type V = SpecResponderIdCombinator;
+    open spec fn view(&self) -> Self::V { SpecResponderIdCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DistinguishedNameCombinator {
-    type Type = DistinguishedName<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ResponderIdCombinator {
+    type Type = ResponderId<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type DistinguishedNameCombinatorAlias = Opaque1FfffCombinator;
+}
+pub type ResponderIdCombinatorAlias = Opaque1FfffCombinator;
 
 
-pub open spec fn spec_distinguished_name() -> SpecDistinguishedNameCombinator {
-    SpecDistinguishedNameCombinator(spec_opaque_1_ffff())
+pub open spec fn spec_responder_id() -> SpecResponderIdCombinator {
+    SpecResponderIdCombinator(spec_opaque_1_ffff())
 }
 
                 
-pub fn distinguished_name<'a>() -> (o: DistinguishedNameCombinator)
-    ensures o@ == spec_distinguished_name(),
+pub fn responder_id<'a>() -> (o: ResponderIdCombinator)
+    ensures o@ == spec_responder_id(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = DistinguishedNameCombinator(opaque_1_ffff());
-    assert({
-        &&& combinator@ == spec_distinguished_name()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ResponderIdCombinator(opaque_1_ffff());
+    // assert({
+    //     &&& combinator@ == spec_responder_id()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_distinguished_name<'a>(input: &'a [u8]) -> (res: PResult<<DistinguishedNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_responder_id<'a>(input: &'a [u8]) -> (res: PResult<<ResponderIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_distinguished_name().spec_parse(input@) == Some((n as int, v@)),
-        spec_distinguished_name().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_responder_id().spec_parse(input@) == Some((n as int, v@)),
+        spec_responder_id().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_distinguished_name().spec_parse(input@) is None,
-        spec_distinguished_name().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_responder_id().spec_parse(input@) is None,
+        spec_responder_id().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = distinguished_name();
+    let combinator = responder_id();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_distinguished_name<'a>(v: <DistinguishedNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_responder_id<'a>(v: <ResponderIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_distinguished_name().wf(v@),
+        spec_responder_id().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_distinguished_name().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_distinguished_name().spec_serialize(v@))
+            &&& n == spec_responder_id().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_responder_id().spec_serialize(v@))
         },
 {
-    let combinator = distinguished_name();
+    let combinator = responder_id();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn distinguished_name_len<'a>(v: <DistinguishedNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn responder_id_len<'a>(v: <ResponderIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_distinguished_name().wf(v@),
-        spec_distinguished_name().spec_serialize(v@).len() <= usize::MAX,
+        spec_responder_id().wf(v@),
+        spec_responder_id().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_distinguished_name().spec_serialize(v@).len(),
+        serialize_len == spec_responder_id().spec_serialize(v@).len(),
 {
-    let combinator = distinguished_name();
+    let combinator = responder_id();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub mod SignatureScheme {
-    use super::*;
-    pub spec const SPEC_RSA_PKCS1_MD5: u16 = 257;
-    pub spec const SPEC_RSA_PKCS1_SHA1: u16 = 513;
-    pub spec const SPEC_ECDSA_MD5: u16 = 259;
-    pub spec const SPEC_ECDSA_SHA1: u16 = 515;
-    pub spec const SPEC_RSA_PKCS1_SHA256: u16 = 1025;
-    pub spec const SPEC_RSA_PKCS1_SHA384: u16 = 1281;
-    pub spec const SPEC_RSA_PKCS1_SHA512: u16 = 1537;
-    pub spec const SPEC_ECDSA_SECP256R1_SHA256: u16 = 1027;
-    pub spec const SPEC_ECDSA_SECP384R1_SHA384: u16 = 1283;
-    pub spec const SPEC_ECDSA_SECP521R1_SHA512: u16 = 1539;
-    pub spec const SPEC_RSA_PSS_RSAE_SHA256: u16 = 2052;
-    pub spec const SPEC_RSA_PSS_RSAE_SHA384: u16 = 2053;
-    pub spec const SPEC_RSA_PSS_RSAE_SHA512: u16 = 2054;
-    pub spec const SPEC_ED25519: u16 = 2055;
-    pub spec const SPEC_ED448: u16 = 2056;
-    pub spec const SPEC_RSA_PSS_PSS_SHA256: u16 = 2057;
-    pub spec const SPEC_RSA_PSS_PSS_SHA384: u16 = 2058;
-    pub spec const SPEC_RSA_PSS_PSS_SHA512: u16 = 2059;
-    pub exec const RSA_PKCS1_MD5: u16 ensures RSA_PKCS1_MD5 == SPEC_RSA_PKCS1_MD5 { 257 }
-    pub exec const RSA_PKCS1_SHA1: u16 ensures RSA_PKCS1_SHA1 == SPEC_RSA_PKCS1_SHA1 { 513 }
-    pub exec const ECDSA_MD5: u16 ensures ECDSA_MD5 == SPEC_ECDSA_MD5 { 259 }
-    pub exec const ECDSA_SHA1: u16 ensures ECDSA_SHA1 == SPEC_ECDSA_SHA1 { 515 }
-    pub exec const RSA_PKCS1_SHA256: u16 ensures RSA_PKCS1_SHA256 == SPEC_RSA_PKCS1_SHA256 { 1025 }
-    pub exec const RSA_PKCS1_SHA384: u16 ensures RSA_PKCS1_SHA384 == SPEC_RSA_PKCS1_SHA384 { 1281 }
-    pub exec const RSA_PKCS1_SHA512: u16 ensures RSA_PKCS1_SHA512 == SPEC_RSA_PKCS1_SHA512 { 1537 }
-    pub exec const ECDSA_SECP256R1_SHA256: u16 ensures ECDSA_SECP256R1_SHA256 == SPEC_ECDSA_SECP256R1_SHA256 { 1027 }
-    pub exec const ECDSA_SECP384R1_SHA384: u16 ensures ECDSA_SECP384R1_SHA384 == SPEC_ECDSA_SECP384R1_SHA384 { 1283 }
-    pub exec const ECDSA_SECP521R1_SHA512: u16 ensures ECDSA_SECP521R1_SHA512 == SPEC_ECDSA_SECP521R1_SHA512 { 1539 }
-    pub exec const RSA_PSS_RSAE_SHA256: u16 ensures RSA_PSS_RSAE_SHA256 == SPEC_RSA_PSS_RSAE_SHA256 { 2052 }
-    pub exec const RSA_PSS_RSAE_SHA384: u16 ensures RSA_PSS_RSAE_SHA384 == SPEC_RSA_PSS_RSAE_SHA384 { 2053 }
-    pub exec const RSA_PSS_RSAE_SHA512: u16 ensures RSA_PSS_RSAE_SHA512 == SPEC_RSA_PSS_RSAE_SHA512 { 2054 }
-    pub exec const ED25519: u16 ensures ED25519 == SPEC_ED25519 { 2055 }
-    pub exec const ED448: u16 ensures ED448 == SPEC_ED448 { 2056 }
-    pub exec const RSA_PSS_PSS_SHA256: u16 ensures RSA_PSS_PSS_SHA256 == SPEC_RSA_PSS_PSS_SHA256 { 2057 }
-    pub exec const RSA_PSS_PSS_SHA384: u16 ensures RSA_PSS_PSS_SHA384 == SPEC_RSA_PSS_PSS_SHA384 { 2058 }
-    pub exec const RSA_PSS_PSS_SHA512: u16 ensures RSA_PSS_PSS_SHA512 == SPEC_RSA_PSS_PSS_SHA512 { 2059 }
+
+pub struct SpecResponderIdList {
+    pub l: u16,
+    pub list: Seq<SpecResponderId>,
 }
 
+pub type SpecResponderIdListInner = (u16, Seq<SpecResponderId>);
 
-pub struct SpecSignatureSchemeCombinator(pub SpecSignatureSchemeCombinatorAlias);
 
-impl SpecCombinator for SpecSignatureSchemeCombinator {
-    type Type = u16;
+impl SpecFrom<SpecResponderIdList> for SpecResponderIdListInner {
+    open spec fn spec_from(m: SpecResponderIdList) -> SpecResponderIdListInner {
+        (m.l, m.list)
+    }
+}
+
+impl SpecFrom<SpecResponderIdListInner> for SpecResponderIdList {
+    open spec fn spec_from(m: SpecResponderIdListInner) -> SpecResponderIdList {
+        let (l, list) = m;
+        SpecResponderIdList { l, list }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct ResponderIdList<'a> {
+    pub l: u16,
+    pub list: RepeatResult<ResponderId<'a>>,
+}
+
+impl View for ResponderIdList<'_> {
+    type V = SpecResponderIdList;
+
+    open spec fn view(&self) -> Self::V {
+        SpecResponderIdList {
+            l: self.l@,
+            list: self.list@,
+        }
+    }
+}
+pub type ResponderIdListInner<'a> = (u16, RepeatResult<ResponderId<'a>>);
+
+pub type ResponderIdListInnerRef<'a> = (&'a u16, &'a RepeatResult<ResponderId<'a>>);
+impl<'a> From<&'a ResponderIdList<'a>> for ResponderIdListInnerRef<'a> {
+    fn ex_from(m: &'a ResponderIdList) -> ResponderIdListInnerRef<'a> {
+        (&m.l, &m.list)
+    }
+}
+
+impl<'a> From<ResponderIdListInner<'a>> for ResponderIdList<'a> {
+    fn ex_from(m: ResponderIdListInner) -> ResponderIdList {
+        let (l, list) = m;
+        ResponderIdList { l, list }
+    }
+}
+
+pub struct ResponderIdListMapper;
+impl View for ResponderIdListMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ResponderIdListMapper {
+    type Src = SpecResponderIdListInner;
+    type Dst = SpecResponderIdList;
+}
+impl SpecIsoProof for ResponderIdListMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ResponderIdListMapper {
+    type Src = ResponderIdListInner<'a>;
+    type Dst = ResponderIdList<'a>;
+    type RefSrc = ResponderIdListInnerRef<'a>;
+}
+
+pub struct SpecResponderIdListCombinator(pub SpecResponderIdListCombinatorAlias);
+
+impl SpecCombinator for SpecResponderIdListCombinator {
+    type Type = SpecResponderIdList;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecSignatureSchemeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSignatureSchemeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecResponderIdListCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecResponderIdListCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecSignatureSchemeCombinatorAlias = U16Be;
+pub type SpecResponderIdListCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecResponderIdCombinator>>>, ResponderIdListMapper>;
 
-pub struct SignatureSchemeCombinator(pub SignatureSchemeCombinatorAlias);
+pub struct ResponderIdListCombinator(pub ResponderIdListCombinatorAlias);
 
-impl View for SignatureSchemeCombinator {
-    type V = SpecSignatureSchemeCombinator;
-    open spec fn view(&self) -> Self::V { SpecSignatureSchemeCombinator(self.0@) }
+impl View for ResponderIdListCombinator {
+    type V = SpecResponderIdListCombinator;
+    open spec fn view(&self) -> Self::V { SpecResponderIdListCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SignatureSchemeCombinator {
-    type Type = u16;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ResponderIdListCombinator {
+    type Type = ResponderIdList<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SignatureSchemeCombinatorAlias = U16Be;
+}
+pub type ResponderIdListCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<ResponderIdCombinator>>, ResponderIdListCont0>, ResponderIdListMapper>;
 
 
-pub open spec fn spec_signature_scheme() -> SpecSignatureSchemeCombinator {
-    SpecSignatureSchemeCombinator(U16Be)
+pub open spec fn spec_responder_id_list() -> SpecResponderIdListCombinator {
+    SpecResponderIdListCombinator(
+    Mapped {
+        inner: Pair::spec_new(U16Be, |deps| spec_responder_id_list_cont0(deps)),
+        mapper: ResponderIdListMapper,
+    })
+}
+
+pub open spec fn spec_responder_id_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecResponderIdCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_responder_id()))
+}
+
+impl View for ResponderIdListCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecResponderIdCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_responder_id_list_cont0(deps)
+        }
+    }
 }
 
                 
-pub fn signature_scheme<'a>() -> (o: SignatureSchemeCombinator)
-    ensures o@ == spec_signature_scheme(),
+pub fn responder_id_list<'a>() -> (o: ResponderIdListCombinator)
+    ensures o@ == spec_responder_id_list(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = SignatureSchemeCombinator(U16Be);
-    assert({
-        &&& combinator@ == spec_signature_scheme()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ResponderIdListCombinator(
+    Mapped {
+        inner: Pair::new(U16Be, ResponderIdListCont0),
+        mapper: ResponderIdListMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_responder_id_list()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_signature_scheme<'a>(input: &'a [u8]) -> (res: PResult<<SignatureSchemeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_responder_id_list<'a>(input: &'a [u8]) -> (res: PResult<<ResponderIdListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_signature_scheme().spec_parse(input@) == Some((n as int, v@)),
-        spec_signature_scheme().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_responder_id_list().spec_parse(input@) == Some((n as int, v@)),
+        spec_responder_id_list().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_signature_scheme().spec_parse(input@) is None,
-        spec_signature_scheme().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_responder_id_list().spec_parse(input@) is None,
+        spec_responder_id_list().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = signature_scheme();
+    let combinator = responder_id_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_signature_scheme<'a>(v: <SignatureSchemeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_responder_id_list<'a>(v: <ResponderIdListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_signature_scheme().wf(v@),
+        spec_responder_id_list().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_signature_scheme().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_signature_scheme().spec_serialize(v@))
+            &&& n == spec_responder_id_list().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_responder_id_list().spec_serialize(v@))
         },
 {
-    let combinator = signature_scheme();
+    let combinator = responder_id_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn signature_scheme_len<'a>(v: <SignatureSchemeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn responder_id_list_len<'a>(v: <ResponderIdListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_signature_scheme().wf(v@),
-        spec_signature_scheme().spec_serialize(v@).len() <= usize::MAX,
+        spec_responder_id_list().wf(v@),
+        spec_responder_id_list().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_signature_scheme().spec_serialize(v@).len(),
+        serialize_len == spec_responder_id_list().spec_serialize(v@).len(),
 {
-    let combinator = signature_scheme();
+    let combinator = responder_id_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
+pub struct ResponderIdListCont0;
+type ResponderIdListCont0Type<'a, 'b> = &'b u16;
+type ResponderIdListCont0SType<'a, 'x> = &'x u16;
+type ResponderIdListCont0Input<'a, 'b, 'x> = POrSType<ResponderIdListCont0Type<'a, 'b>, ResponderIdListCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ResponderIdListCont0Input<'a, 'b, 'x>> for ResponderIdListCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<ResponderIdCombinator>>;
 
-pub spec const SPEC_KeyUpdateRequest_UpdateNotRequested: u8 = 0;
-pub spec const SPEC_KeyUpdateRequest_UpdateRequested: u8 = 1;
-pub exec static EXEC_KeyUpdateRequest_UpdateNotRequested: u8 ensures EXEC_KeyUpdateRequest_UpdateNotRequested == SPEC_KeyUpdateRequest_UpdateNotRequested { 0 }
-pub exec static EXEC_KeyUpdateRequest_UpdateRequested: u8 ensures EXEC_KeyUpdateRequest_UpdateRequested == SPEC_KeyUpdateRequest_UpdateRequested { 1 }
+    open spec fn requires(&self, deps: ResponderIdListCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U16Be).wf(deps@)
+        }
 
-#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
-pub enum KeyUpdateRequest {
-    UpdateNotRequested = 0,
-UpdateRequested = 1
-}
-pub type SpecKeyUpdateRequest = KeyUpdateRequest;
+    open spec fn ensures(&self, deps: ResponderIdListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_responder_id_list_cont0(deps@)
+    }
 
-pub type KeyUpdateRequestInner = u8;
+    fn apply(&self, deps: ResponderIdListCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(responder_id()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(responder_id()))
+            }
+        }
+    }
+}
+                
 
-pub type KeyUpdateRequestInnerRef<'a> = &'a u8;
+pub struct SpecOscpStatusRequest {
+    pub responder_id_list: SpecResponderIdList,
+    pub extensions: SpecOcspExtensions,
+}
 
-impl View for KeyUpdateRequest {
-    type V = Self;
+pub type SpecOscpStatusRequestInner = (SpecResponderIdList, SpecOcspExtensions);
 
-    open spec fn view(&self) -> Self::V {
-        *self
+
+impl SpecFrom<SpecOscpStatusRequest> for SpecOscpStatusRequestInner {
+    open spec fn spec_from(m: SpecOscpStatusRequest) -> SpecOscpStatusRequestInner {
+        (m.responder_id_list, m.extensions)
     }
 }
 
-impl SpecTryFrom<KeyUpdateRequestInner> for KeyUpdateRequest {
-    type Error = ();
-
-    open spec fn spec_try_from(v: KeyUpdateRequestInner) -> Result<KeyUpdateRequest, ()> {
-        match v {
-            0u8 => Ok(KeyUpdateRequest::UpdateNotRequested),
-            1u8 => Ok(KeyUpdateRequest::UpdateRequested),
-            _ => Err(()),
-        }
+impl SpecFrom<SpecOscpStatusRequestInner> for SpecOscpStatusRequest {
+    open spec fn spec_from(m: SpecOscpStatusRequestInner) -> SpecOscpStatusRequest {
+        let (responder_id_list, extensions) = m;
+        SpecOscpStatusRequest { responder_id_list, extensions }
     }
 }
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-impl SpecTryFrom<KeyUpdateRequest> for KeyUpdateRequestInner {
-    type Error = ();
-
-    open spec fn spec_try_from(v: KeyUpdateRequest) -> Result<KeyUpdateRequestInner, ()> {
-        match v {
-            KeyUpdateRequest::UpdateNotRequested => Ok(SPEC_KeyUpdateRequest_UpdateNotRequested),
-            KeyUpdateRequest::UpdateRequested => Ok(SPEC_KeyUpdateRequest_UpdateRequested),
-        }
-    }
+pub struct OscpStatusRequest<'a> {
+    pub responder_id_list: ResponderIdList<'a>,
+    pub extensions: OcspExtensions<'a>,
 }
 
-impl TryFrom<KeyUpdateRequestInner> for KeyUpdateRequest {
-    type Error = ();
+impl View for OscpStatusRequest<'_> {
+    type V = SpecOscpStatusRequest;
 
-    fn ex_try_from(v: KeyUpdateRequestInner) -> Result<KeyUpdateRequest, ()> {
-        match v {
-            0u8 => Ok(KeyUpdateRequest::UpdateNotRequested),
-            1u8 => Ok(KeyUpdateRequest::UpdateRequested),
-            _ => Err(()),
+    open spec fn view(&self) -> Self::V {
+        SpecOscpStatusRequest {
+            responder_id_list: self.responder_id_list@,
+            extensions: self.extensions@,
         }
     }
 }
+pub type OscpStatusRequestInner<'a> = (ResponderIdList<'a>, OcspExtensions<'a>);
 
-impl<'a> TryFrom<&'a KeyUpdateRequest> for KeyUpdateRequestInnerRef<'a> {
-    type Error = ();
-
-    fn ex_try_from(v: &'a KeyUpdateRequest) -> Result<KeyUpdateRequestInnerRef<'a>, ()> {
-        match v {
-            KeyUpdateRequest::UpdateNotRequested => Ok(&EXEC_KeyUpdateRequest_UpdateNotRequested),
-            KeyUpdateRequest::UpdateRequested => Ok(&EXEC_KeyUpdateRequest_UpdateRequested),
-        }
+pub type OscpStatusRequestInnerRef<'a> = (&'a ResponderIdList<'a>, &'a OcspExtensions<'a>);
+impl<'a> From<&'a OscpStatusRequest<'a>> for OscpStatusRequestInnerRef<'a> {
+    fn ex_from(m: &'a OscpStatusRequest) -> OscpStatusRequestInnerRef<'a> {
+        (&m.responder_id_list, &m.extensions)
     }
 }
 
-pub struct KeyUpdateRequestMapper;
+impl<'a> From<OscpStatusRequestInner<'a>> for OscpStatusRequest<'a> {
+    fn ex_from(m: OscpStatusRequestInner) -> OscpStatusRequest {
+        let (responder_id_list, extensions) = m;
+        OscpStatusRequest { responder_id_list, extensions }
+    }
+}
 
-impl View for KeyUpdateRequestMapper {
+pub struct OscpStatusRequestMapper;
+impl View for OscpStatusRequestMapper {
     type V = Self;
-
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-
-impl SpecPartialIso for KeyUpdateRequestMapper {
-    type Src = KeyUpdateRequestInner;
-    type Dst = KeyUpdateRequest;
+impl SpecIso for OscpStatusRequestMapper {
+    type Src = SpecOscpStatusRequestInner;
+    type Dst = SpecOscpStatusRequest;
 }
-
-impl SpecPartialIsoProof for KeyUpdateRequestMapper {
-    proof fn spec_iso(s: Self::Src) { 
-        assert(
-            Self::spec_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_rev_apply(v) is Ok
-            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
-        });
+impl SpecIsoProof for OscpStatusRequestMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
-
-    proof fn spec_iso_rev(s: Self::Dst) { 
-        assert(
-            Self::spec_rev_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_apply(v) is Ok
-            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
-        });
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-
-impl<'a> PartialIso<'a> for KeyUpdateRequestMapper {
-    type Src = KeyUpdateRequestInner;
-    type Dst = KeyUpdateRequest;
-    type RefSrc = KeyUpdateRequestInnerRef<'a>;
+impl<'a> Iso<'a> for OscpStatusRequestMapper {
+    type Src = OscpStatusRequestInner<'a>;
+    type Dst = OscpStatusRequest<'a>;
+    type RefSrc = OscpStatusRequestInnerRef<'a>;
 }
+type SpecOscpStatusRequestCombinatorAlias1 = (SpecResponderIdListCombinator, SpecOcspExtensionsCombinator);
+pub struct SpecOscpStatusRequestCombinator(pub SpecOscpStatusRequestCombinatorAlias);
 
-
-pub struct SpecKeyUpdateRequestCombinator(pub SpecKeyUpdateRequestCombinatorAlias);
-
-impl SpecCombinator for SpecKeyUpdateRequestCombinator {
-    type Type = SpecKeyUpdateRequest;
+impl SpecCombinator for SpecOscpStatusRequestCombinator {
+    type Type = SpecOscpStatusRequest;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecKeyUpdateRequestCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecKeyUpdateRequestCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOscpStatusRequestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOscpStatusRequestCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecKeyUpdateRequestCombinatorAlias = TryMap<U8, KeyUpdateRequestMapper>;
+pub type SpecOscpStatusRequestCombinatorAlias = Mapped<SpecOscpStatusRequestCombinatorAlias1, OscpStatusRequestMapper>;
+type OscpStatusRequestCombinatorAlias1 = (ResponderIdListCombinator, OcspExtensionsCombinator);
+pub struct OscpStatusRequestCombinator1(pub OscpStatusRequestCombinatorAlias1);
+impl View for OscpStatusRequestCombinator1 {
+    type V = SpecOscpStatusRequestCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(OscpStatusRequestCombinator1, OscpStatusRequestCombinatorAlias1);
 
-pub struct KeyUpdateRequestCombinator(pub KeyUpdateRequestCombinatorAlias);
+pub struct OscpStatusRequestCombinator(pub OscpStatusRequestCombinatorAlias);
 
-impl View for KeyUpdateRequestCombinator {
-    type V = SpecKeyUpdateRequestCombinator;
-    open spec fn view(&self) -> Self::V { SpecKeyUpdateRequestCombinator(self.0@) }
+impl View for OscpStatusRequestCombinator {
+    type V = SpecOscpStatusRequestCombinator;
+    open spec fn view(&self) -> Self::V { SpecOscpStatusRequestCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for KeyUpdateRequestCombinator {
-    type Type = KeyUpdateRequest;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OscpStatusRequestCombinator {
+    type Type = OscpStatusRequest<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type KeyUpdateRequestCombinatorAlias = TryMap<U8, KeyUpdateRequestMapper>;
+}
+pub type OscpStatusRequestCombinatorAlias = Mapped<OscpStatusRequestCombinator1, OscpStatusRequestMapper>;
 
 
-pub open spec fn spec_key_update_request() -> SpecKeyUpdateRequestCombinator {
-    SpecKeyUpdateRequestCombinator(TryMap { inner: U8, mapper: KeyUpdateRequestMapper })
+pub open spec fn spec_oscp_status_request() -> SpecOscpStatusRequestCombinator {
+    SpecOscpStatusRequestCombinator(
+    Mapped {
+        inner: (spec_responder_id_list(), spec_ocsp_extensions()),
+        mapper: OscpStatusRequestMapper,
+    })
 }
 
                 
-pub fn key_update_request<'a>() -> (o: KeyUpdateRequestCombinator)
-    ensures o@ == spec_key_update_request(),
+pub fn oscp_status_request<'a>() -> (o: OscpStatusRequestCombinator)
+    ensures o@ == spec_oscp_status_request(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = KeyUpdateRequestCombinator(TryMap { inner: U8, mapper: KeyUpdateRequestMapper });
-    assert({
-        &&& combinator@ == spec_key_update_request()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = OscpStatusRequestCombinator(
+    Mapped {
+        inner: OscpStatusRequestCombinator1((responder_id_list(), ocsp_extensions())),
+        mapper: OscpStatusRequestMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_oscp_status_request()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_key_update_request<'a>(input: &'a [u8]) -> (res: PResult<<KeyUpdateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_oscp_status_request<'a>(input: &'a [u8]) -> (res: PResult<<OscpStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_key_update_request().spec_parse(input@) == Some((n as int, v@)),
-        spec_key_update_request().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_oscp_status_request().spec_parse(input@) == Some((n as int, v@)),
+        spec_oscp_status_request().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_key_update_request().spec_parse(input@) is None,
-        spec_key_update_request().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_oscp_status_request().spec_parse(input@) is None,
+        spec_oscp_status_request().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = key_update_request();
+    let combinator = oscp_status_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_key_update_request<'a>(v: <KeyUpdateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_oscp_status_request<'a>(v: <OscpStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_key_update_request().wf(v@),
+        spec_oscp_status_request().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_key_update_request().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_key_update_request().spec_serialize(v@))
+            &&& n == spec_oscp_status_request().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_oscp_status_request().spec_serialize(v@))
         },
 {
-    let combinator = key_update_request();
+    let combinator = oscp_status_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn key_update_request_len<'a>(v: <KeyUpdateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn oscp_status_request_len<'a>(v: <OscpStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_key_update_request().wf(v@),
-        spec_key_update_request().spec_serialize(v@).len() <= usize::MAX,
+        spec_oscp_status_request().wf(v@),
+        spec_oscp_status_request().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_key_update_request().spec_serialize(v@).len(),
+        serialize_len == spec_oscp_status_request().spec_serialize(v@).len(),
 {
-    let combinator = key_update_request();
+    let combinator = oscp_status_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecKeyUpdate {
-    pub request_update: SpecKeyUpdateRequest,
+pub struct SpecCertificateStatusRequest {
+    pub status_type: u8,
+    pub request: SpecOscpStatusRequest,
 }
 
-pub type SpecKeyUpdateInner = SpecKeyUpdateRequest;
+pub type SpecCertificateStatusRequestInner = (u8, SpecOscpStatusRequest);
 
 
-impl SpecFrom<SpecKeyUpdate> for SpecKeyUpdateInner {
-    open spec fn spec_from(m: SpecKeyUpdate) -> SpecKeyUpdateInner {
-        m.request_update
+impl SpecFrom<SpecCertificateStatusRequest> for SpecCertificateStatusRequestInner {
+    open spec fn spec_from(m: SpecCertificateStatusRequest) -> SpecCertificateStatusRequestInner {
+        (m.status_type, m.request)
     }
 }
 
-impl SpecFrom<SpecKeyUpdateInner> for SpecKeyUpdate {
-    open spec fn spec_from(m: SpecKeyUpdateInner) -> SpecKeyUpdate {
-        let request_update = m;
-        SpecKeyUpdate { request_update }
+impl SpecFrom<SpecCertificateStatusRequestInner> for SpecCertificateStatusRequest {
+    open spec fn spec_from(m: SpecCertificateStatusRequestInner) -> SpecCertificateStatusRequest {
+        let (status_type, request) = m;
+        SpecCertificateStatusRequest { status_type, request }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct KeyUpdate {
-    pub request_update: KeyUpdateRequest,
+pub struct CertificateStatusRequest<'a> {
+    pub status_type: u8,
+    pub request: OscpStatusRequest<'a>,
 }
 
-impl View for KeyUpdate {
-    type V = SpecKeyUpdate;
+impl View for CertificateStatusRequest<'_> {
+    type V = SpecCertificateStatusRequest;
 
     open spec fn view(&self) -> Self::V {
-        SpecKeyUpdate {
-            request_update: self.request_update@,
+        SpecCertificateStatusRequest {
+            status_type: self.status_type@,
+            request: self.request@,
         }
     }
 }
-pub type KeyUpdateInner = KeyUpdateRequest;
+pub type CertificateStatusRequestInner<'a> = (u8, OscpStatusRequest<'a>);
 
-pub type KeyUpdateInnerRef<'a> = &'a KeyUpdateRequest;
-impl<'a> From<&'a KeyUpdate> for KeyUpdateInnerRef<'a> {
-    fn ex_from(m: &'a KeyUpdate) -> KeyUpdateInnerRef<'a> {
-        &m.request_update
-    }
+pub type CertificateStatusRequestInnerRef<'a> = (&'a u8, &'a OscpStatusRequest<'a>);
+impl<'a> From<&'a CertificateStatusRequest<'a>> for CertificateStatusRequestInnerRef<'a> {
+    fn ex_from(m: &'a CertificateStatusRequest) -> CertificateStatusRequestInnerRef<'a> {
+        (&m.status_type, &m.request)
+    }
 }
 
-impl From<KeyUpdateInner> for KeyUpdate {
-    fn ex_from(m: KeyUpdateInner) -> KeyUpdate {
-        let request_update = m;
-        KeyUpdate { request_update }
+impl<'a> From<CertificateStatusRequestInner<'a>> for CertificateStatusRequest<'a> {
+    fn ex_from(m: CertificateStatusRequestInner) -> CertificateStatusRequest {
+        let (status_type, request) = m;
+        CertificateStatusRequest { status_type, request }
     }
 }
 
-pub struct KeyUpdateMapper;
-impl View for KeyUpdateMapper {
+pub struct CertificateStatusRequestMapper;
+impl View for CertificateStatusRequestMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for KeyUpdateMapper {
-    type Src = SpecKeyUpdateInner;
-    type Dst = SpecKeyUpdate;
+impl SpecIso for CertificateStatusRequestMapper {
+    type Src = SpecCertificateStatusRequestInner;
+    type Dst = SpecCertificateStatusRequest;
 }
-impl SpecIsoProof for KeyUpdateMapper {
+impl SpecIsoProof for CertificateStatusRequestMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -2878,461 +2626,325 @@ impl SpecIsoProof for KeyUpdateMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for KeyUpdateMapper {
-    type Src = KeyUpdateInner;
-    type Dst = KeyUpdate;
-    type RefSrc = KeyUpdateInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateStatusRequestMapper {
+    type Src = CertificateStatusRequestInner<'a>;
+    type Dst = CertificateStatusRequest<'a>;
+    type RefSrc = CertificateStatusRequestInnerRef<'a>;
 }
+pub const CERTIFICATESTATUSREQUESTSTATUS_TYPE_CONST: u8 = 1;
+type SpecCertificateStatusRequestCombinatorAlias1 = (Refined<U8, TagPred<u8>>, SpecOscpStatusRequestCombinator);
+pub struct SpecCertificateStatusRequestCombinator(pub SpecCertificateStatusRequestCombinatorAlias);
 
-pub struct SpecKeyUpdateCombinator(pub SpecKeyUpdateCombinatorAlias);
-
-impl SpecCombinator for SpecKeyUpdateCombinator {
-    type Type = SpecKeyUpdate;
+impl SpecCombinator for SpecCertificateStatusRequestCombinator {
+    type Type = SpecCertificateStatusRequest;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecKeyUpdateCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecKeyUpdateCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateStatusRequestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateStatusRequestCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecKeyUpdateCombinatorAlias = Mapped<SpecKeyUpdateRequestCombinator, KeyUpdateMapper>;
+pub type SpecCertificateStatusRequestCombinatorAlias = Mapped<SpecCertificateStatusRequestCombinatorAlias1, CertificateStatusRequestMapper>;
+type CertificateStatusRequestCombinatorAlias1 = (Refined<U8, TagPred<u8>>, OscpStatusRequestCombinator);
+pub struct CertificateStatusRequestCombinator1(pub CertificateStatusRequestCombinatorAlias1);
+impl View for CertificateStatusRequestCombinator1 {
+    type V = SpecCertificateStatusRequestCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateStatusRequestCombinator1, CertificateStatusRequestCombinatorAlias1);
 
-pub struct KeyUpdateCombinator(pub KeyUpdateCombinatorAlias);
+pub struct CertificateStatusRequestCombinator(pub CertificateStatusRequestCombinatorAlias);
 
-impl View for KeyUpdateCombinator {
-    type V = SpecKeyUpdateCombinator;
-    open spec fn view(&self) -> Self::V { SpecKeyUpdateCombinator(self.0@) }
+impl View for CertificateStatusRequestCombinator {
+    type V = SpecCertificateStatusRequestCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateStatusRequestCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for KeyUpdateCombinator {
-    type Type = KeyUpdate;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateStatusRequestCombinator {
+    type Type = CertificateStatusRequest<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type KeyUpdateCombinatorAlias = Mapped<KeyUpdateRequestCombinator, KeyUpdateMapper>;
+}
+pub type CertificateStatusRequestCombinatorAlias = Mapped<CertificateStatusRequestCombinator1, CertificateStatusRequestMapper>;
 
 
-pub open spec fn spec_key_update() -> SpecKeyUpdateCombinator {
-    SpecKeyUpdateCombinator(
+pub open spec fn spec_certificate_status_request() -> SpecCertificateStatusRequestCombinator {
+    SpecCertificateStatusRequestCombinator(
     Mapped {
-        inner: spec_key_update_request(),
-        mapper: KeyUpdateMapper,
+        inner: (Refined { inner: U8, predicate: TagPred(CERTIFICATESTATUSREQUESTSTATUS_TYPE_CONST) }, spec_oscp_status_request()),
+        mapper: CertificateStatusRequestMapper,
     })
 }
 
                 
-pub fn key_update<'a>() -> (o: KeyUpdateCombinator)
-    ensures o@ == spec_key_update(),
+pub fn certificate_status_request<'a>() -> (o: CertificateStatusRequestCombinator)
+    ensures o@ == spec_certificate_status_request(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = KeyUpdateCombinator(
+    let combinator = CertificateStatusRequestCombinator(
     Mapped {
-        inner: key_update_request(),
-        mapper: KeyUpdateMapper,
-    });
-    assert({
-        &&& combinator@ == spec_key_update()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: CertificateStatusRequestCombinator1((Refined { inner: U8, predicate: TagPred(CERTIFICATESTATUSREQUESTSTATUS_TYPE_CONST) }, oscp_status_request())),
+        mapper: CertificateStatusRequestMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_status_request()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_key_update<'a>(input: &'a [u8]) -> (res: PResult<<KeyUpdateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_status_request<'a>(input: &'a [u8]) -> (res: PResult<<CertificateStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_key_update().spec_parse(input@) == Some((n as int, v@)),
-        spec_key_update().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_status_request().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_status_request().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_key_update().spec_parse(input@) is None,
-        spec_key_update().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_status_request().spec_parse(input@) is None,
+        spec_certificate_status_request().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = key_update();
+    let combinator = certificate_status_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_key_update<'a>(v: <KeyUpdateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_status_request<'a>(v: <CertificateStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_key_update().wf(v@),
+        spec_certificate_status_request().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_key_update().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_key_update().spec_serialize(v@))
+            &&& n == spec_certificate_status_request().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_status_request().spec_serialize(v@))
         },
 {
-    let combinator = key_update();
+    let combinator = certificate_status_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn key_update_len<'a>(v: <KeyUpdateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_status_request_len<'a>(v: <CertificateStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_key_update().wf(v@),
-        spec_key_update().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_status_request().wf(v@),
+        spec_certificate_status_request().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_key_update().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_status_request().spec_serialize(v@).len(),
 {
-    let combinator = key_update();
+    let combinator = certificate_status_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
+pub type SpecSerializedSct = SpecOpaque1Ffff;
+pub type SerializedSct<'a> = Opaque1Ffff<'a>;
+pub type SerializedSctRef<'a> = &'a Opaque1Ffff<'a>;
 
-pub struct SpecOpaque1Ffffff {
-    pub l: u24,
-    pub data: Seq<u8>,
-}
-
-pub type SpecOpaque1FfffffInner = (u24, Seq<u8>);
-
-
-impl SpecFrom<SpecOpaque1Ffffff> for SpecOpaque1FfffffInner {
-    open spec fn spec_from(m: SpecOpaque1Ffffff) -> SpecOpaque1FfffffInner {
-        (m.l, m.data)
-    }
-}
-
-impl SpecFrom<SpecOpaque1FfffffInner> for SpecOpaque1Ffffff {
-    open spec fn spec_from(m: SpecOpaque1FfffffInner) -> SpecOpaque1Ffffff {
-        let (l, data) = m;
-        SpecOpaque1Ffffff { l, data }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct Opaque1Ffffff<'a> {
-    pub l: u24,
-    pub data: &'a [u8],
-}
-
-impl View for Opaque1Ffffff<'_> {
-    type V = SpecOpaque1Ffffff;
-
-    open spec fn view(&self) -> Self::V {
-        SpecOpaque1Ffffff {
-            l: self.l@,
-            data: self.data@,
-        }
-    }
-}
-pub type Opaque1FfffffInner<'a> = (u24, &'a [u8]);
-
-pub type Opaque1FfffffInnerRef<'a> = (&'a u24, &'a &'a [u8]);
-impl<'a> From<&'a Opaque1Ffffff<'a>> for Opaque1FfffffInnerRef<'a> {
-    fn ex_from(m: &'a Opaque1Ffffff) -> Opaque1FfffffInnerRef<'a> {
-        (&m.l, &m.data)
-    }
-}
-
-impl<'a> From<Opaque1FfffffInner<'a>> for Opaque1Ffffff<'a> {
-    fn ex_from(m: Opaque1FfffffInner) -> Opaque1Ffffff {
-        let (l, data) = m;
-        Opaque1Ffffff { l, data }
-    }
-}
-
-pub struct Opaque1FfffffMapper;
-impl View for Opaque1FfffffMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for Opaque1FfffffMapper {
-    type Src = SpecOpaque1FfffffInner;
-    type Dst = SpecOpaque1Ffffff;
-}
-impl SpecIsoProof for Opaque1FfffffMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for Opaque1FfffffMapper {
-    type Src = Opaque1FfffffInner<'a>;
-    type Dst = Opaque1Ffffff<'a>;
-    type RefSrc = Opaque1FfffffInnerRef<'a>;
-}
 
-pub struct SpecOpaque1FfffffCombinator(pub SpecOpaque1FfffffCombinatorAlias);
+pub struct SpecSerializedSctCombinator(pub SpecSerializedSctCombinatorAlias);
 
-impl SpecCombinator for SpecOpaque1FfffffCombinator {
-    type Type = SpecOpaque1Ffffff;
+impl SpecCombinator for SpecSerializedSctCombinator {
+    type Type = SpecSerializedSct;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOpaque1FfffffCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOpaque1FfffffCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSerializedSctCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSerializedSctCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOpaque1FfffffCombinatorAlias = Mapped<SpecPair<Refined<U24Be, Predicate15036445817960576151>, bytes::Variable>, Opaque1FfffffMapper>;
-pub struct Predicate15036445817960576151;
-impl View for Predicate15036445817960576151 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u24> for Predicate15036445817960576151 {
-    fn apply(&self, i: &u24) -> bool {
-        let i = (*i).as_u32();
-        (i >= 1 && i <= 16777215)
-    }
-}
-impl SpecPred<u24> for Predicate15036445817960576151 {
-    open spec fn spec_apply(&self, i: &u24) -> bool {
-        let i = (*i).spec_as_u32();
-        (i >= 1 && i <= 16777215)
-    }
-}
+pub type SpecSerializedSctCombinatorAlias = SpecOpaque1FfffCombinator;
 
-pub struct Opaque1FfffffCombinator(pub Opaque1FfffffCombinatorAlias);
+pub struct SerializedSctCombinator(pub SerializedSctCombinatorAlias);
 
-impl View for Opaque1FfffffCombinator {
-    type V = SpecOpaque1FfffffCombinator;
-    open spec fn view(&self) -> Self::V { SpecOpaque1FfffffCombinator(self.0@) }
+impl View for SerializedSctCombinator {
+    type V = SpecSerializedSctCombinator;
+    open spec fn view(&self) -> Self::V { SpecSerializedSctCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque1FfffffCombinator {
-    type Type = Opaque1Ffffff<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SerializedSctCombinator {
+    type Type = SerializedSct<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type Opaque1FfffffCombinatorAlias = Mapped<Pair<Refined<U24Be, Predicate15036445817960576151>, bytes::Variable, Opaque1FfffffCont0>, Opaque1FfffffMapper>;
+}
+pub type SerializedSctCombinatorAlias = Opaque1FfffCombinator;
 
 
-pub open spec fn spec_opaque_1_ffffff() -> SpecOpaque1FfffffCombinator {
-    SpecOpaque1FfffffCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U24Be, predicate: Predicate15036445817960576151 }, |deps| spec_opaque1_ffffff_cont0(deps)),
-        mapper: Opaque1FfffffMapper,
-    })
-}
-
-pub open spec fn spec_opaque1_ffffff_cont0(deps: u24) -> bytes::Variable {
-    let l = deps;
-    bytes::Variable(l.spec_into())
-}
-
-impl View for Opaque1FfffffCont0 {
-    type V = spec_fn(u24) -> bytes::Variable;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u24| {
-            spec_opaque1_ffffff_cont0(deps)
-        }
-    }
+pub open spec fn spec_serialized_sct() -> SpecSerializedSctCombinator {
+    SpecSerializedSctCombinator(spec_opaque_1_ffff())
 }
 
                 
-pub fn opaque_1_ffffff<'a>() -> (o: Opaque1FfffffCombinator)
-    ensures o@ == spec_opaque_1_ffffff(),
+pub fn serialized_sct<'a>() -> (o: SerializedSctCombinator)
+    ensures o@ == spec_serialized_sct(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = Opaque1FfffffCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U24Be, predicate: Predicate15036445817960576151 }, Opaque1FfffffCont0),
-        mapper: Opaque1FfffffMapper,
-    });
-    assert({
-        &&& combinator@ == spec_opaque_1_ffffff()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = SerializedSctCombinator(opaque_1_ffff());
+    // assert({
+    //     &&& combinator@ == spec_serialized_sct()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_opaque_1_ffffff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque1FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_serialized_sct<'a>(input: &'a [u8]) -> (res: PResult<<SerializedSctCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_opaque_1_ffffff().spec_parse(input@) == Some((n as int, v@)),
-        spec_opaque_1_ffffff().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_serialized_sct().spec_parse(input@) == Some((n as int, v@)),
+        spec_serialized_sct().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_opaque_1_ffffff().spec_parse(input@) is None,
-        spec_opaque_1_ffffff().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_serialized_sct().spec_parse(input@) is None,
+        spec_serialized_sct().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = opaque_1_ffffff();
+    let combinator = serialized_sct();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_opaque_1_ffffff<'a>(v: <Opaque1FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_serialized_sct<'a>(v: <SerializedSctCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_opaque_1_ffffff().wf(v@),
+        spec_serialized_sct().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_opaque_1_ffffff().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_1_ffffff().spec_serialize(v@))
+            &&& n == spec_serialized_sct().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_serialized_sct().spec_serialize(v@))
         },
 {
-    let combinator = opaque_1_ffffff();
+    let combinator = serialized_sct();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn opaque_1_ffffff_len<'a>(v: <Opaque1FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn serialized_sct_len<'a>(v: <SerializedSctCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_opaque_1_ffffff().wf(v@),
-        spec_opaque_1_ffffff().spec_serialize(v@).len() <= usize::MAX,
+        spec_serialized_sct().wf(v@),
+        spec_serialized_sct().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_opaque_1_ffffff().spec_serialize(v@).len(),
+        serialize_len == spec_serialized_sct().spec_serialize(v@).len(),
 {
-    let combinator = opaque_1_ffffff();
+    let combinator = serialized_sct();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct Opaque1FfffffCont0;
-type Opaque1FfffffCont0Type<'a, 'b> = &'b u24;
-type Opaque1FfffffCont0SType<'a, 'x> = &'x u24;
-type Opaque1FfffffCont0Input<'a, 'b, 'x> = POrSType<Opaque1FfffffCont0Type<'a, 'b>, Opaque1FfffffCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<Opaque1FfffffCont0Input<'a, 'b, 'x>> for Opaque1FfffffCont0 {
-    type Output = bytes::Variable;
-
-    open spec fn requires(&self, deps: Opaque1FfffffCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: Opaque1FfffffCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_opaque1_ffffff_cont0(deps@)
-    }
-
-    fn apply(&self, deps: Opaque1FfffffCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                bytes::Variable(l.ex_into())
-            }
-        }
-    }
-}
                 
 
-pub struct SpecPskIdentity {
-    pub identity: SpecOpaque1Ffff,
-    pub obfuscated_ticket_age: u32,
+pub struct SpecSignedCertificateTimestampList {
+    pub l: u16,
+    pub list: Seq<SpecSerializedSct>,
 }
 
-pub type SpecPskIdentityInner = (SpecOpaque1Ffff, u32);
+pub type SpecSignedCertificateTimestampListInner = (u16, Seq<SpecSerializedSct>);
 
 
-impl SpecFrom<SpecPskIdentity> for SpecPskIdentityInner {
-    open spec fn spec_from(m: SpecPskIdentity) -> SpecPskIdentityInner {
-        (m.identity, m.obfuscated_ticket_age)
+impl SpecFrom<SpecSignedCertificateTimestampList> for SpecSignedCertificateTimestampListInner {
+    open spec fn spec_from(m: SpecSignedCertificateTimestampList) -> SpecSignedCertificateTimestampListInner {
+        (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecPskIdentityInner> for SpecPskIdentity {
-    open spec fn spec_from(m: SpecPskIdentityInner) -> SpecPskIdentity {
-        let (identity, obfuscated_ticket_age) = m;
-        SpecPskIdentity { identity, obfuscated_ticket_age }
+impl SpecFrom<SpecSignedCertificateTimestampListInner> for SpecSignedCertificateTimestampList {
+    open spec fn spec_from(m: SpecSignedCertificateTimestampListInner) -> SpecSignedCertificateTimestampList {
+        let (l, list) = m;
+        SpecSignedCertificateTimestampList { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct PskIdentity<'a> {
-    pub identity: Opaque1Ffff<'a>,
-    pub obfuscated_ticket_age: u32,
+pub struct SignedCertificateTimestampList<'a> {
+    pub l: u16,
+    pub list: RepeatResult<SerializedSct<'a>>,
 }
 
-impl View for PskIdentity<'_> {
-    type V = SpecPskIdentity;
+impl View for SignedCertificateTimestampList<'_> {
+    type V = SpecSignedCertificateTimestampList;
 
     open spec fn view(&self) -> Self::V {
-        SpecPskIdentity {
-            identity: self.identity@,
-            obfuscated_ticket_age: self.obfuscated_ticket_age@,
+        SpecSignedCertificateTimestampList {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
-pub type PskIdentityInner<'a> = (Opaque1Ffff<'a>, u32);
+pub type SignedCertificateTimestampListInner<'a> = (u16, RepeatResult<SerializedSct<'a>>);
 
-pub type PskIdentityInnerRef<'a> = (&'a Opaque1Ffff<'a>, &'a u32);
-impl<'a> From<&'a PskIdentity<'a>> for PskIdentityInnerRef<'a> {
-    fn ex_from(m: &'a PskIdentity) -> PskIdentityInnerRef<'a> {
-        (&m.identity, &m.obfuscated_ticket_age)
+pub type SignedCertificateTimestampListInnerRef<'a> = (&'a u16, &'a RepeatResult<SerializedSct<'a>>);
+impl<'a> From<&'a SignedCertificateTimestampList<'a>> for SignedCertificateTimestampListInnerRef<'a> {
+    fn ex_from(m: &'a SignedCertificateTimestampList) -> SignedCertificateTimestampListInnerRef<'a> {
+        (&m.l, &m.list)
     }
 }
 
-impl<'a> From<PskIdentityInner<'a>> for PskIdentity<'a> {
-    fn ex_from(m: PskIdentityInner) -> PskIdentity {
-        let (identity, obfuscated_ticket_age) = m;
-        PskIdentity { identity, obfuscated_ticket_age }
+impl<'a> From<SignedCertificateTimestampListInner<'a>> for SignedCertificateTimestampList<'a> {
+    fn ex_from(m: SignedCertificateTimestampListInner) -> SignedCertificateTimestampList {
+        let (l, list) = m;
+        SignedCertificateTimestampList { l, list }
     }
 }
 
-pub struct PskIdentityMapper;
-impl View for PskIdentityMapper {
+pub struct SignedCertificateTimestampListMapper;
+impl View for SignedCertificateTimestampListMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for PskIdentityMapper {
-    type Src = SpecPskIdentityInner;
-    type Dst = SpecPskIdentity;
+impl SpecIso for SignedCertificateTimestampListMapper {
+    type Src = SpecSignedCertificateTimestampListInner;
+    type Dst = SpecSignedCertificateTimestampList;
 }
-impl SpecIsoProof for PskIdentityMapper {
+impl SpecIsoProof for SignedCertificateTimestampListMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -3340,206 +2952,265 @@ impl SpecIsoProof for PskIdentityMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for PskIdentityMapper {
-    type Src = PskIdentityInner<'a>;
-    type Dst = PskIdentity<'a>;
-    type RefSrc = PskIdentityInnerRef<'a>;
+impl<'a> Iso<'a> for SignedCertificateTimestampListMapper {
+    type Src = SignedCertificateTimestampListInner<'a>;
+    type Dst = SignedCertificateTimestampList<'a>;
+    type RefSrc = SignedCertificateTimestampListInnerRef<'a>;
 }
-type SpecPskIdentityCombinatorAlias1 = (SpecOpaque1FfffCombinator, U32Be);
-pub struct SpecPskIdentityCombinator(pub SpecPskIdentityCombinatorAlias);
 
-impl SpecCombinator for SpecPskIdentityCombinator {
-    type Type = SpecPskIdentity;
+pub struct SpecSignedCertificateTimestampListCombinator(pub SpecSignedCertificateTimestampListCombinatorAlias);
+
+impl SpecCombinator for SpecSignedCertificateTimestampListCombinator {
+    type Type = SpecSignedCertificateTimestampList;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecPskIdentityCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecPskIdentityCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSignedCertificateTimestampListCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSignedCertificateTimestampListCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecPskIdentityCombinatorAlias = Mapped<SpecPskIdentityCombinatorAlias1, PskIdentityMapper>;
-type PskIdentityCombinatorAlias1 = (Opaque1FfffCombinator, U32Be);
-pub struct PskIdentityCombinator1(pub PskIdentityCombinatorAlias1);
-impl View for PskIdentityCombinator1 {
-    type V = SpecPskIdentityCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
+pub type SpecSignedCertificateTimestampListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate16977634203518580913>, AndThen<bytes::Variable, Repeat<SpecSerializedSctCombinator>>>, SignedCertificateTimestampListMapper>;
+pub struct Predicate16977634203518580913;
+impl View for Predicate16977634203518580913 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate16977634203518580913 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 1 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate16977634203518580913 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 1 && i <= 65535)
+    }
 }
-impl_wrapper_combinator!(PskIdentityCombinator1, PskIdentityCombinatorAlias1);
 
-pub struct PskIdentityCombinator(pub PskIdentityCombinatorAlias);
+pub struct SignedCertificateTimestampListCombinator(pub SignedCertificateTimestampListCombinatorAlias);
 
-impl View for PskIdentityCombinator {
-    type V = SpecPskIdentityCombinator;
-    open spec fn view(&self) -> Self::V { SpecPskIdentityCombinator(self.0@) }
+impl View for SignedCertificateTimestampListCombinator {
+    type V = SpecSignedCertificateTimestampListCombinator;
+    open spec fn view(&self) -> Self::V { SpecSignedCertificateTimestampListCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskIdentityCombinator {
-    type Type = PskIdentity<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SignedCertificateTimestampListCombinator {
+    type Type = SignedCertificateTimestampList<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type PskIdentityCombinatorAlias = Mapped<PskIdentityCombinator1, PskIdentityMapper>;
+}
+pub type SignedCertificateTimestampListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate16977634203518580913>, AndThen<bytes::Variable, Repeat<SerializedSctCombinator>>, SignedCertificateTimestampListCont0>, SignedCertificateTimestampListMapper>;
 
 
-pub open spec fn spec_psk_identity() -> SpecPskIdentityCombinator {
-    SpecPskIdentityCombinator(
+pub open spec fn spec_signed_certificate_timestamp_list() -> SpecSignedCertificateTimestampListCombinator {
+    SpecSignedCertificateTimestampListCombinator(
     Mapped {
-        inner: (spec_opaque_1_ffff(), U32Be),
-        mapper: PskIdentityMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate16977634203518580913 }, |deps| spec_signed_certificate_timestamp_list_cont0(deps)),
+        mapper: SignedCertificateTimestampListMapper,
     })
 }
 
+pub open spec fn spec_signed_certificate_timestamp_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecSerializedSctCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_serialized_sct()))
+}
+
+impl View for SignedCertificateTimestampListCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecSerializedSctCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_signed_certificate_timestamp_list_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn psk_identity<'a>() -> (o: PskIdentityCombinator)
-    ensures o@ == spec_psk_identity(),
+pub fn signed_certificate_timestamp_list<'a>() -> (o: SignedCertificateTimestampListCombinator)
+    ensures o@ == spec_signed_certificate_timestamp_list(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = PskIdentityCombinator(
+    let combinator = SignedCertificateTimestampListCombinator(
     Mapped {
-        inner: PskIdentityCombinator1((opaque_1_ffff(), U32Be)),
-        mapper: PskIdentityMapper,
-    });
-    assert({
-        &&& combinator@ == spec_psk_identity()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate16977634203518580913 }, SignedCertificateTimestampListCont0),
+        mapper: SignedCertificateTimestampListMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_signed_certificate_timestamp_list()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_psk_identity<'a>(input: &'a [u8]) -> (res: PResult<<PskIdentityCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_signed_certificate_timestamp_list<'a>(input: &'a [u8]) -> (res: PResult<<SignedCertificateTimestampListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_psk_identity().spec_parse(input@) == Some((n as int, v@)),
-        spec_psk_identity().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_signed_certificate_timestamp_list().spec_parse(input@) == Some((n as int, v@)),
+        spec_signed_certificate_timestamp_list().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_psk_identity().spec_parse(input@) is None,
-        spec_psk_identity().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_signed_certificate_timestamp_list().spec_parse(input@) is None,
+        spec_signed_certificate_timestamp_list().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = psk_identity();
+    let combinator = signed_certificate_timestamp_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_psk_identity<'a>(v: <PskIdentityCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_signed_certificate_timestamp_list<'a>(v: <SignedCertificateTimestampListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_psk_identity().wf(v@),
+        spec_signed_certificate_timestamp_list().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_psk_identity().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_psk_identity().spec_serialize(v@))
+            &&& n == spec_signed_certificate_timestamp_list().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_signed_certificate_timestamp_list().spec_serialize(v@))
         },
 {
-    let combinator = psk_identity();
+    let combinator = signed_certificate_timestamp_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn psk_identity_len<'a>(v: <PskIdentityCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn signed_certificate_timestamp_list_len<'a>(v: <SignedCertificateTimestampListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_psk_identity().wf(v@),
-        spec_psk_identity().spec_serialize(v@).len() <= usize::MAX,
+        spec_signed_certificate_timestamp_list().wf(v@),
+        spec_signed_certificate_timestamp_list().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_psk_identity().spec_serialize(v@).len(),
+        serialize_len == spec_signed_certificate_timestamp_list().spec_serialize(v@).len(),
 {
-    let combinator = psk_identity();
+    let combinator = signed_certificate_timestamp_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct SignedCertificateTimestampListCont0;
+type SignedCertificateTimestampListCont0Type<'a, 'b> = &'b u16;
+type SignedCertificateTimestampListCont0SType<'a, 'x> = &'x u16;
+type SignedCertificateTimestampListCont0Input<'a, 'b, 'x> = POrSType<SignedCertificateTimestampListCont0Type<'a, 'b>, SignedCertificateTimestampListCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<SignedCertificateTimestampListCont0Input<'a, 'b, 'x>> for SignedCertificateTimestampListCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<SerializedSctCombinator>>;
+
+    open spec fn requires(&self, deps: SignedCertificateTimestampListCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate16977634203518580913 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: SignedCertificateTimestampListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_signed_certificate_timestamp_list_cont0(deps@)
+    }
+
+    fn apply(&self, deps: SignedCertificateTimestampListCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(serialized_sct()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(serialized_sct()))
+            }
+        }
+    }
+}
                 
 
-pub struct SpecPskIdentities {
-    pub l: u16,
-    pub list: Seq<SpecPskIdentity>,
+pub struct SpecOpaque1Ff {
+    pub l: u8,
+    pub data: Seq<u8>,
 }
 
-pub type SpecPskIdentitiesInner = (u16, Seq<SpecPskIdentity>);
+pub type SpecOpaque1FfInner = (u8, Seq<u8>);
 
 
-impl SpecFrom<SpecPskIdentities> for SpecPskIdentitiesInner {
-    open spec fn spec_from(m: SpecPskIdentities) -> SpecPskIdentitiesInner {
-        (m.l, m.list)
+impl SpecFrom<SpecOpaque1Ff> for SpecOpaque1FfInner {
+    open spec fn spec_from(m: SpecOpaque1Ff) -> SpecOpaque1FfInner {
+        (m.l, m.data)
     }
 }
 
-impl SpecFrom<SpecPskIdentitiesInner> for SpecPskIdentities {
-    open spec fn spec_from(m: SpecPskIdentitiesInner) -> SpecPskIdentities {
-        let (l, list) = m;
-        SpecPskIdentities { l, list }
+impl SpecFrom<SpecOpaque1FfInner> for SpecOpaque1Ff {
+    open spec fn spec_from(m: SpecOpaque1FfInner) -> SpecOpaque1Ff {
+        let (l, data) = m;
+        SpecOpaque1Ff { l, data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct PskIdentities<'a> {
-    pub l: u16,
-    pub list: RepeatResult<PskIdentity<'a>>,
+pub struct Opaque1Ff<'a> {
+    pub l: u8,
+    pub data: &'a [u8],
 }
 
-impl View for PskIdentities<'_> {
-    type V = SpecPskIdentities;
+impl View for Opaque1Ff<'_> {
+    type V = SpecOpaque1Ff;
 
     open spec fn view(&self) -> Self::V {
-        SpecPskIdentities {
+        SpecOpaque1Ff {
             l: self.l@,
-            list: self.list@,
+            data: self.data@,
         }
     }
 }
-pub type PskIdentitiesInner<'a> = (u16, RepeatResult<PskIdentity<'a>>);
+pub type Opaque1FfInner<'a> = (u8, &'a [u8]);
 
-pub type PskIdentitiesInnerRef<'a> = (&'a u16, &'a RepeatResult<PskIdentity<'a>>);
-impl<'a> From<&'a PskIdentities<'a>> for PskIdentitiesInnerRef<'a> {
-    fn ex_from(m: &'a PskIdentities) -> PskIdentitiesInnerRef<'a> {
-        (&m.l, &m.list)
+pub type Opaque1FfInnerRef<'a> = (&'a u8, &'a &'a [u8]);
+impl<'a> From<&'a Opaque1Ff<'a>> for Opaque1FfInnerRef<'a> {
+    fn ex_from(m: &'a Opaque1Ff) -> Opaque1FfInnerRef<'a> {
+        (&m.l, &m.data)
     }
 }
 
-impl<'a> From<PskIdentitiesInner<'a>> for PskIdentities<'a> {
-    fn ex_from(m: PskIdentitiesInner) -> PskIdentities {
-        let (l, list) = m;
-        PskIdentities { l, list }
+impl<'a> From<Opaque1FfInner<'a>> for Opaque1Ff<'a> {
+    fn ex_from(m: Opaque1FfInner) -> Opaque1Ff {
+        let (l, data) = m;
+        Opaque1Ff { l, data }
     }
 }
 
-pub struct PskIdentitiesMapper;
-impl View for PskIdentitiesMapper {
+pub struct Opaque1FfMapper;
+impl View for Opaque1FfMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for PskIdentitiesMapper {
-    type Src = SpecPskIdentitiesInner;
-    type Dst = SpecPskIdentities;
+impl SpecIso for Opaque1FfMapper {
+    type Src = SpecOpaque1FfInner;
+    type Dst = SpecOpaque1Ff;
 }
-impl SpecIsoProof for PskIdentitiesMapper {
+impl SpecIsoProof for Opaque1FfMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -3547,258 +3218,265 @@ impl SpecIsoProof for PskIdentitiesMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for PskIdentitiesMapper {
-    type Src = PskIdentitiesInner<'a>;
-    type Dst = PskIdentities<'a>;
-    type RefSrc = PskIdentitiesInnerRef<'a>;
+impl<'a> Iso<'a> for Opaque1FfMapper {
+    type Src = Opaque1FfInner<'a>;
+    type Dst = Opaque1Ff<'a>;
+    type RefSrc = Opaque1FfInnerRef<'a>;
 }
 
-pub struct SpecPskIdentitiesCombinator(pub SpecPskIdentitiesCombinatorAlias);
+pub struct SpecOpaque1FfCombinator(pub SpecOpaque1FfCombinatorAlias);
 
-impl SpecCombinator for SpecPskIdentitiesCombinator {
-    type Type = SpecPskIdentities;
+impl SpecCombinator for SpecOpaque1FfCombinator {
+    type Type = SpecOpaque1Ff;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecPskIdentitiesCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecPskIdentitiesCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOpaque1FfCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOpaque1FfCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecPskIdentitiesCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate22012019403780218>, AndThen<bytes::Variable, Repeat<SpecPskIdentityCombinator>>>, PskIdentitiesMapper>;
-pub struct Predicate22012019403780218;
-impl View for Predicate22012019403780218 {
+pub type SpecOpaque1FfCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate3651688686135228051>, bytes::Variable>, Opaque1FfMapper>;
+pub struct Predicate3651688686135228051;
+impl View for Predicate3651688686135228051 {
     type V = Self;
 
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl Pred<u16> for Predicate22012019403780218 {
-    fn apply(&self, i: &u16) -> bool {
+impl Pred<u8> for Predicate3651688686135228051 {
+    fn apply(&self, i: &u8) -> bool {
         let i = (*i);
-        (i >= 7 && i <= 65535)
+        (i >= 1 && i <= 255)
     }
 }
-impl SpecPred<u16> for Predicate22012019403780218 {
-    open spec fn spec_apply(&self, i: &u16) -> bool {
+impl SpecPred<u8> for Predicate3651688686135228051 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
         let i = (*i);
-        (i >= 7 && i <= 65535)
+        (i >= 1 && i <= 255)
     }
 }
 
-pub struct PskIdentitiesCombinator(pub PskIdentitiesCombinatorAlias);
+pub struct Opaque1FfCombinator(pub Opaque1FfCombinatorAlias);
 
-impl View for PskIdentitiesCombinator {
-    type V = SpecPskIdentitiesCombinator;
-    open spec fn view(&self) -> Self::V { SpecPskIdentitiesCombinator(self.0@) }
+impl View for Opaque1FfCombinator {
+    type V = SpecOpaque1FfCombinator;
+    open spec fn view(&self) -> Self::V { SpecOpaque1FfCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskIdentitiesCombinator {
-    type Type = PskIdentities<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque1FfCombinator {
+    type Type = Opaque1Ff<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type PskIdentitiesCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate22012019403780218>, AndThen<bytes::Variable, Repeat<PskIdentityCombinator>>, PskIdentitiesCont0>, PskIdentitiesMapper>;
+}
+pub type Opaque1FfCombinatorAlias = Mapped<Pair<Refined<U8, Predicate3651688686135228051>, bytes::Variable, Opaque1FfCont0>, Opaque1FfMapper>;
 
 
-pub open spec fn spec_psk_identities() -> SpecPskIdentitiesCombinator {
-    SpecPskIdentitiesCombinator(
+pub open spec fn spec_opaque_1_ff() -> SpecOpaque1FfCombinator {
+    SpecOpaque1FfCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate22012019403780218 }, |deps| spec_psk_identities_cont0(deps)),
-        mapper: PskIdentitiesMapper,
+        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate3651688686135228051 }, |deps| spec_opaque1_ff_cont0(deps)),
+        mapper: Opaque1FfMapper,
     })
 }
 
-pub open spec fn spec_psk_identities_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecPskIdentityCombinator>> {
+pub open spec fn spec_opaque1_ff_cont0(deps: u8) -> bytes::Variable {
     let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_psk_identity()))
+    bytes::Variable((usize::spec_from(l)) as usize)
 }
 
-impl View for PskIdentitiesCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecPskIdentityCombinator>>;
+impl View for Opaque1FfCont0 {
+    type V = spec_fn(u8) -> bytes::Variable;
 
     open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_psk_identities_cont0(deps)
+        |deps: u8| {
+            spec_opaque1_ff_cont0(deps)
         }
     }
 }
 
                 
-pub fn psk_identities<'a>() -> (o: PskIdentitiesCombinator)
-    ensures o@ == spec_psk_identities(),
+pub fn opaque_1_ff<'a>() -> (o: Opaque1FfCombinator)
+    ensures o@ == spec_opaque_1_ff(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = PskIdentitiesCombinator(
+    let combinator = Opaque1FfCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate22012019403780218 }, PskIdentitiesCont0),
-        mapper: PskIdentitiesMapper,
-    });
-    assert({
-        &&& combinator@ == spec_psk_identities()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U8, predicate: Predicate3651688686135228051 }, Opaque1FfCont0),
+        mapper: Opaque1FfMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_opaque_1_ff()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_psk_identities<'a>(input: &'a [u8]) -> (res: PResult<<PskIdentitiesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_opaque_1_ff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque1FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_psk_identities().spec_parse(input@) == Some((n as int, v@)),
-        spec_psk_identities().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_opaque_1_ff().spec_parse(input@) == Some((n as int, v@)),
+        spec_opaque_1_ff().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_psk_identities().spec_parse(input@) is None,
-        spec_psk_identities().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_opaque_1_ff().spec_parse(input@) is None,
+        spec_opaque_1_ff().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = psk_identities();
+    let combinator = opaque_1_ff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_psk_identities<'a>(v: <PskIdentitiesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_opaque_1_ff<'a>(v: <Opaque1FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_psk_identities().wf(v@),
+        spec_opaque_1_ff().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_psk_identities().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_psk_identities().spec_serialize(v@))
+            &&& n == spec_opaque_1_ff().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_1_ff().spec_serialize(v@))
         },
 {
-    let combinator = psk_identities();
+    let combinator = opaque_1_ff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn psk_identities_len<'a>(v: <PskIdentitiesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn opaque_1_ff_len<'a>(v: <Opaque1FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_psk_identities().wf(v@),
-        spec_psk_identities().spec_serialize(v@).len() <= usize::MAX,
+        spec_opaque_1_ff().wf(v@),
+        spec_opaque_1_ff().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_psk_identities().spec_serialize(v@).len(),
+        serialize_len == spec_opaque_1_ff().spec_serialize(v@).len(),
 {
-    let combinator = psk_identities();
+    let combinator = opaque_1_ff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct PskIdentitiesCont0;
-type PskIdentitiesCont0Type<'a, 'b> = &'b u16;
-type PskIdentitiesCont0SType<'a, 'x> = &'x u16;
-type PskIdentitiesCont0Input<'a, 'b, 'x> = POrSType<PskIdentitiesCont0Type<'a, 'b>, PskIdentitiesCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<PskIdentitiesCont0Input<'a, 'b, 'x>> for PskIdentitiesCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<PskIdentityCombinator>>;
+pub struct Opaque1FfCont0;
+type Opaque1FfCont0Type<'a, 'b> = &'b u8;
+type Opaque1FfCont0SType<'a, 'x> = &'x u8;
+type Opaque1FfCont0Input<'a, 'b, 'x> = POrSType<Opaque1FfCont0Type<'a, 'b>, Opaque1FfCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Opaque1FfCont0Input<'a, 'b, 'x>> for Opaque1FfCont0 {
+    type Output = bytes::Variable;
 
-    open spec fn requires(&self, deps: PskIdentitiesCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: Opaque1FfCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U8, predicate: Predicate3651688686135228051 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: PskIdentitiesCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_psk_identities_cont0(deps@)
+    open spec fn ensures(&self, deps: Opaque1FfCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_opaque1_ff_cont0(deps@)
     }
 
-    fn apply(&self, deps: PskIdentitiesCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: Opaque1FfCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(psk_identity()))
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(psk_identity()))
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
 
-pub struct SpecEarlyDataIndicationNewSessionTicket {
-    pub max_early_data_size: u32,
+pub struct SpecOidFilter {
+    pub certificate_extension_oid: SpecOpaque1Ff,
+    pub certificate_extension_values: SpecOpaque0Ffff,
 }
 
-pub type SpecEarlyDataIndicationNewSessionTicketInner = u32;
+pub type SpecOidFilterInner = (SpecOpaque1Ff, SpecOpaque0Ffff);
 
 
-impl SpecFrom<SpecEarlyDataIndicationNewSessionTicket> for SpecEarlyDataIndicationNewSessionTicketInner {
-    open spec fn spec_from(m: SpecEarlyDataIndicationNewSessionTicket) -> SpecEarlyDataIndicationNewSessionTicketInner {
-        m.max_early_data_size
+impl SpecFrom<SpecOidFilter> for SpecOidFilterInner {
+    open spec fn spec_from(m: SpecOidFilter) -> SpecOidFilterInner {
+        (m.certificate_extension_oid, m.certificate_extension_values)
     }
 }
 
-impl SpecFrom<SpecEarlyDataIndicationNewSessionTicketInner> for SpecEarlyDataIndicationNewSessionTicket {
-    open spec fn spec_from(m: SpecEarlyDataIndicationNewSessionTicketInner) -> SpecEarlyDataIndicationNewSessionTicket {
-        let max_early_data_size = m;
-        SpecEarlyDataIndicationNewSessionTicket { max_early_data_size }
+impl SpecFrom<SpecOidFilterInner> for SpecOidFilter {
+    open spec fn spec_from(m: SpecOidFilterInner) -> SpecOidFilter {
+        let (certificate_extension_oid, certificate_extension_values) = m;
+        SpecOidFilter { certificate_extension_oid, certificate_extension_values }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct EarlyDataIndicationNewSessionTicket {
-    pub max_early_data_size: u32,
+pub struct OidFilter<'a> {
+    pub certificate_extension_oid: Opaque1Ff<'a>,
+    pub certificate_extension_values: Opaque0Ffff<'a>,
 }
 
-impl View for EarlyDataIndicationNewSessionTicket {
-    type V = SpecEarlyDataIndicationNewSessionTicket;
+impl View for OidFilter<'_> {
+    type V = SpecOidFilter;
 
     open spec fn view(&self) -> Self::V {
-        SpecEarlyDataIndicationNewSessionTicket {
-            max_early_data_size: self.max_early_data_size@,
+        SpecOidFilter {
+            certificate_extension_oid: self.certificate_extension_oid@,
+            certificate_extension_values: self.certificate_extension_values@,
         }
     }
 }
-pub type EarlyDataIndicationNewSessionTicketInner = u32;
+pub type OidFilterInner<'a> = (Opaque1Ff<'a>, Opaque0Ffff<'a>);
 
-pub type EarlyDataIndicationNewSessionTicketInnerRef<'a> = &'a u32;
-impl<'a> From<&'a EarlyDataIndicationNewSessionTicket> for EarlyDataIndicationNewSessionTicketInnerRef<'a> {
-    fn ex_from(m: &'a EarlyDataIndicationNewSessionTicket) -> EarlyDataIndicationNewSessionTicketInnerRef<'a> {
-        &m.max_early_data_size
+pub type OidFilterInnerRef<'a> = (&'a Opaque1Ff<'a>, &'a Opaque0Ffff<'a>);
+impl<'a> From<&'a OidFilter<'a>> for OidFilterInnerRef<'a> {
+    fn ex_from(m: &'a OidFilter) -> OidFilterInnerRef<'a> {
+        (&m.certificate_extension_oid, &m.certificate_extension_values)
     }
 }
 
-impl From<EarlyDataIndicationNewSessionTicketInner> for EarlyDataIndicationNewSessionTicket {
-    fn ex_from(m: EarlyDataIndicationNewSessionTicketInner) -> EarlyDataIndicationNewSessionTicket {
-        let max_early_data_size = m;
-        EarlyDataIndicationNewSessionTicket { max_early_data_size }
+impl<'a> From<OidFilterInner<'a>> for OidFilter<'a> {
+    fn ex_from(m: OidFilterInner) -> OidFilter {
+        let (certificate_extension_oid, certificate_extension_values) = m;
+        OidFilter { certificate_extension_oid, certificate_extension_values }
     }
 }
 
-pub struct EarlyDataIndicationNewSessionTicketMapper;
-impl View for EarlyDataIndicationNewSessionTicketMapper {
+pub struct OidFilterMapper;
+impl View for OidFilterMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for EarlyDataIndicationNewSessionTicketMapper {
-    type Src = SpecEarlyDataIndicationNewSessionTicketInner;
-    type Dst = SpecEarlyDataIndicationNewSessionTicket;
+impl SpecIso for OidFilterMapper {
+    type Src = SpecOidFilterInner;
+    type Dst = SpecOidFilter;
 }
-impl SpecIsoProof for EarlyDataIndicationNewSessionTicketMapper {
+impl SpecIsoProof for OidFilterMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -3806,1181 +3484,1176 @@ impl SpecIsoProof for EarlyDataIndicationNewSessionTicketMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for EarlyDataIndicationNewSessionTicketMapper {
-    type Src = EarlyDataIndicationNewSessionTicketInner;
-    type Dst = EarlyDataIndicationNewSessionTicket;
-    type RefSrc = EarlyDataIndicationNewSessionTicketInnerRef<'a>;
+impl<'a> Iso<'a> for OidFilterMapper {
+    type Src = OidFilterInner<'a>;
+    type Dst = OidFilter<'a>;
+    type RefSrc = OidFilterInnerRef<'a>;
 }
+type SpecOidFilterCombinatorAlias1 = (SpecOpaque1FfCombinator, SpecOpaque0FfffCombinator);
+pub struct SpecOidFilterCombinator(pub SpecOidFilterCombinatorAlias);
 
-pub struct SpecEarlyDataIndicationNewSessionTicketCombinator(pub SpecEarlyDataIndicationNewSessionTicketCombinatorAlias);
-
-impl SpecCombinator for SpecEarlyDataIndicationNewSessionTicketCombinator {
-    type Type = SpecEarlyDataIndicationNewSessionTicket;
+impl SpecCombinator for SpecOidFilterCombinator {
+    type Type = SpecOidFilter;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecEarlyDataIndicationNewSessionTicketCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecEarlyDataIndicationNewSessionTicketCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOidFilterCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOidFilterCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecEarlyDataIndicationNewSessionTicketCombinatorAlias = Mapped<U32Be, EarlyDataIndicationNewSessionTicketMapper>;
+pub type SpecOidFilterCombinatorAlias = Mapped<SpecOidFilterCombinatorAlias1, OidFilterMapper>;
+type OidFilterCombinatorAlias1 = (Opaque1FfCombinator, Opaque0FfffCombinator);
+pub struct OidFilterCombinator1(pub OidFilterCombinatorAlias1);
+impl View for OidFilterCombinator1 {
+    type V = SpecOidFilterCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(OidFilterCombinator1, OidFilterCombinatorAlias1);
 
-pub struct EarlyDataIndicationNewSessionTicketCombinator(pub EarlyDataIndicationNewSessionTicketCombinatorAlias);
+pub struct OidFilterCombinator(pub OidFilterCombinatorAlias);
 
-impl View for EarlyDataIndicationNewSessionTicketCombinator {
-    type V = SpecEarlyDataIndicationNewSessionTicketCombinator;
-    open spec fn view(&self) -> Self::V { SpecEarlyDataIndicationNewSessionTicketCombinator(self.0@) }
+impl View for OidFilterCombinator {
+    type V = SpecOidFilterCombinator;
+    open spec fn view(&self) -> Self::V { SpecOidFilterCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EarlyDataIndicationNewSessionTicketCombinator {
-    type Type = EarlyDataIndicationNewSessionTicket;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OidFilterCombinator {
+    type Type = OidFilter<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type EarlyDataIndicationNewSessionTicketCombinatorAlias = Mapped<U32Be, EarlyDataIndicationNewSessionTicketMapper>;
+}
+pub type OidFilterCombinatorAlias = Mapped<OidFilterCombinator1, OidFilterMapper>;
 
 
-pub open spec fn spec_early_data_indication_new_session_ticket() -> SpecEarlyDataIndicationNewSessionTicketCombinator {
-    SpecEarlyDataIndicationNewSessionTicketCombinator(
+pub open spec fn spec_oid_filter() -> SpecOidFilterCombinator {
+    SpecOidFilterCombinator(
     Mapped {
-        inner: U32Be,
-        mapper: EarlyDataIndicationNewSessionTicketMapper,
+        inner: (spec_opaque_1_ff(), spec_opaque_0_ffff()),
+        mapper: OidFilterMapper,
     })
 }
 
                 
-pub fn early_data_indication_new_session_ticket<'a>() -> (o: EarlyDataIndicationNewSessionTicketCombinator)
-    ensures o@ == spec_early_data_indication_new_session_ticket(),
+pub fn oid_filter<'a>() -> (o: OidFilterCombinator)
+    ensures o@ == spec_oid_filter(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = EarlyDataIndicationNewSessionTicketCombinator(
+    let combinator = OidFilterCombinator(
     Mapped {
-        inner: U32Be,
-        mapper: EarlyDataIndicationNewSessionTicketMapper,
-    });
-    assert({
-        &&& combinator@ == spec_early_data_indication_new_session_ticket()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: OidFilterCombinator1((opaque_1_ff(), opaque_0_ffff())),
+        mapper: OidFilterMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_oid_filter()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_early_data_indication_new_session_ticket<'a>(input: &'a [u8]) -> (res: PResult<<EarlyDataIndicationNewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_oid_filter<'a>(input: &'a [u8]) -> (res: PResult<<OidFilterCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_early_data_indication_new_session_ticket().spec_parse(input@) == Some((n as int, v@)),
-        spec_early_data_indication_new_session_ticket().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_oid_filter().spec_parse(input@) == Some((n as int, v@)),
+        spec_oid_filter().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_early_data_indication_new_session_ticket().spec_parse(input@) is None,
-        spec_early_data_indication_new_session_ticket().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_oid_filter().spec_parse(input@) is None,
+        spec_oid_filter().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = early_data_indication_new_session_ticket();
+    let combinator = oid_filter();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_early_data_indication_new_session_ticket<'a>(v: <EarlyDataIndicationNewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_oid_filter<'a>(v: <OidFilterCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_early_data_indication_new_session_ticket().wf(v@),
+        spec_oid_filter().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_early_data_indication_new_session_ticket().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_early_data_indication_new_session_ticket().spec_serialize(v@))
+            &&& n == spec_oid_filter().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_oid_filter().spec_serialize(v@))
         },
 {
-    let combinator = early_data_indication_new_session_ticket();
+    let combinator = oid_filter();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn early_data_indication_new_session_ticket_len<'a>(v: <EarlyDataIndicationNewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn oid_filter_len<'a>(v: <OidFilterCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_early_data_indication_new_session_ticket().wf(v@),
-        spec_early_data_indication_new_session_ticket().spec_serialize(v@).len() <= usize::MAX,
+        spec_oid_filter().wf(v@),
+        spec_oid_filter().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_early_data_indication_new_session_ticket().spec_serialize(v@).len(),
+        serialize_len == spec_oid_filter().spec_serialize(v@).len(),
 {
-    let combinator = early_data_indication_new_session_ticket();
+    let combinator = oid_filter();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub mod ExtensionType {
-    use super::*;
-    pub spec const SPEC_ServerName: u16 = 0;
-    pub spec const SPEC_MaxFragmentLength: u16 = 1;
-    pub spec const SPEC_StatusRequest: u16 = 5;
-    pub spec const SPEC_SupportedGroups: u16 = 10;
-    pub spec const SPEC_ECPointFormats: u16 = 11;
-    pub spec const SPEC_SignatureAlgorithms: u16 = 13;
-    pub spec const SPEC_UseSRTP: u16 = 14;
-    pub spec const SPEC_Heartbeat: u16 = 15;
-    pub spec const SPEC_ApplicationLayerProtocolNegotiation: u16 = 16;
-    pub spec const SPEC_SignedCertificateTimeStamp: u16 = 18;
-    pub spec const SPEC_ClientCertificateType: u16 = 19;
-    pub spec const SPEC_ServerCertificateType: u16 = 20;
-    pub spec const SPEC_Padding: u16 = 21;
-    pub spec const SPEC_EncryptThenMac: u16 = 22;
-    pub spec const SPEC_ExtendedMasterSecret: u16 = 23;
-    pub spec const SPEC_SessionTicket: u16 = 35;
-    pub spec const SPEC_PreSharedKey: u16 = 41;
-    pub spec const SPEC_EarlyData: u16 = 42;
-    pub spec const SPEC_SupportedVersions: u16 = 43;
-    pub spec const SPEC_Cookie: u16 = 44;
-    pub spec const SPEC_PskKeyExchangeModes: u16 = 45;
-    pub spec const SPEC_CertificateAuthorities: u16 = 47;
-    pub spec const SPEC_OidFilters: u16 = 48;
-    pub spec const SPEC_PostHandshakeAuth: u16 = 49;
-    pub spec const SPEC_SignatureAlgorithmsCert: u16 = 50;
-    pub spec const SPEC_KeyShare: u16 = 51;
-    pub spec const SPEC_Dummy: u16 = 65535;
-    pub exec const ServerName: u16 ensures ServerName == SPEC_ServerName { 0 }
-    pub exec const MaxFragmentLength: u16 ensures MaxFragmentLength == SPEC_MaxFragmentLength { 1 }
-    pub exec const StatusRequest: u16 ensures StatusRequest == SPEC_StatusRequest { 5 }
-    pub exec const SupportedGroups: u16 ensures SupportedGroups == SPEC_SupportedGroups { 10 }
-    pub exec const ECPointFormats: u16 ensures ECPointFormats == SPEC_ECPointFormats { 11 }
-    pub exec const SignatureAlgorithms: u16 ensures SignatureAlgorithms == SPEC_SignatureAlgorithms { 13 }
-    pub exec const UseSRTP: u16 ensures UseSRTP == SPEC_UseSRTP { 14 }
-    pub exec const Heartbeat: u16 ensures Heartbeat == SPEC_Heartbeat { 15 }
-    pub exec const ApplicationLayerProtocolNegotiation: u16 ensures ApplicationLayerProtocolNegotiation == SPEC_ApplicationLayerProtocolNegotiation { 16 }
-    pub exec const SignedCertificateTimeStamp: u16 ensures SignedCertificateTimeStamp == SPEC_SignedCertificateTimeStamp { 18 }
-    pub exec const ClientCertificateType: u16 ensures ClientCertificateType == SPEC_ClientCertificateType { 19 }
-    pub exec const ServerCertificateType: u16 ensures ServerCertificateType == SPEC_ServerCertificateType { 20 }
-    pub exec const Padding: u16 ensures Padding == SPEC_Padding { 21 }
-    pub exec const EncryptThenMac: u16 ensures EncryptThenMac == SPEC_EncryptThenMac { 22 }
-    pub exec const ExtendedMasterSecret: u16 ensures ExtendedMasterSecret == SPEC_ExtendedMasterSecret { 23 }
-    pub exec const SessionTicket: u16 ensures SessionTicket == SPEC_SessionTicket { 35 }
-    pub exec const PreSharedKey: u16 ensures PreSharedKey == SPEC_PreSharedKey { 41 }
-    pub exec const EarlyData: u16 ensures EarlyData == SPEC_EarlyData { 42 }
-    pub exec const SupportedVersions: u16 ensures SupportedVersions == SPEC_SupportedVersions { 43 }
-    pub exec const Cookie: u16 ensures Cookie == SPEC_Cookie { 44 }
-    pub exec const PskKeyExchangeModes: u16 ensures PskKeyExchangeModes == SPEC_PskKeyExchangeModes { 45 }
-    pub exec const CertificateAuthorities: u16 ensures CertificateAuthorities == SPEC_CertificateAuthorities { 47 }
-    pub exec const OidFilters: u16 ensures OidFilters == SPEC_OidFilters { 48 }
-    pub exec const PostHandshakeAuth: u16 ensures PostHandshakeAuth == SPEC_PostHandshakeAuth { 49 }
-    pub exec const SignatureAlgorithmsCert: u16 ensures SignatureAlgorithmsCert == SPEC_SignatureAlgorithmsCert { 50 }
-    pub exec const KeyShare: u16 ensures KeyShare == SPEC_KeyShare { 51 }
-    pub exec const Dummy: u16 ensures Dummy == SPEC_Dummy { 65535 }
+
+pub struct SpecOidFilterExtension {
+    pub l: u16,
+    pub list: Seq<SpecOidFilter>,
 }
 
+pub type SpecOidFilterExtensionInner = (u16, Seq<SpecOidFilter>);
 
-pub struct SpecExtensionTypeCombinator(pub SpecExtensionTypeCombinatorAlias);
 
-impl SpecCombinator for SpecExtensionTypeCombinator {
-    type Type = u16;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecExtensionTypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecExtensionTypeCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
+impl SpecFrom<SpecOidFilterExtension> for SpecOidFilterExtensionInner {
+    open spec fn spec_from(m: SpecOidFilterExtension) -> SpecOidFilterExtensionInner {
+        (m.l, m.list)
+    }
 }
-pub type SpecExtensionTypeCombinatorAlias = U16Be;
-
-pub struct ExtensionTypeCombinator(pub ExtensionTypeCombinatorAlias);
 
-impl View for ExtensionTypeCombinator {
-    type V = SpecExtensionTypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecExtensionTypeCombinator(self.0@) }
+impl SpecFrom<SpecOidFilterExtensionInner> for SpecOidFilterExtension {
+    open spec fn spec_from(m: SpecOidFilterExtensionInner) -> SpecOidFilterExtension {
+        let (l, list) = m;
+        SpecOidFilterExtension { l, list }
+    }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExtensionTypeCombinator {
-    type Type = u16;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ExtensionTypeCombinatorAlias = U16Be;
+#[derive(Debug, Clone, PartialEq, Eq)]
 
+pub struct OidFilterExtension<'a> {
+    pub l: u16,
+    pub list: RepeatResult<OidFilter<'a>>,
+}
 
-pub open spec fn spec_extension_type() -> SpecExtensionTypeCombinator {
-    SpecExtensionTypeCombinator(U16Be)
-}
+impl View for OidFilterExtension<'_> {
+    type V = SpecOidFilterExtension;
 
-                
-pub fn extension_type<'a>() -> (o: ExtensionTypeCombinator)
-    ensures o@ == spec_extension_type(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = ExtensionTypeCombinator(U16Be);
-    assert({
-        &&& combinator@ == spec_extension_type()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
+    open spec fn view(&self) -> Self::V {
+        SpecOidFilterExtension {
+            l: self.l@,
+            list: self.list@,
+        }
+    }
 }
+pub type OidFilterExtensionInner<'a> = (u16, RepeatResult<OidFilter<'a>>);
 
-pub fn parse_extension_type<'a>(input: &'a [u8]) -> (res: PResult<<ExtensionTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_extension_type().spec_parse(input@) == Some((n as int, v@)),
-        spec_extension_type().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_extension_type().spec_parse(input@) is None,
-        spec_extension_type().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = extension_type();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+pub type OidFilterExtensionInnerRef<'a> = (&'a u16, &'a RepeatResult<OidFilter<'a>>);
+impl<'a> From<&'a OidFilterExtension<'a>> for OidFilterExtensionInnerRef<'a> {
+    fn ex_from(m: &'a OidFilterExtension) -> OidFilterExtensionInnerRef<'a> {
+        (&m.l, &m.list)
+    }
 }
 
-pub fn serialize_extension_type<'a>(v: <ExtensionTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_extension_type().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_extension_type().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_extension_type().spec_serialize(v@))
-        },
-{
-    let combinator = extension_type();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+impl<'a> From<OidFilterExtensionInner<'a>> for OidFilterExtension<'a> {
+    fn ex_from(m: OidFilterExtensionInner) -> OidFilterExtension {
+        let (l, list) = m;
+        OidFilterExtension { l, list }
+    }
 }
 
-pub fn extension_type_len<'a>(v: <ExtensionTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_extension_type().wf(v@),
-        spec_extension_type().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_extension_type().spec_serialize(v@).len(),
-{
-    let combinator = extension_type();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+pub struct OidFilterExtensionMapper;
+impl View for OidFilterExtensionMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for OidFilterExtensionMapper {
+    type Src = SpecOidFilterExtensionInner;
+    type Dst = SpecOidFilterExtension;
+}
+impl SpecIsoProof for OidFilterExtensionMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for OidFilterExtensionMapper {
+    type Src = OidFilterExtensionInner<'a>;
+    type Dst = OidFilterExtension<'a>;
+    type RefSrc = OidFilterExtensionInnerRef<'a>;
 }
 
-                
-pub type SpecEmpty = Seq<u8>;
-pub type Empty<'a> = &'a [u8];
-pub type EmptyRef<'a> = &'a &'a [u8];
-
-
-pub struct SpecEmptyCombinator(pub SpecEmptyCombinatorAlias);
+pub struct SpecOidFilterExtensionCombinator(pub SpecOidFilterExtensionCombinatorAlias);
 
-impl SpecCombinator for SpecEmptyCombinator {
-    type Type = SpecEmpty;
+impl SpecCombinator for SpecOidFilterExtensionCombinator {
+    type Type = SpecOidFilterExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecEmptyCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecEmptyCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOidFilterExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOidFilterExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecEmptyCombinatorAlias = bytes::Fixed<0>;
+pub type SpecOidFilterExtensionCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecOidFilterCombinator>>>, OidFilterExtensionMapper>;
 
-pub struct EmptyCombinator(pub EmptyCombinatorAlias);
+pub struct OidFilterExtensionCombinator(pub OidFilterExtensionCombinatorAlias);
 
-impl View for EmptyCombinator {
-    type V = SpecEmptyCombinator;
-    open spec fn view(&self) -> Self::V { SpecEmptyCombinator(self.0@) }
+impl View for OidFilterExtensionCombinator {
+    type V = SpecOidFilterExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecOidFilterExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EmptyCombinator {
-    type Type = Empty<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OidFilterExtensionCombinator {
+    type Type = OidFilterExtension<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type EmptyCombinatorAlias = bytes::Fixed<0>;
+}
+pub type OidFilterExtensionCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<OidFilterCombinator>>, OidFilterExtensionCont0>, OidFilterExtensionMapper>;
 
 
-pub open spec fn spec_empty() -> SpecEmptyCombinator {
-    SpecEmptyCombinator(bytes::Fixed::<0>)
+pub open spec fn spec_oid_filter_extension() -> SpecOidFilterExtensionCombinator {
+    SpecOidFilterExtensionCombinator(
+    Mapped {
+        inner: Pair::spec_new(U16Be, |deps| spec_oid_filter_extension_cont0(deps)),
+        mapper: OidFilterExtensionMapper,
+    })
+}
+
+pub open spec fn spec_oid_filter_extension_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecOidFilterCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_oid_filter()))
+}
+
+impl View for OidFilterExtensionCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecOidFilterCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_oid_filter_extension_cont0(deps)
+        }
+    }
 }
 
                 
-pub fn empty<'a>() -> (o: EmptyCombinator)
-    ensures o@ == spec_empty(),
+pub fn oid_filter_extension<'a>() -> (o: OidFilterExtensionCombinator)
+    ensures o@ == spec_oid_filter_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = EmptyCombinator(bytes::Fixed::<0>);
-    assert({
-        &&& combinator@ == spec_empty()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = OidFilterExtensionCombinator(
+    Mapped {
+        inner: Pair::new(U16Be, OidFilterExtensionCont0),
+        mapper: OidFilterExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_oid_filter_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_empty<'a>(input: &'a [u8]) -> (res: PResult<<EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_oid_filter_extension<'a>(input: &'a [u8]) -> (res: PResult<<OidFilterExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_empty().spec_parse(input@) == Some((n as int, v@)),
-        spec_empty().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_oid_filter_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_oid_filter_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_empty().spec_parse(input@) is None,
-        spec_empty().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_oid_filter_extension().spec_parse(input@) is None,
+        spec_oid_filter_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = empty();
+    let combinator = oid_filter_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_empty<'a>(v: <EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_oid_filter_extension<'a>(v: <OidFilterExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_empty().wf(v@),
+        spec_oid_filter_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_empty().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_empty().spec_serialize(v@))
+            &&& n == spec_oid_filter_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_oid_filter_extension().spec_serialize(v@))
         },
 {
-    let combinator = empty();
+    let combinator = oid_filter_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn empty_len<'a>(v: <EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn oid_filter_extension_len<'a>(v: <OidFilterExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_empty().wf(v@),
-        spec_empty().spec_serialize(v@).len() <= usize::MAX,
+        spec_oid_filter_extension().wf(v@),
+        spec_oid_filter_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_empty().spec_serialize(v@).len(),
+        serialize_len == spec_oid_filter_extension().spec_serialize(v@).len(),
 {
-    let combinator = empty();
+    let combinator = oid_filter_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
-pub mod MaxFragmentLength {
-    use super::*;
-    pub spec const SPEC_Pow2_9: u8 = 1;
-    pub spec const SPEC_Pow2_10: u8 = 2;
-    pub spec const SPEC_Pow2_11: u8 = 3;
-    pub spec const SPEC_Pow2_12: u8 = 4;
-    pub exec const Pow2_9: u8 ensures Pow2_9 == SPEC_Pow2_9 { 1 }
-    pub exec const Pow2_10: u8 ensures Pow2_10 == SPEC_Pow2_10 { 2 }
-    pub exec const Pow2_11: u8 ensures Pow2_11 == SPEC_Pow2_11 { 3 }
-    pub exec const Pow2_12: u8 ensures Pow2_12 == SPEC_Pow2_12 { 4 }
-}
+pub struct OidFilterExtensionCont0;
+type OidFilterExtensionCont0Type<'a, 'b> = &'b u16;
+type OidFilterExtensionCont0SType<'a, 'x> = &'x u16;
+type OidFilterExtensionCont0Input<'a, 'b, 'x> = POrSType<OidFilterExtensionCont0Type<'a, 'b>, OidFilterExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<OidFilterExtensionCont0Input<'a, 'b, 'x>> for OidFilterExtensionCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<OidFilterCombinator>>;
 
+    open spec fn requires(&self, deps: OidFilterExtensionCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U16Be).wf(deps@)
+        }
 
-pub struct SpecMaxFragmentLengthCombinator(pub SpecMaxFragmentLengthCombinatorAlias);
+    open spec fn ensures(&self, deps: OidFilterExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_oid_filter_extension_cont0(deps@)
+    }
 
-impl SpecCombinator for SpecMaxFragmentLengthCombinator {
-    type Type = u8;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
+    fn apply(&self, deps: OidFilterExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(oid_filter()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(oid_filter()))
+            }
+        }
+    }
 }
-impl SecureSpecCombinator for SpecMaxFragmentLengthCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecMaxFragmentLengthCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
+                
+
+pub enum SpecCertificateRequestExtensionExtensionData {
+    SignatureAlgorithms(SpecSignatureSchemeList),
+    CertificateAuthorities(SpecCertificateAuthoritiesExtension),
+    SignatureAlgorithmsCert(SpecSignatureSchemeList),
+    StatusRequest(SpecCertificateStatusRequest),
+    SignedCertificateTimeStamp(SpecSignedCertificateTimestampList),
+    OidFilters(SpecOidFilterExtension),
+    Unrecognized(Seq<u8>),
 }
-pub type SpecMaxFragmentLengthCombinatorAlias = U8;
 
-pub struct MaxFragmentLengthCombinator(pub MaxFragmentLengthCombinatorAlias);
+pub type SpecCertificateRequestExtensionExtensionDataInner = Either<SpecSignatureSchemeList, Either<SpecCertificateAuthoritiesExtension, Either<SpecSignatureSchemeList, Either<SpecCertificateStatusRequest, Either<SpecSignedCertificateTimestampList, Either<SpecOidFilterExtension, Seq<u8>>>>>>>;
 
-impl View for MaxFragmentLengthCombinator {
-    type V = SpecMaxFragmentLengthCombinator;
-    open spec fn view(&self) -> Self::V { SpecMaxFragmentLengthCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MaxFragmentLengthCombinator {
-    type Type = u8;
+impl SpecFrom<SpecCertificateRequestExtensionExtensionData> for SpecCertificateRequestExtensionExtensionDataInner {
+    open spec fn spec_from(m: SpecCertificateRequestExtensionExtensionData) -> SpecCertificateRequestExtensionExtensionDataInner {
+        match m {
+            SpecCertificateRequestExtensionExtensionData::SignatureAlgorithms(m) => Either::Left(m),
+            SpecCertificateRequestExtensionExtensionData::CertificateAuthorities(m) => Either::Right(Either::Left(m)),
+            SpecCertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecCertificateRequestExtensionExtensionData::StatusRequest(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecCertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecCertificateRequestExtensionExtensionData::OidFilters(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            SpecCertificateRequestExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecCertificateRequestExtensionExtensionDataInner> for SpecCertificateRequestExtensionExtensionData {
+    open spec fn spec_from(m: SpecCertificateRequestExtensionExtensionDataInner) -> SpecCertificateRequestExtensionExtensionData {
+        match m {
+            Either::Left(m) => SpecCertificateRequestExtensionExtensionData::SignatureAlgorithms(m),
+            Either::Right(Either::Left(m)) => SpecCertificateRequestExtensionExtensionData::CertificateAuthorities(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecCertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecCertificateRequestExtensionExtensionData::StatusRequest(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecCertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecCertificateRequestExtensionExtensionData::OidFilters(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => SpecCertificateRequestExtensionExtensionData::Unrecognized(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CertificateRequestExtensionExtensionData<'a> {
+    SignatureAlgorithms(SignatureSchemeList),
+    CertificateAuthorities(CertificateAuthoritiesExtension<'a>),
+    SignatureAlgorithmsCert(SignatureSchemeList),
+    StatusRequest(CertificateStatusRequest<'a>),
+    SignedCertificateTimeStamp(SignedCertificateTimestampList<'a>),
+    OidFilters(OidFilterExtension<'a>),
+    Unrecognized(&'a [u8]),
+}
+
+pub type CertificateRequestExtensionExtensionDataInner<'a> = Either<SignatureSchemeList, Either<CertificateAuthoritiesExtension<'a>, Either<SignatureSchemeList, Either<CertificateStatusRequest<'a>, Either<SignedCertificateTimestampList<'a>, Either<OidFilterExtension<'a>, &'a [u8]>>>>>>;
+
+pub type CertificateRequestExtensionExtensionDataInnerRef<'a> = Either<&'a SignatureSchemeList, Either<&'a CertificateAuthoritiesExtension<'a>, Either<&'a SignatureSchemeList, Either<&'a CertificateStatusRequest<'a>, Either<&'a SignedCertificateTimestampList<'a>, Either<&'a OidFilterExtension<'a>, &'a &'a [u8]>>>>>>;
+
+
+impl<'a> View for CertificateRequestExtensionExtensionData<'a> {
+    type V = SpecCertificateRequestExtensionExtensionData;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            CertificateRequestExtensionExtensionData::SignatureAlgorithms(m) => SpecCertificateRequestExtensionExtensionData::SignatureAlgorithms(m@),
+            CertificateRequestExtensionExtensionData::CertificateAuthorities(m) => SpecCertificateRequestExtensionExtensionData::CertificateAuthorities(m@),
+            CertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m) => SpecCertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m@),
+            CertificateRequestExtensionExtensionData::StatusRequest(m) => SpecCertificateRequestExtensionExtensionData::StatusRequest(m@),
+            CertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m) => SpecCertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m@),
+            CertificateRequestExtensionExtensionData::OidFilters(m) => SpecCertificateRequestExtensionExtensionData::OidFilters(m@),
+            CertificateRequestExtensionExtensionData::Unrecognized(m) => SpecCertificateRequestExtensionExtensionData::Unrecognized(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a CertificateRequestExtensionExtensionData<'a>> for CertificateRequestExtensionExtensionDataInnerRef<'a> {
+    fn ex_from(m: &'a CertificateRequestExtensionExtensionData<'a>) -> CertificateRequestExtensionExtensionDataInnerRef<'a> {
+        match m {
+            CertificateRequestExtensionExtensionData::SignatureAlgorithms(m) => Either::Left(m),
+            CertificateRequestExtensionExtensionData::CertificateAuthorities(m) => Either::Right(Either::Left(m)),
+            CertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m) => Either::Right(Either::Right(Either::Left(m))),
+            CertificateRequestExtensionExtensionData::StatusRequest(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            CertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            CertificateRequestExtensionExtensionData::OidFilters(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            CertificateRequestExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
+        }
+    }
+
+}
+
+impl<'a> From<CertificateRequestExtensionExtensionDataInner<'a>> for CertificateRequestExtensionExtensionData<'a> {
+    fn ex_from(m: CertificateRequestExtensionExtensionDataInner<'a>) -> CertificateRequestExtensionExtensionData<'a> {
+        match m {
+            Either::Left(m) => CertificateRequestExtensionExtensionData::SignatureAlgorithms(m),
+            Either::Right(Either::Left(m)) => CertificateRequestExtensionExtensionData::CertificateAuthorities(m),
+            Either::Right(Either::Right(Either::Left(m))) => CertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => CertificateRequestExtensionExtensionData::StatusRequest(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => CertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => CertificateRequestExtensionExtensionData::OidFilters(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => CertificateRequestExtensionExtensionData::Unrecognized(m),
+        }
+    }
+    
+}
+
+
+pub struct CertificateRequestExtensionExtensionDataMapper;
+impl View for CertificateRequestExtensionExtensionDataMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CertificateRequestExtensionExtensionDataMapper {
+    type Src = SpecCertificateRequestExtensionExtensionDataInner;
+    type Dst = SpecCertificateRequestExtensionExtensionData;
+}
+impl SpecIsoProof for CertificateRequestExtensionExtensionDataMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CertificateRequestExtensionExtensionDataMapper {
+    type Src = CertificateRequestExtensionExtensionDataInner<'a>;
+    type Dst = CertificateRequestExtensionExtensionData<'a>;
+    type RefSrc = CertificateRequestExtensionExtensionDataInnerRef<'a>;
+}
+
+type SpecCertificateRequestExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecOidFilterExtensionCombinator>, Cond<bytes::Variable>>;
+type SpecCertificateRequestExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecSignedCertificateTimestampListCombinator>, SpecCertificateRequestExtensionExtensionDataCombinatorAlias1>;
+type SpecCertificateRequestExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SpecCertificateStatusRequestCombinator>, SpecCertificateRequestExtensionExtensionDataCombinatorAlias2>;
+type SpecCertificateRequestExtensionExtensionDataCombinatorAlias4 = Choice<Cond<SpecSignatureSchemeListCombinator>, SpecCertificateRequestExtensionExtensionDataCombinatorAlias3>;
+type SpecCertificateRequestExtensionExtensionDataCombinatorAlias5 = Choice<Cond<SpecCertificateAuthoritiesExtensionCombinator>, SpecCertificateRequestExtensionExtensionDataCombinatorAlias4>;
+type SpecCertificateRequestExtensionExtensionDataCombinatorAlias6 = Choice<Cond<SpecSignatureSchemeListCombinator>, SpecCertificateRequestExtensionExtensionDataCombinatorAlias5>;
+pub struct SpecCertificateRequestExtensionExtensionDataCombinator(pub SpecCertificateRequestExtensionExtensionDataCombinatorAlias);
+
+impl SpecCombinator for SpecCertificateRequestExtensionExtensionDataCombinator {
+    type Type = SpecCertificateRequestExtensionExtensionData;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCertificateRequestExtensionExtensionDataCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateRequestExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCertificateRequestExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecCertificateRequestExtensionExtensionDataCombinatorAlias6, CertificateRequestExtensionExtensionDataMapper>>;
+type CertificateRequestExtensionExtensionDataCombinatorAlias1 = Choice<Cond<OidFilterExtensionCombinator>, Cond<bytes::Variable>>;
+type CertificateRequestExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SignedCertificateTimestampListCombinator>, CertificateRequestExtensionExtensionDataCombinator1>;
+type CertificateRequestExtensionExtensionDataCombinatorAlias3 = Choice<Cond<CertificateStatusRequestCombinator>, CertificateRequestExtensionExtensionDataCombinator2>;
+type CertificateRequestExtensionExtensionDataCombinatorAlias4 = Choice<Cond<SignatureSchemeListCombinator>, CertificateRequestExtensionExtensionDataCombinator3>;
+type CertificateRequestExtensionExtensionDataCombinatorAlias5 = Choice<Cond<CertificateAuthoritiesExtensionCombinator>, CertificateRequestExtensionExtensionDataCombinator4>;
+type CertificateRequestExtensionExtensionDataCombinatorAlias6 = Choice<Cond<SignatureSchemeListCombinator>, CertificateRequestExtensionExtensionDataCombinator5>;
+pub struct CertificateRequestExtensionExtensionDataCombinator1(pub CertificateRequestExtensionExtensionDataCombinatorAlias1);
+impl View for CertificateRequestExtensionExtensionDataCombinator1 {
+    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator1, CertificateRequestExtensionExtensionDataCombinatorAlias1);
+
+pub struct CertificateRequestExtensionExtensionDataCombinator2(pub CertificateRequestExtensionExtensionDataCombinatorAlias2);
+impl View for CertificateRequestExtensionExtensionDataCombinator2 {
+    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator2, CertificateRequestExtensionExtensionDataCombinatorAlias2);
+
+pub struct CertificateRequestExtensionExtensionDataCombinator3(pub CertificateRequestExtensionExtensionDataCombinatorAlias3);
+impl View for CertificateRequestExtensionExtensionDataCombinator3 {
+    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator3, CertificateRequestExtensionExtensionDataCombinatorAlias3);
+
+pub struct CertificateRequestExtensionExtensionDataCombinator4(pub CertificateRequestExtensionExtensionDataCombinatorAlias4);
+impl View for CertificateRequestExtensionExtensionDataCombinator4 {
+    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator4, CertificateRequestExtensionExtensionDataCombinatorAlias4);
+
+pub struct CertificateRequestExtensionExtensionDataCombinator5(pub CertificateRequestExtensionExtensionDataCombinatorAlias5);
+impl View for CertificateRequestExtensionExtensionDataCombinator5 {
+    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator5, CertificateRequestExtensionExtensionDataCombinatorAlias5);
+
+pub struct CertificateRequestExtensionExtensionDataCombinator6(pub CertificateRequestExtensionExtensionDataCombinatorAlias6);
+impl View for CertificateRequestExtensionExtensionDataCombinator6 {
+    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator6, CertificateRequestExtensionExtensionDataCombinatorAlias6);
+
+pub struct CertificateRequestExtensionExtensionDataCombinator(pub CertificateRequestExtensionExtensionDataCombinatorAlias);
+
+impl View for CertificateRequestExtensionExtensionDataCombinator {
+    type V = SpecCertificateRequestExtensionExtensionDataCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateRequestExtensionExtensionDataCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateRequestExtensionExtensionDataCombinator {
+    type Type = CertificateRequestExtensionExtensionData<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type MaxFragmentLengthCombinatorAlias = U8;
+}
+pub type CertificateRequestExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<CertificateRequestExtensionExtensionDataCombinator6, CertificateRequestExtensionExtensionDataMapper>>;
 
 
-pub open spec fn spec_max_fragment_length() -> SpecMaxFragmentLengthCombinator {
-    SpecMaxFragmentLengthCombinator(U8)
+pub open spec fn spec_certificate_request_extension_extension_data(ext_len: u16, extension_type: u16) -> SpecCertificateRequestExtensionExtensionDataCombinator {
+    SpecCertificateRequestExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::spec_from(ext_len)) as usize), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignatureAlgorithms, inner: spec_signature_scheme_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_CertificateAuthorities, inner: spec_certificate_authorities_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignatureAlgorithmsCert, inner: spec_signature_scheme_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_StatusRequest, inner: spec_certificate_status_request() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp, inner: spec_signed_certificate_timestamp_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_OidFilters, inner: spec_oid_filter_extension() }, Cond { cond: !(extension_type == ExtensionType::SPEC_SignatureAlgorithms || extension_type == ExtensionType::SPEC_CertificateAuthorities || extension_type == ExtensionType::SPEC_SignatureAlgorithmsCert || extension_type == ExtensionType::SPEC_StatusRequest || extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp || extension_type == ExtensionType::SPEC_OidFilters), inner: bytes::Variable((usize::spec_from(ext_len)) as usize) })))))), mapper: CertificateRequestExtensionExtensionDataMapper }))
 }
 
-                
-pub fn max_fragment_length<'a>() -> (o: MaxFragmentLengthCombinator)
-    ensures o@ == spec_max_fragment_length(),
+pub fn certificate_request_extension_extension_data<'a>(ext_len: u16, extension_type: u16) -> (o: CertificateRequestExtensionExtensionDataCombinator)
+    requires
+        spec_extension_type().wf(extension_type@),
+
+    ensures o@ == spec_certificate_request_extension_extension_data(ext_len@, extension_type@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = MaxFragmentLengthCombinator(U8);
-    assert({
-        &&& combinator@ == spec_max_fragment_length()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = CertificateRequestExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::ex_from(ext_len)) as usize), Mapped { inner: CertificateRequestExtensionExtensionDataCombinator6(Choice::new(Cond { cond: extension_type == ExtensionType::SignatureAlgorithms, inner: signature_scheme_list() }, CertificateRequestExtensionExtensionDataCombinator5(Choice::new(Cond { cond: extension_type == ExtensionType::CertificateAuthorities, inner: certificate_authorities_extension() }, CertificateRequestExtensionExtensionDataCombinator4(Choice::new(Cond { cond: extension_type == ExtensionType::SignatureAlgorithmsCert, inner: signature_scheme_list() }, CertificateRequestExtensionExtensionDataCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::StatusRequest, inner: certificate_status_request() }, CertificateRequestExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::SignedCertificateTimeStamp, inner: signed_certificate_timestamp_list() }, CertificateRequestExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::OidFilters, inner: oid_filter_extension() }, Cond { cond: !(extension_type == ExtensionType::SignatureAlgorithms || extension_type == ExtensionType::CertificateAuthorities || extension_type == ExtensionType::SignatureAlgorithmsCert || extension_type == ExtensionType::StatusRequest || extension_type == ExtensionType::SignedCertificateTimeStamp || extension_type == ExtensionType::OidFilters), inner: bytes::Variable((usize::ex_from(ext_len)) as usize) })))))))))))), mapper: CertificateRequestExtensionExtensionDataMapper }));
+    // assert({
+    //     &&& combinator@ == spec_certificate_request_extension_extension_data(ext_len@, extension_type@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_max_fragment_length<'a>(input: &'a [u8]) -> (res: PResult<<MaxFragmentLengthCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_request_extension_extension_data<'a>(input: &'a [u8], ext_len: u16, extension_type: u16) -> (res: PResult<<CertificateRequestExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_max_fragment_length().spec_parse(input@) == Some((n as int, v@)),
-        spec_max_fragment_length().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_max_fragment_length().spec_parse(input@) is None,
-        spec_max_fragment_length().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None,
+        spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = max_fragment_length();
+    let combinator = certificate_request_extension_extension_data( ext_len, extension_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_max_fragment_length<'a>(v: <MaxFragmentLengthCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_request_extension_extension_data<'a>(v: <CertificateRequestExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16, extension_type: u16) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_max_fragment_length().wf(v@),
+        spec_certificate_request_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_extension_type().wf(extension_type@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_max_fragment_length().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_max_fragment_length().spec_serialize(v@))
+            &&& n == spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@))
         },
 {
-    let combinator = max_fragment_length();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = certificate_request_extension_extension_data( ext_len, extension_type );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn max_fragment_length_len<'a>(v: <MaxFragmentLengthCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_request_extension_extension_data_len<'a>(v: <CertificateRequestExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16, extension_type: u16) -> (serialize_len: usize)
     requires
-        spec_max_fragment_length().wf(v@),
-        spec_max_fragment_length().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_request_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        serialize_len == spec_max_fragment_length().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len(),
 {
-    let combinator = max_fragment_length();
+    let combinator = certificate_request_extension_extension_data( ext_len, extension_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
-pub mod NamedGroup {
-    use super::*;
-    pub spec const SPEC_Sect163k1: u16 = 1;
-    pub spec const SPEC_Sect163r1: u16 = 2;
-    pub spec const SPEC_Sect163r2: u16 = 3;
-    pub spec const SPEC_Sect193r1: u16 = 4;
-    pub spec const SPEC_Sect193r2: u16 = 5;
-    pub spec const SPEC_Sect233k1: u16 = 6;
-    pub spec const SPEC_Sect233r1: u16 = 7;
-    pub spec const SPEC_Sect239k1: u16 = 8;
-    pub spec const SPEC_Sect283k1: u16 = 9;
-    pub spec const SPEC_Sect283r1: u16 = 10;
-    pub spec const SPEC_Sect409k1: u16 = 11;
-    pub spec const SPEC_Sect409r1: u16 = 12;
-    pub spec const SPEC_Sect571k1: u16 = 13;
-    pub spec const SPEC_Sect571r1: u16 = 14;
-    pub spec const SPEC_Secp160k1: u16 = 15;
-    pub spec const SPEC_Secp160r1: u16 = 16;
-    pub spec const SPEC_Secp160r2: u16 = 17;
-    pub spec const SPEC_Secp192k1: u16 = 18;
-    pub spec const SPEC_Secp192r1: u16 = 19;
-    pub spec const SPEC_Secp224k1: u16 = 20;
-    pub spec const SPEC_Secp224r1: u16 = 21;
-    pub spec const SPEC_Secp256k1: u16 = 22;
-    pub spec const SPEC_Secp256r1: u16 = 23;
-    pub spec const SPEC_Secp384r1: u16 = 24;
-    pub spec const SPEC_Secp521r1: u16 = 25;
-    pub spec const SPEC_X25519: u16 = 29;
-    pub spec const SPEC_X448: u16 = 30;
-    pub spec const SPEC_Ffdhe2048: u16 = 256;
-    pub spec const SPEC_Ffdhe3072: u16 = 257;
-    pub spec const SPEC_Ffdhe4096: u16 = 258;
-    pub spec const SPEC_Ffdhe6144: u16 = 259;
-    pub spec const SPEC_Ffdhe8192: u16 = 260;
-    pub exec const Sect163k1: u16 ensures Sect163k1 == SPEC_Sect163k1 { 1 }
-    pub exec const Sect163r1: u16 ensures Sect163r1 == SPEC_Sect163r1 { 2 }
-    pub exec const Sect163r2: u16 ensures Sect163r2 == SPEC_Sect163r2 { 3 }
-    pub exec const Sect193r1: u16 ensures Sect193r1 == SPEC_Sect193r1 { 4 }
-    pub exec const Sect193r2: u16 ensures Sect193r2 == SPEC_Sect193r2 { 5 }
-    pub exec const Sect233k1: u16 ensures Sect233k1 == SPEC_Sect233k1 { 6 }
-    pub exec const Sect233r1: u16 ensures Sect233r1 == SPEC_Sect233r1 { 7 }
-    pub exec const Sect239k1: u16 ensures Sect239k1 == SPEC_Sect239k1 { 8 }
-    pub exec const Sect283k1: u16 ensures Sect283k1 == SPEC_Sect283k1 { 9 }
-    pub exec const Sect283r1: u16 ensures Sect283r1 == SPEC_Sect283r1 { 10 }
-    pub exec const Sect409k1: u16 ensures Sect409k1 == SPEC_Sect409k1 { 11 }
-    pub exec const Sect409r1: u16 ensures Sect409r1 == SPEC_Sect409r1 { 12 }
-    pub exec const Sect571k1: u16 ensures Sect571k1 == SPEC_Sect571k1 { 13 }
-    pub exec const Sect571r1: u16 ensures Sect571r1 == SPEC_Sect571r1 { 14 }
-    pub exec const Secp160k1: u16 ensures Secp160k1 == SPEC_Secp160k1 { 15 }
-    pub exec const Secp160r1: u16 ensures Secp160r1 == SPEC_Secp160r1 { 16 }
-    pub exec const Secp160r2: u16 ensures Secp160r2 == SPEC_Secp160r2 { 17 }
-    pub exec const Secp192k1: u16 ensures Secp192k1 == SPEC_Secp192k1 { 18 }
-    pub exec const Secp192r1: u16 ensures Secp192r1 == SPEC_Secp192r1 { 19 }
-    pub exec const Secp224k1: u16 ensures Secp224k1 == SPEC_Secp224k1 { 20 }
-    pub exec const Secp224r1: u16 ensures Secp224r1 == SPEC_Secp224r1 { 21 }
-    pub exec const Secp256k1: u16 ensures Secp256k1 == SPEC_Secp256k1 { 22 }
-    pub exec const Secp256r1: u16 ensures Secp256r1 == SPEC_Secp256r1 { 23 }
-    pub exec const Secp384r1: u16 ensures Secp384r1 == SPEC_Secp384r1 { 24 }
-    pub exec const Secp521r1: u16 ensures Secp521r1 == SPEC_Secp521r1 { 25 }
-    pub exec const X25519: u16 ensures X25519 == SPEC_X25519 { 29 }
-    pub exec const X448: u16 ensures X448 == SPEC_X448 { 30 }
-    pub exec const Ffdhe2048: u16 ensures Ffdhe2048 == SPEC_Ffdhe2048 { 256 }
-    pub exec const Ffdhe3072: u16 ensures Ffdhe3072 == SPEC_Ffdhe3072 { 257 }
-    pub exec const Ffdhe4096: u16 ensures Ffdhe4096 == SPEC_Ffdhe4096 { 258 }
-    pub exec const Ffdhe6144: u16 ensures Ffdhe6144 == SPEC_Ffdhe6144 { 259 }
-    pub exec const Ffdhe8192: u16 ensures Ffdhe8192 == SPEC_Ffdhe8192 { 260 }
+
+pub struct SpecCertificateRequestExtension {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: SpecCertificateRequestExtensionExtensionData,
 }
 
+pub type SpecCertificateRequestExtensionInner = ((u16, u16), SpecCertificateRequestExtensionExtensionData);
 
-pub struct SpecNamedGroupCombinator(pub SpecNamedGroupCombinatorAlias);
 
-impl SpecCombinator for SpecNamedGroupCombinator {
-    type Type = u16;
+impl SpecFrom<SpecCertificateRequestExtension> for SpecCertificateRequestExtensionInner {
+    open spec fn spec_from(m: SpecCertificateRequestExtension) -> SpecCertificateRequestExtensionInner {
+        ((m.extension_type, m.ext_len), m.extension_data)
+    }
+}
+
+impl SpecFrom<SpecCertificateRequestExtensionInner> for SpecCertificateRequestExtension {
+    open spec fn spec_from(m: SpecCertificateRequestExtensionInner) -> SpecCertificateRequestExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        SpecCertificateRequestExtension { extension_type, ext_len, extension_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct CertificateRequestExtension<'a> {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: CertificateRequestExtensionExtensionData<'a>,
+}
+
+impl View for CertificateRequestExtension<'_> {
+    type V = SpecCertificateRequestExtension;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCertificateRequestExtension {
+            extension_type: self.extension_type@,
+            ext_len: self.ext_len@,
+            extension_data: self.extension_data@,
+        }
+    }
+}
+pub type CertificateRequestExtensionInner<'a> = ((u16, u16), CertificateRequestExtensionExtensionData<'a>);
+
+pub type CertificateRequestExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a CertificateRequestExtensionExtensionData<'a>);
+impl<'a> From<&'a CertificateRequestExtension<'a>> for CertificateRequestExtensionInnerRef<'a> {
+    fn ex_from(m: &'a CertificateRequestExtension) -> CertificateRequestExtensionInnerRef<'a> {
+        ((&m.extension_type, &m.ext_len), &m.extension_data)
+    }
+}
+
+impl<'a> From<CertificateRequestExtensionInner<'a>> for CertificateRequestExtension<'a> {
+    fn ex_from(m: CertificateRequestExtensionInner) -> CertificateRequestExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        CertificateRequestExtension { extension_type, ext_len, extension_data }
+    }
+}
+
+pub struct CertificateRequestExtensionMapper;
+impl View for CertificateRequestExtensionMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CertificateRequestExtensionMapper {
+    type Src = SpecCertificateRequestExtensionInner;
+    type Dst = SpecCertificateRequestExtension;
+}
+impl SpecIsoProof for CertificateRequestExtensionMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CertificateRequestExtensionMapper {
+    type Src = CertificateRequestExtensionInner<'a>;
+    type Dst = CertificateRequestExtension<'a>;
+    type RefSrc = CertificateRequestExtensionInnerRef<'a>;
+}
+
+pub struct SpecCertificateRequestExtensionCombinator(pub SpecCertificateRequestExtensionCombinatorAlias);
+
+impl SpecCombinator for SpecCertificateRequestExtensionCombinator {
+    type Type = SpecCertificateRequestExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecNamedGroupCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecNamedGroupCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateRequestExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateRequestExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecNamedGroupCombinatorAlias = U16Be;
+pub type SpecCertificateRequestExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecCertificateRequestExtensionExtensionDataCombinator>, CertificateRequestExtensionMapper>;
 
-pub struct NamedGroupCombinator(pub NamedGroupCombinatorAlias);
+pub struct CertificateRequestExtensionCombinator(pub CertificateRequestExtensionCombinatorAlias);
 
-impl View for NamedGroupCombinator {
-    type V = SpecNamedGroupCombinator;
-    open spec fn view(&self) -> Self::V { SpecNamedGroupCombinator(self.0@) }
+impl View for CertificateRequestExtensionCombinator {
+    type V = SpecCertificateRequestExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateRequestExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NamedGroupCombinator {
-    type Type = u16;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateRequestExtensionCombinator {
+    type Type = CertificateRequestExtension<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type NamedGroupCombinatorAlias = U16Be;
+}
+pub type CertificateRequestExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, CertificateRequestExtensionCont1>, CertificateRequestExtensionExtensionDataCombinator, CertificateRequestExtensionCont0>, CertificateRequestExtensionMapper>;
 
 
-pub open spec fn spec_named_group() -> SpecNamedGroupCombinator {
-    SpecNamedGroupCombinator(U16Be)
+pub open spec fn spec_certificate_request_extension() -> SpecCertificateRequestExtensionCombinator {
+    SpecCertificateRequestExtensionCombinator(
+    Mapped {
+        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_certificate_request_extension_cont1(deps)), |deps| spec_certificate_request_extension_cont0(deps)),
+        mapper: CertificateRequestExtensionMapper,
+    })
+}
+
+pub open spec fn spec_certificate_request_extension_cont1(deps: u16) -> U16Be {
+    let extension_type = deps;
+    U16Be
+}
+
+impl View for CertificateRequestExtensionCont1 {
+    type V = spec_fn(u16) -> U16Be;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_certificate_request_extension_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_certificate_request_extension_cont0(deps: (u16, u16)) -> SpecCertificateRequestExtensionExtensionDataCombinator {
+    let (extension_type, ext_len) = deps;
+    spec_certificate_request_extension_extension_data(ext_len, extension_type)
+}
+
+impl View for CertificateRequestExtensionCont0 {
+    type V = spec_fn((u16, u16)) -> SpecCertificateRequestExtensionExtensionDataCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u16, u16)| {
+            spec_certificate_request_extension_cont0(deps)
+        }
+    }
 }
 
                 
-pub fn named_group<'a>() -> (o: NamedGroupCombinator)
-    ensures o@ == spec_named_group(),
+pub fn certificate_request_extension<'a>() -> (o: CertificateRequestExtensionCombinator)
+    ensures o@ == spec_certificate_request_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = NamedGroupCombinator(U16Be);
-    assert({
-        &&& combinator@ == spec_named_group()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = CertificateRequestExtensionCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(extension_type(), CertificateRequestExtensionCont1), CertificateRequestExtensionCont0),
+        mapper: CertificateRequestExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_request_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_named_group<'a>(input: &'a [u8]) -> (res: PResult<<NamedGroupCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_request_extension<'a>(input: &'a [u8]) -> (res: PResult<<CertificateRequestExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_named_group().spec_parse(input@) == Some((n as int, v@)),
-        spec_named_group().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_request_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_request_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_named_group().spec_parse(input@) is None,
-        spec_named_group().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_request_extension().spec_parse(input@) is None,
+        spec_certificate_request_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = named_group();
+    let combinator = certificate_request_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_named_group<'a>(v: <NamedGroupCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_request_extension<'a>(v: <CertificateRequestExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_named_group().wf(v@),
+        spec_certificate_request_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_named_group().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_named_group().spec_serialize(v@))
+            &&& n == spec_certificate_request_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_request_extension().spec_serialize(v@))
         },
 {
-    let combinator = named_group();
+    let combinator = certificate_request_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn named_group_len<'a>(v: <NamedGroupCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_request_extension_len<'a>(v: <CertificateRequestExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_named_group().wf(v@),
-        spec_named_group().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_request_extension().wf(v@),
+        spec_certificate_request_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_named_group().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_request_extension().spec_serialize(v@).len(),
 {
-    let combinator = named_group();
+    let combinator = certificate_request_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
-
-pub struct SpecNamedGroupList {
-    pub l: u16,
-    pub list: Seq<u16>,
-}
-
-pub type SpecNamedGroupListInner = (u16, Seq<u16>);
-
+pub struct CertificateRequestExtensionCont1;
+type CertificateRequestExtensionCont1Type<'a, 'b> = &'b u16;
+type CertificateRequestExtensionCont1SType<'a, 'x> = &'x u16;
+type CertificateRequestExtensionCont1Input<'a, 'b, 'x> = POrSType<CertificateRequestExtensionCont1Type<'a, 'b>, CertificateRequestExtensionCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CertificateRequestExtensionCont1Input<'a, 'b, 'x>> for CertificateRequestExtensionCont1 {
+    type Output = U16Be;
 
-impl SpecFrom<SpecNamedGroupList> for SpecNamedGroupListInner {
-    open spec fn spec_from(m: SpecNamedGroupList) -> SpecNamedGroupListInner {
-        (m.l, m.list)
-    }
-}
+    open spec fn requires(&self, deps: CertificateRequestExtensionCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_extension_type()).wf(deps@)
+        }
 
-impl SpecFrom<SpecNamedGroupListInner> for SpecNamedGroupList {
-    open spec fn spec_from(m: SpecNamedGroupListInner) -> SpecNamedGroupList {
-        let (l, list) = m;
-        SpecNamedGroupList { l, list }
+    open spec fn ensures(&self, deps: CertificateRequestExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_certificate_request_extension_cont1(deps@)
     }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct NamedGroupList {
-    pub l: u16,
-    pub list: RepeatResult<u16>,
-}
-
-impl View for NamedGroupList {
-    type V = SpecNamedGroupList;
 
-    open spec fn view(&self) -> Self::V {
-        SpecNamedGroupList {
-            l: self.l@,
-            list: self.list@,
+    fn apply(&self, deps: CertificateRequestExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
+            }
+            POrSType::S(deps) => {
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
+            }
         }
     }
 }
-pub type NamedGroupListInner = (u16, RepeatResult<u16>);
+pub struct CertificateRequestExtensionCont0;
+type CertificateRequestExtensionCont0Type<'a, 'b> = &'b (u16, u16);
+type CertificateRequestExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
+type CertificateRequestExtensionCont0Input<'a, 'b, 'x> = POrSType<CertificateRequestExtensionCont0Type<'a, 'b>, CertificateRequestExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CertificateRequestExtensionCont0Input<'a, 'b, 'x>> for CertificateRequestExtensionCont0 {
+    type Output = CertificateRequestExtensionExtensionDataCombinator;
 
-pub type NamedGroupListInnerRef<'a> = (&'a u16, &'a RepeatResult<u16>);
-impl<'a> From<&'a NamedGroupList> for NamedGroupListInnerRef<'a> {
-    fn ex_from(m: &'a NamedGroupList) -> NamedGroupListInnerRef<'a> {
-        (&m.l, &m.list)
-    }
-}
+    open spec fn requires(&self, deps: CertificateRequestExtensionCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_extension_type(), |deps| spec_certificate_request_extension_cont1(deps))).wf(deps@)
+        }
 
-impl From<NamedGroupListInner> for NamedGroupList {
-    fn ex_from(m: NamedGroupListInner) -> NamedGroupList {
-        let (l, list) = m;
-        NamedGroupList { l, list }
+    open spec fn ensures(&self, deps: CertificateRequestExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_certificate_request_extension_cont0(deps@)
     }
-}
 
-pub struct NamedGroupListMapper;
-impl View for NamedGroupListMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for NamedGroupListMapper {
-    type Src = SpecNamedGroupListInner;
-    type Dst = SpecNamedGroupList;
-}
-impl SpecIsoProof for NamedGroupListMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    fn apply(&self, deps: CertificateRequestExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                certificate_request_extension_extension_data(ext_len, extension_type)
+            }
+            POrSType::S(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                certificate_request_extension_extension_data(ext_len, extension_type)
+            }
+        }
     }
 }
-impl<'a> Iso<'a> for NamedGroupListMapper {
-    type Src = NamedGroupListInner;
-    type Dst = NamedGroupList;
-    type RefSrc = NamedGroupListInnerRef<'a>;
+                
+pub mod NameType {
+    use super::*;
+    pub spec const SPEC_HostName: u8 = 0;
+    pub exec const HostName: u8 ensures HostName == SPEC_HostName { 0 }
 }
 
-pub struct SpecNamedGroupListCombinator(pub SpecNamedGroupListCombinatorAlias);
 
-impl SpecCombinator for SpecNamedGroupListCombinator {
-    type Type = SpecNamedGroupList;
+pub struct SpecNameTypeCombinator(pub SpecNameTypeCombinatorAlias);
+
+impl SpecCombinator for SpecNameTypeCombinator {
+    type Type = u8;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecNamedGroupListCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecNamedGroupListCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecNameTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNameTypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecNamedGroupListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<SpecNamedGroupCombinator>>>, NamedGroupListMapper>;
-pub struct Predicate8195707947578446211;
-impl View for Predicate8195707947578446211 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u16> for Predicate8195707947578446211 {
-    fn apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 2 && i <= 65535)
-    }
-}
-impl SpecPred<u16> for Predicate8195707947578446211 {
-    open spec fn spec_apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 2 && i <= 65535)
-    }
-}
+pub type SpecNameTypeCombinatorAlias = U8;
 
-pub struct NamedGroupListCombinator(pub NamedGroupListCombinatorAlias);
+pub struct NameTypeCombinator(pub NameTypeCombinatorAlias);
 
-impl View for NamedGroupListCombinator {
-    type V = SpecNamedGroupListCombinator;
-    open spec fn view(&self) -> Self::V { SpecNamedGroupListCombinator(self.0@) }
+impl View for NameTypeCombinator {
+    type V = SpecNameTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecNameTypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NamedGroupListCombinator {
-    type Type = NamedGroupList;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NameTypeCombinator {
+    type Type = u8;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type NamedGroupListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<NamedGroupCombinator>>, NamedGroupListCont0>, NamedGroupListMapper>;
-
-
-pub open spec fn spec_named_group_list() -> SpecNamedGroupListCombinator {
-    SpecNamedGroupListCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, |deps| spec_named_group_list_cont0(deps)),
-        mapper: NamedGroupListMapper,
-    })
-}
-
-pub open spec fn spec_named_group_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecNamedGroupCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_named_group()))
 }
+pub type NameTypeCombinatorAlias = U8;
 
-impl View for NamedGroupListCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecNamedGroupCombinator>>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_named_group_list_cont0(deps)
-        }
-    }
+pub open spec fn spec_name_type() -> SpecNameTypeCombinator {
+    SpecNameTypeCombinator(U8)
 }
 
                 
-pub fn named_group_list<'a>() -> (o: NamedGroupListCombinator)
-    ensures o@ == spec_named_group_list(),
+pub fn name_type<'a>() -> (o: NameTypeCombinator)
+    ensures o@ == spec_name_type(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = NamedGroupListCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, NamedGroupListCont0),
-        mapper: NamedGroupListMapper,
-    });
-    assert({
-        &&& combinator@ == spec_named_group_list()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = NameTypeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_name_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_named_group_list<'a>(input: &'a [u8]) -> (res: PResult<<NamedGroupListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_name_type<'a>(input: &'a [u8]) -> (res: PResult<<NameTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_named_group_list().spec_parse(input@) == Some((n as int, v@)),
-        spec_named_group_list().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_name_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_name_type().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_named_group_list().spec_parse(input@) is None,
-        spec_named_group_list().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_name_type().spec_parse(input@) is None,
+        spec_name_type().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = named_group_list();
+    let combinator = name_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_named_group_list<'a>(v: <NamedGroupListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_name_type<'a>(v: <NameTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_named_group_list().wf(v@),
+        spec_name_type().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_named_group_list().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_named_group_list().spec_serialize(v@))
+            &&& n == spec_name_type().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_name_type().spec_serialize(v@))
         },
 {
-    let combinator = named_group_list();
+    let combinator = name_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn named_group_list_len<'a>(v: <NamedGroupListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn name_type_len<'a>(v: <NameTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_named_group_list().wf(v@),
-        spec_named_group_list().spec_serialize(v@).len() <= usize::MAX,
+        spec_name_type().wf(v@),
+        spec_name_type().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_named_group_list().spec_serialize(v@).len(),
+        serialize_len == spec_name_type().spec_serialize(v@).len(),
 {
-    let combinator = named_group_list();
+    let combinator = name_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct NamedGroupListCont0;
-type NamedGroupListCont0Type<'a, 'b> = &'b u16;
-type NamedGroupListCont0SType<'a, 'x> = &'x u16;
-type NamedGroupListCont0Input<'a, 'b, 'x> = POrSType<NamedGroupListCont0Type<'a, 'b>, NamedGroupListCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<NamedGroupListCont0Input<'a, 'b, 'x>> for NamedGroupListCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<NamedGroupCombinator>>;
+                
+
+pub struct SpecSessionId {
+    pub l: u8,
+    pub id: Seq<u8>,
+}
 
-    open spec fn requires(&self, deps: NamedGroupListCont0Input<'a, 'b, 'x>) -> bool { true }
+pub type SpecSessionIdInner = (u8, Seq<u8>);
 
-    open spec fn ensures(&self, deps: NamedGroupListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_named_group_list_cont0(deps@)
+
+impl SpecFrom<SpecSessionId> for SpecSessionIdInner {
+    open spec fn spec_from(m: SpecSessionId) -> SpecSessionIdInner {
+        (m.l, m.id)
     }
+}
 
-    fn apply(&self, deps: NamedGroupListCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(named_group()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(named_group()))
-            }
-        }
-    }
-}
-                
-pub mod HeartbeatMode {
-    use super::*;
-    pub spec const SPEC_PeerAllowedToSend: u8 = 1;
-    pub spec const SPEC_PeerNotAllowedToSend: u8 = 2;
-    pub exec const PeerAllowedToSend: u8 ensures PeerAllowedToSend == SPEC_PeerAllowedToSend { 1 }
-    pub exec const PeerNotAllowedToSend: u8 ensures PeerNotAllowedToSend == SPEC_PeerNotAllowedToSend { 2 }
-}
-
-
-pub struct SpecHeartbeatModeCombinator(pub SpecHeartbeatModeCombinatorAlias);
-
-impl SpecCombinator for SpecHeartbeatModeCombinator {
-    type Type = u8;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecHeartbeatModeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecHeartbeatModeCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
-}
-pub type SpecHeartbeatModeCombinatorAlias = U8;
-
-pub struct HeartbeatModeCombinator(pub HeartbeatModeCombinatorAlias);
-
-impl View for HeartbeatModeCombinator {
-    type V = SpecHeartbeatModeCombinator;
-    open spec fn view(&self) -> Self::V { SpecHeartbeatModeCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeartbeatModeCombinator {
-    type Type = u8;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type HeartbeatModeCombinatorAlias = U8;
-
-
-pub open spec fn spec_heartbeat_mode() -> SpecHeartbeatModeCombinator {
-    SpecHeartbeatModeCombinator(U8)
-}
-
-                
-pub fn heartbeat_mode<'a>() -> (o: HeartbeatModeCombinator)
-    ensures o@ == spec_heartbeat_mode(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = HeartbeatModeCombinator(U8);
-    assert({
-        &&& combinator@ == spec_heartbeat_mode()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
-
-pub fn parse_heartbeat_mode<'a>(input: &'a [u8]) -> (res: PResult<<HeartbeatModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_heartbeat_mode().spec_parse(input@) == Some((n as int, v@)),
-        spec_heartbeat_mode().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_heartbeat_mode().spec_parse(input@) is None,
-        spec_heartbeat_mode().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = heartbeat_mode();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
-}
-
-pub fn serialize_heartbeat_mode<'a>(v: <HeartbeatModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_heartbeat_mode().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_heartbeat_mode().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_heartbeat_mode().spec_serialize(v@))
-        },
-{
-    let combinator = heartbeat_mode();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
-}
-
-pub fn heartbeat_mode_len<'a>(v: <HeartbeatModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_heartbeat_mode().wf(v@),
-        spec_heartbeat_mode().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_heartbeat_mode().spec_serialize(v@).len(),
-{
-    let combinator = heartbeat_mode();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
-}
-
-                
-
-pub struct SpecOpaque1Ff {
-    pub l: u8,
-    pub data: Seq<u8>,
-}
-
-pub type SpecOpaque1FfInner = (u8, Seq<u8>);
-
-
-impl SpecFrom<SpecOpaque1Ff> for SpecOpaque1FfInner {
-    open spec fn spec_from(m: SpecOpaque1Ff) -> SpecOpaque1FfInner {
-        (m.l, m.data)
-    }
-}
-
-impl SpecFrom<SpecOpaque1FfInner> for SpecOpaque1Ff {
-    open spec fn spec_from(m: SpecOpaque1FfInner) -> SpecOpaque1Ff {
-        let (l, data) = m;
-        SpecOpaque1Ff { l, data }
+impl SpecFrom<SpecSessionIdInner> for SpecSessionId {
+    open spec fn spec_from(m: SpecSessionIdInner) -> SpecSessionId {
+        let (l, id) = m;
+        SpecSessionId { l, id }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Opaque1Ff<'a> {
+pub struct SessionId<'a> {
     pub l: u8,
-    pub data: &'a [u8],
+    pub id: &'a [u8],
 }
 
-impl View for Opaque1Ff<'_> {
-    type V = SpecOpaque1Ff;
+impl View for SessionId<'_> {
+    type V = SpecSessionId;
 
     open spec fn view(&self) -> Self::V {
-        SpecOpaque1Ff {
+        SpecSessionId {
             l: self.l@,
-            data: self.data@,
+            id: self.id@,
         }
     }
 }
-pub type Opaque1FfInner<'a> = (u8, &'a [u8]);
+pub type SessionIdInner<'a> = (u8, &'a [u8]);
 
-pub type Opaque1FfInnerRef<'a> = (&'a u8, &'a &'a [u8]);
-impl<'a> From<&'a Opaque1Ff<'a>> for Opaque1FfInnerRef<'a> {
-    fn ex_from(m: &'a Opaque1Ff) -> Opaque1FfInnerRef<'a> {
-        (&m.l, &m.data)
+pub type SessionIdInnerRef<'a> = (&'a u8, &'a &'a [u8]);
+impl<'a> From<&'a SessionId<'a>> for SessionIdInnerRef<'a> {
+    fn ex_from(m: &'a SessionId) -> SessionIdInnerRef<'a> {
+        (&m.l, &m.id)
     }
 }
 
-impl<'a> From<Opaque1FfInner<'a>> for Opaque1Ff<'a> {
-    fn ex_from(m: Opaque1FfInner) -> Opaque1Ff {
-        let (l, data) = m;
-        Opaque1Ff { l, data }
+impl<'a> From<SessionIdInner<'a>> for SessionId<'a> {
+    fn ex_from(m: SessionIdInner) -> SessionId {
+        let (l, id) = m;
+        SessionId { l, id }
     }
 }
 
-pub struct Opaque1FfMapper;
-impl View for Opaque1FfMapper {
+pub struct SessionIdMapper;
+impl View for SessionIdMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for Opaque1FfMapper {
-    type Src = SpecOpaque1FfInner;
-    type Dst = SpecOpaque1Ff;
+impl SpecIso for SessionIdMapper {
+    type Src = SpecSessionIdInner;
+    type Dst = SpecSessionId;
 }
-impl SpecIsoProof for Opaque1FfMapper {
+impl SpecIsoProof for SessionIdMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -4988,1226 +4661,900 @@ impl SpecIsoProof for Opaque1FfMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for Opaque1FfMapper {
-    type Src = Opaque1FfInner<'a>;
-    type Dst = Opaque1Ff<'a>;
-    type RefSrc = Opaque1FfInnerRef<'a>;
+impl<'a> Iso<'a> for SessionIdMapper {
+    type Src = SessionIdInner<'a>;
+    type Dst = SessionId<'a>;
+    type RefSrc = SessionIdInnerRef<'a>;
 }
 
-pub struct SpecOpaque1FfCombinator(pub SpecOpaque1FfCombinatorAlias);
+pub struct SpecSessionIdCombinator(pub SpecSessionIdCombinatorAlias);
 
-impl SpecCombinator for SpecOpaque1FfCombinator {
-    type Type = SpecOpaque1Ff;
+impl SpecCombinator for SpecSessionIdCombinator {
+    type Type = SpecSessionId;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOpaque1FfCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOpaque1FfCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSessionIdCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSessionIdCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOpaque1FfCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate3651688686135228051>, bytes::Variable>, Opaque1FfMapper>;
-pub struct Predicate3651688686135228051;
-impl View for Predicate3651688686135228051 {
+pub type SpecSessionIdCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate14254733753739482027>, bytes::Variable>, SessionIdMapper>;
+pub struct Predicate14254733753739482027;
+impl View for Predicate14254733753739482027 {
     type V = Self;
 
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl Pred<u8> for Predicate3651688686135228051 {
+impl Pred<u8> for Predicate14254733753739482027 {
     fn apply(&self, i: &u8) -> bool {
         let i = (*i);
-        (i >= 1 && i <= 255)
+        (i >= 0 && i <= 32)
     }
 }
-impl SpecPred<u8> for Predicate3651688686135228051 {
+impl SpecPred<u8> for Predicate14254733753739482027 {
     open spec fn spec_apply(&self, i: &u8) -> bool {
         let i = (*i);
-        (i >= 1 && i <= 255)
+        (i >= 0 && i <= 32)
     }
 }
 
-pub struct Opaque1FfCombinator(pub Opaque1FfCombinatorAlias);
+pub struct SessionIdCombinator(pub SessionIdCombinatorAlias);
 
-impl View for Opaque1FfCombinator {
-    type V = SpecOpaque1FfCombinator;
-    open spec fn view(&self) -> Self::V { SpecOpaque1FfCombinator(self.0@) }
+impl View for SessionIdCombinator {
+    type V = SpecSessionIdCombinator;
+    open spec fn view(&self) -> Self::V { SpecSessionIdCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque1FfCombinator {
-    type Type = Opaque1Ff<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SessionIdCombinator {
+    type Type = SessionId<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type Opaque1FfCombinatorAlias = Mapped<Pair<Refined<U8, Predicate3651688686135228051>, bytes::Variable, Opaque1FfCont0>, Opaque1FfMapper>;
+}
+pub type SessionIdCombinatorAlias = Mapped<Pair<Refined<U8, Predicate14254733753739482027>, bytes::Variable, SessionIdCont0>, SessionIdMapper>;
 
 
-pub open spec fn spec_opaque_1_ff() -> SpecOpaque1FfCombinator {
-    SpecOpaque1FfCombinator(
+pub open spec fn spec_session_id() -> SpecSessionIdCombinator {
+    SpecSessionIdCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate3651688686135228051 }, |deps| spec_opaque1_ff_cont0(deps)),
-        mapper: Opaque1FfMapper,
+        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate14254733753739482027 }, |deps| spec_session_id_cont0(deps)),
+        mapper: SessionIdMapper,
     })
 }
 
-pub open spec fn spec_opaque1_ff_cont0(deps: u8) -> bytes::Variable {
+pub open spec fn spec_session_id_cont0(deps: u8) -> bytes::Variable {
     let l = deps;
-    bytes::Variable(l.spec_into())
+    bytes::Variable((usize::spec_from(l)) as usize)
 }
 
-impl View for Opaque1FfCont0 {
+impl View for SessionIdCont0 {
     type V = spec_fn(u8) -> bytes::Variable;
 
     open spec fn view(&self) -> Self::V {
         |deps: u8| {
-            spec_opaque1_ff_cont0(deps)
+            spec_session_id_cont0(deps)
         }
     }
 }
 
                 
-pub fn opaque_1_ff<'a>() -> (o: Opaque1FfCombinator)
-    ensures o@ == spec_opaque_1_ff(),
+pub fn session_id<'a>() -> (o: SessionIdCombinator)
+    ensures o@ == spec_session_id(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = Opaque1FfCombinator(
+    let combinator = SessionIdCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U8, predicate: Predicate3651688686135228051 }, Opaque1FfCont0),
-        mapper: Opaque1FfMapper,
-    });
-    assert({
-        &&& combinator@ == spec_opaque_1_ff()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U8, predicate: Predicate14254733753739482027 }, SessionIdCont0),
+        mapper: SessionIdMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_session_id()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_opaque_1_ff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque1FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_session_id<'a>(input: &'a [u8]) -> (res: PResult<<SessionIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_opaque_1_ff().spec_parse(input@) == Some((n as int, v@)),
-        spec_opaque_1_ff().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_session_id().spec_parse(input@) == Some((n as int, v@)),
+        spec_session_id().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_opaque_1_ff().spec_parse(input@) is None,
-        spec_opaque_1_ff().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_session_id().spec_parse(input@) is None,
+        spec_session_id().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = opaque_1_ff();
+    let combinator = session_id();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_opaque_1_ff<'a>(v: <Opaque1FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_session_id<'a>(v: <SessionIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_opaque_1_ff().wf(v@),
+        spec_session_id().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_opaque_1_ff().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_1_ff().spec_serialize(v@))
+            &&& n == spec_session_id().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_session_id().spec_serialize(v@))
         },
 {
-    let combinator = opaque_1_ff();
+    let combinator = session_id();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn opaque_1_ff_len<'a>(v: <Opaque1FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn session_id_len<'a>(v: <SessionIdCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_opaque_1_ff().wf(v@),
-        spec_opaque_1_ff().spec_serialize(v@).len() <= usize::MAX,
+        spec_session_id().wf(v@),
+        spec_session_id().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_opaque_1_ff().spec_serialize(v@).len(),
+        serialize_len == spec_session_id().spec_serialize(v@).len(),
 {
-    let combinator = opaque_1_ff();
+    let combinator = session_id();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct Opaque1FfCont0;
-type Opaque1FfCont0Type<'a, 'b> = &'b u8;
-type Opaque1FfCont0SType<'a, 'x> = &'x u8;
-type Opaque1FfCont0Input<'a, 'b, 'x> = POrSType<Opaque1FfCont0Type<'a, 'b>, Opaque1FfCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<Opaque1FfCont0Input<'a, 'b, 'x>> for Opaque1FfCont0 {
+pub struct SessionIdCont0;
+type SessionIdCont0Type<'a, 'b> = &'b u8;
+type SessionIdCont0SType<'a, 'x> = &'x u8;
+type SessionIdCont0Input<'a, 'b, 'x> = POrSType<SessionIdCont0Type<'a, 'b>, SessionIdCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<SessionIdCont0Input<'a, 'b, 'x>> for SessionIdCont0 {
     type Output = bytes::Variable;
 
-    open spec fn requires(&self, deps: Opaque1FfCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: SessionIdCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U8, predicate: Predicate14254733753739482027 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: Opaque1FfCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_opaque1_ff_cont0(deps@)
+    open spec fn ensures(&self, deps: SessionIdCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_session_id_cont0(deps@)
     }
 
-    fn apply(&self, deps: Opaque1FfCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: SessionIdCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                bytes::Variable(l.ex_into())
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
-pub type SpecProtocolName = SpecOpaque1Ff;
-pub type ProtocolName<'a> = Opaque1Ff<'a>;
-pub type ProtocolNameRef<'a> = &'a Opaque1Ff<'a>;
+pub mod CipherSuite {
+    use super::*;
+    pub spec const SPEC_TLS_AES_128_GCM_SHA256: u16 = 4865;
+    pub spec const SPEC_TLS_AES_256_GCM_SHA384: u16 = 4866;
+    pub spec const SPEC_TLS_CHACHA20_POLY1305_SHA256: u16 = 4867;
+    pub spec const SPEC_TLS_AES_128_CCM_SHA256: u16 = 4868;
+    pub spec const SPEC_TLS_AES_128_CCM_8_SHA256: u16 = 4869;
+    pub exec const TLS_AES_128_GCM_SHA256: u16 ensures TLS_AES_128_GCM_SHA256 == SPEC_TLS_AES_128_GCM_SHA256 { 4865 }
+    pub exec const TLS_AES_256_GCM_SHA384: u16 ensures TLS_AES_256_GCM_SHA384 == SPEC_TLS_AES_256_GCM_SHA384 { 4866 }
+    pub exec const TLS_CHACHA20_POLY1305_SHA256: u16 ensures TLS_CHACHA20_POLY1305_SHA256 == SPEC_TLS_CHACHA20_POLY1305_SHA256 { 4867 }
+    pub exec const TLS_AES_128_CCM_SHA256: u16 ensures TLS_AES_128_CCM_SHA256 == SPEC_TLS_AES_128_CCM_SHA256 { 4868 }
+    pub exec const TLS_AES_128_CCM_8_SHA256: u16 ensures TLS_AES_128_CCM_8_SHA256 == SPEC_TLS_AES_128_CCM_8_SHA256 { 4869 }
+}
 
 
-pub struct SpecProtocolNameCombinator(pub SpecProtocolNameCombinatorAlias);
+pub struct SpecCipherSuiteCombinator(pub SpecCipherSuiteCombinatorAlias);
 
-impl SpecCombinator for SpecProtocolNameCombinator {
-    type Type = SpecProtocolName;
+impl SpecCombinator for SpecCipherSuiteCombinator {
+    type Type = u16;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecProtocolNameCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecProtocolNameCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCipherSuiteCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCipherSuiteCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecProtocolNameCombinatorAlias = SpecOpaque1FfCombinator;
+pub type SpecCipherSuiteCombinatorAlias = U16Be;
 
-pub struct ProtocolNameCombinator(pub ProtocolNameCombinatorAlias);
+pub struct CipherSuiteCombinator(pub CipherSuiteCombinatorAlias);
 
-impl View for ProtocolNameCombinator {
-    type V = SpecProtocolNameCombinator;
-    open spec fn view(&self) -> Self::V { SpecProtocolNameCombinator(self.0@) }
+impl View for CipherSuiteCombinator {
+    type V = SpecCipherSuiteCombinator;
+    open spec fn view(&self) -> Self::V { SpecCipherSuiteCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProtocolNameCombinator {
-    type Type = ProtocolName<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CipherSuiteCombinator {
+    type Type = u16;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ProtocolNameCombinatorAlias = Opaque1FfCombinator;
+}
+pub type CipherSuiteCombinatorAlias = U16Be;
 
 
-pub open spec fn spec_protocol_name() -> SpecProtocolNameCombinator {
-    SpecProtocolNameCombinator(spec_opaque_1_ff())
+pub open spec fn spec_cipher_suite() -> SpecCipherSuiteCombinator {
+    SpecCipherSuiteCombinator(U16Be)
 }
 
                 
-pub fn protocol_name<'a>() -> (o: ProtocolNameCombinator)
-    ensures o@ == spec_protocol_name(),
+pub fn cipher_suite<'a>() -> (o: CipherSuiteCombinator)
+    ensures o@ == spec_cipher_suite(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ProtocolNameCombinator(opaque_1_ff());
-    assert({
-        &&& combinator@ == spec_protocol_name()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = CipherSuiteCombinator(U16Be);
+    // assert({
+    //     &&& combinator@ == spec_cipher_suite()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_protocol_name<'a>(input: &'a [u8]) -> (res: PResult<<ProtocolNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_cipher_suite<'a>(input: &'a [u8]) -> (res: PResult<<CipherSuiteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_protocol_name().spec_parse(input@) == Some((n as int, v@)),
-        spec_protocol_name().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_cipher_suite().spec_parse(input@) == Some((n as int, v@)),
+        spec_cipher_suite().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_protocol_name().spec_parse(input@) is None,
-        spec_protocol_name().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_cipher_suite().spec_parse(input@) is None,
+        spec_cipher_suite().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = protocol_name();
+    let combinator = cipher_suite();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_protocol_name<'a>(v: <ProtocolNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_cipher_suite<'a>(v: <CipherSuiteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_protocol_name().wf(v@),
+        spec_cipher_suite().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_protocol_name().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_protocol_name().spec_serialize(v@))
+            &&& n == spec_cipher_suite().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_cipher_suite().spec_serialize(v@))
         },
 {
-    let combinator = protocol_name();
+    let combinator = cipher_suite();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn protocol_name_len<'a>(v: <ProtocolNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn cipher_suite_len<'a>(v: <CipherSuiteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_protocol_name().wf(v@),
-        spec_protocol_name().spec_serialize(v@).len() <= usize::MAX,
+        spec_cipher_suite().wf(v@),
+        spec_cipher_suite().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_protocol_name().spec_serialize(v@).len(),
+        serialize_len == spec_cipher_suite().spec_serialize(v@).len(),
 {
-    let combinator = protocol_name();
+    let combinator = cipher_suite();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-
-pub struct SpecProtocolNameList {
-    pub l: u16,
-    pub list: Seq<SpecProtocolName>,
-}
-
-pub type SpecProtocolNameListInner = (u16, Seq<SpecProtocolName>);
-
-
-impl SpecFrom<SpecProtocolNameList> for SpecProtocolNameListInner {
-    open spec fn spec_from(m: SpecProtocolNameList) -> SpecProtocolNameListInner {
-        (m.l, m.list)
-    }
-}
-
-impl SpecFrom<SpecProtocolNameListInner> for SpecProtocolNameList {
-    open spec fn spec_from(m: SpecProtocolNameListInner) -> SpecProtocolNameList {
-        let (l, list) = m;
-        SpecProtocolNameList { l, list }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct ProtocolNameList<'a> {
-    pub l: u16,
-    pub list: RepeatResult<ProtocolName<'a>>,
-}
-
-impl View for ProtocolNameList<'_> {
-    type V = SpecProtocolNameList;
-
-    open spec fn view(&self) -> Self::V {
-        SpecProtocolNameList {
-            l: self.l@,
-            list: self.list@,
-        }
-    }
-}
-pub type ProtocolNameListInner<'a> = (u16, RepeatResult<ProtocolName<'a>>);
-
-pub type ProtocolNameListInnerRef<'a> = (&'a u16, &'a RepeatResult<ProtocolName<'a>>);
-impl<'a> From<&'a ProtocolNameList<'a>> for ProtocolNameListInnerRef<'a> {
-    fn ex_from(m: &'a ProtocolNameList) -> ProtocolNameListInnerRef<'a> {
-        (&m.l, &m.list)
-    }
-}
-
-impl<'a> From<ProtocolNameListInner<'a>> for ProtocolNameList<'a> {
-    fn ex_from(m: ProtocolNameListInner) -> ProtocolNameList {
-        let (l, list) = m;
-        ProtocolNameList { l, list }
-    }
+pub mod ProtocolVersion {
+    use super::*;
+    pub spec const SPEC_SSLv3: u16 = 768;
+    pub spec const SPEC_TLSv1_0: u16 = 769;
+    pub spec const SPEC_TLSv1_1: u16 = 770;
+    pub spec const SPEC_TLSv1_2: u16 = 771;
+    pub spec const SPEC_TLSv1_3: u16 = 772;
+    pub exec const SSLv3: u16 ensures SSLv3 == SPEC_SSLv3 { 768 }
+    pub exec const TLSv1_0: u16 ensures TLSv1_0 == SPEC_TLSv1_0 { 769 }
+    pub exec const TLSv1_1: u16 ensures TLSv1_1 == SPEC_TLSv1_1 { 770 }
+    pub exec const TLSv1_2: u16 ensures TLSv1_2 == SPEC_TLSv1_2 { 771 }
+    pub exec const TLSv1_3: u16 ensures TLSv1_3 == SPEC_TLSv1_3 { 772 }
 }
 
-pub struct ProtocolNameListMapper;
-impl View for ProtocolNameListMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ProtocolNameListMapper {
-    type Src = SpecProtocolNameListInner;
-    type Dst = SpecProtocolNameList;
-}
-impl SpecIsoProof for ProtocolNameListMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for ProtocolNameListMapper {
-    type Src = ProtocolNameListInner<'a>;
-    type Dst = ProtocolNameList<'a>;
-    type RefSrc = ProtocolNameListInnerRef<'a>;
-}
 
-pub struct SpecProtocolNameListCombinator(pub SpecProtocolNameListCombinatorAlias);
+pub struct SpecProtocolVersionCombinator(pub SpecProtocolVersionCombinatorAlias);
 
-impl SpecCombinator for SpecProtocolNameListCombinator {
-    type Type = SpecProtocolNameList;
+impl SpecCombinator for SpecProtocolVersionCombinator {
+    type Type = u16;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecProtocolNameListCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecProtocolNameListCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecProtocolVersionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecProtocolVersionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecProtocolNameListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<SpecProtocolNameCombinator>>>, ProtocolNameListMapper>;
+pub type SpecProtocolVersionCombinatorAlias = U16Be;
 
-pub struct ProtocolNameListCombinator(pub ProtocolNameListCombinatorAlias);
+pub struct ProtocolVersionCombinator(pub ProtocolVersionCombinatorAlias);
 
-impl View for ProtocolNameListCombinator {
-    type V = SpecProtocolNameListCombinator;
-    open spec fn view(&self) -> Self::V { SpecProtocolNameListCombinator(self.0@) }
+impl View for ProtocolVersionCombinator {
+    type V = SpecProtocolVersionCombinator;
+    open spec fn view(&self) -> Self::V { SpecProtocolVersionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProtocolNameListCombinator {
-    type Type = ProtocolNameList<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProtocolVersionCombinator {
+    type Type = u16;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ProtocolNameListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<ProtocolNameCombinator>>, ProtocolNameListCont0>, ProtocolNameListMapper>;
+}
+pub type ProtocolVersionCombinatorAlias = U16Be;
 
 
-pub open spec fn spec_protocol_name_list() -> SpecProtocolNameListCombinator {
-    SpecProtocolNameListCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, |deps| spec_protocol_name_list_cont0(deps)),
-        mapper: ProtocolNameListMapper,
-    })
+pub open spec fn spec_protocol_version() -> SpecProtocolVersionCombinator {
+    SpecProtocolVersionCombinator(U16Be)
 }
 
-pub open spec fn spec_protocol_name_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecProtocolNameCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_protocol_name()))
+                
+pub fn protocol_version<'a>() -> (o: ProtocolVersionCombinator)
+    ensures o@ == spec_protocol_version(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ProtocolVersionCombinator(U16Be);
+    // assert({
+    //     &&& combinator@ == spec_protocol_version()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
 }
 
-impl View for ProtocolNameListCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecProtocolNameCombinator>>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_protocol_name_list_cont0(deps)
-        }
-    }
-}
-
-                
-pub fn protocol_name_list<'a>() -> (o: ProtocolNameListCombinator)
-    ensures o@ == spec_protocol_name_list(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = ProtocolNameListCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, ProtocolNameListCont0),
-        mapper: ProtocolNameListMapper,
-    });
-    assert({
-        &&& combinator@ == spec_protocol_name_list()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
-
-pub fn parse_protocol_name_list<'a>(input: &'a [u8]) -> (res: PResult<<ProtocolNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_protocol_version<'a>(input: &'a [u8]) -> (res: PResult<<ProtocolVersionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_protocol_name_list().spec_parse(input@) == Some((n as int, v@)),
-        spec_protocol_name_list().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_protocol_version().spec_parse(input@) == Some((n as int, v@)),
+        spec_protocol_version().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_protocol_name_list().spec_parse(input@) is None,
-        spec_protocol_name_list().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_protocol_version().spec_parse(input@) is None,
+        spec_protocol_version().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = protocol_name_list();
+    let combinator = protocol_version();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_protocol_name_list<'a>(v: <ProtocolNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_protocol_version<'a>(v: <ProtocolVersionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_protocol_name_list().wf(v@),
+        spec_protocol_version().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_protocol_name_list().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_protocol_name_list().spec_serialize(v@))
+            &&& n == spec_protocol_version().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_protocol_version().spec_serialize(v@))
         },
 {
-    let combinator = protocol_name_list();
+    let combinator = protocol_version();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn protocol_name_list_len<'a>(v: <ProtocolNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn protocol_version_len<'a>(v: <ProtocolVersionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_protocol_name_list().wf(v@),
-        spec_protocol_name_list().spec_serialize(v@).len() <= usize::MAX,
+        spec_protocol_version().wf(v@),
+        spec_protocol_version().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_protocol_name_list().spec_serialize(v@).len(),
+        serialize_len == spec_protocol_version().spec_serialize(v@).len(),
 {
-    let combinator = protocol_name_list();
+    let combinator = protocol_version();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ProtocolNameListCont0;
-type ProtocolNameListCont0Type<'a, 'b> = &'b u16;
-type ProtocolNameListCont0SType<'a, 'x> = &'x u16;
-type ProtocolNameListCont0Input<'a, 'b, 'x> = POrSType<ProtocolNameListCont0Type<'a, 'b>, ProtocolNameListCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ProtocolNameListCont0Input<'a, 'b, 'x>> for ProtocolNameListCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<ProtocolNameCombinator>>;
-
-    open spec fn requires(&self, deps: ProtocolNameListCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: ProtocolNameListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_protocol_name_list_cont0(deps@)
-    }
-
-    fn apply(&self, deps: ProtocolNameListCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(protocol_name()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(protocol_name()))
-            }
-        }
-    }
-}
                 
-pub mod CertificateType {
-    use super::*;
-    pub spec const SPEC_X509: u8 = 0;
-    pub spec const SPEC_RawPublicKey: u8 = 2;
-    pub exec const X509: u8 ensures X509 == SPEC_X509 { 0 }
-    pub exec const RawPublicKey: u8 ensures RawPublicKey == SPEC_RawPublicKey { 2 }
-}
 
 
-pub struct SpecCertificateTypeCombinator(pub SpecCertificateTypeCombinatorAlias);
+pub struct SpecSupportedVersionsServerCombinator(pub SpecSupportedVersionsServerCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateTypeCombinator {
-    type Type = u8;
+impl SpecCombinator for SpecSupportedVersionsServerCombinator {
+    type Type = u16;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateTypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateTypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSupportedVersionsServerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSupportedVersionsServerCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateTypeCombinatorAlias = U8;
+pub type SpecSupportedVersionsServerCombinatorAlias = SpecProtocolVersionCombinator;
 
-pub struct CertificateTypeCombinator(pub CertificateTypeCombinatorAlias);
+pub struct SupportedVersionsServerCombinator(pub SupportedVersionsServerCombinatorAlias);
 
-impl View for CertificateTypeCombinator {
-    type V = SpecCertificateTypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateTypeCombinator(self.0@) }
+impl View for SupportedVersionsServerCombinator {
+    type V = SpecSupportedVersionsServerCombinator;
+    open spec fn view(&self) -> Self::V { SpecSupportedVersionsServerCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateTypeCombinator {
-    type Type = u8;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SupportedVersionsServerCombinator {
+    type Type = u16;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateTypeCombinatorAlias = U8;
+}
+pub type SupportedVersionsServerCombinatorAlias = ProtocolVersionCombinator;
 
 
-pub open spec fn spec_certificate_type() -> SpecCertificateTypeCombinator {
-    SpecCertificateTypeCombinator(U8)
+pub open spec fn spec_supported_versions_server() -> SpecSupportedVersionsServerCombinator {
+    SpecSupportedVersionsServerCombinator(spec_protocol_version())
 }
 
                 
-pub fn certificate_type<'a>() -> (o: CertificateTypeCombinator)
-    ensures o@ == spec_certificate_type(),
+pub fn supported_versions_server<'a>() -> (o: SupportedVersionsServerCombinator)
+    ensures o@ == spec_supported_versions_server(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateTypeCombinator(U8);
-    assert({
-        &&& combinator@ == spec_certificate_type()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = SupportedVersionsServerCombinator(protocol_version());
+    // assert({
+    //     &&& combinator@ == spec_supported_versions_server()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_type<'a>(input: &'a [u8]) -> (res: PResult<<CertificateTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_supported_versions_server<'a>(input: &'a [u8]) -> (res: PResult<<SupportedVersionsServerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_type().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_type().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_supported_versions_server().spec_parse(input@) == Some((n as int, v@)),
+        spec_supported_versions_server().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_type().spec_parse(input@) is None,
-        spec_certificate_type().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_supported_versions_server().spec_parse(input@) is None,
+        spec_supported_versions_server().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_type();
+    let combinator = supported_versions_server();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_type<'a>(v: <CertificateTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_supported_versions_server<'a>(v: <SupportedVersionsServerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_type().wf(v@),
+        spec_supported_versions_server().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_type().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_type().spec_serialize(v@))
+            &&& n == spec_supported_versions_server().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_supported_versions_server().spec_serialize(v@))
         },
 {
-    let combinator = certificate_type();
+    let combinator = supported_versions_server();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_type_len<'a>(v: <CertificateTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn supported_versions_server_len<'a>(v: <SupportedVersionsServerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_type().wf(v@),
-        spec_certificate_type().spec_serialize(v@).len() <= usize::MAX,
+        spec_supported_versions_server().wf(v@),
+        spec_supported_versions_server().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_type().spec_serialize(v@).len(),
+        serialize_len == spec_supported_versions_server().spec_serialize(v@).len(),
 {
-    let combinator = certificate_type();
+    let combinator = supported_versions_server();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
+pub type SpecCookie = SpecOpaque1Ffff;
+pub type Cookie<'a> = Opaque1Ffff<'a>;
+pub type CookieRef<'a> = &'a Opaque1Ffff<'a>;
 
-pub struct SpecClientCertTypeClientExtension {
-    pub l: u8,
-    pub list: Seq<u8>,
-}
-
-pub type SpecClientCertTypeClientExtensionInner = (u8, Seq<u8>);
-
-
-impl SpecFrom<SpecClientCertTypeClientExtension> for SpecClientCertTypeClientExtensionInner {
-    open spec fn spec_from(m: SpecClientCertTypeClientExtension) -> SpecClientCertTypeClientExtensionInner {
-        (m.l, m.list)
-    }
-}
-
-impl SpecFrom<SpecClientCertTypeClientExtensionInner> for SpecClientCertTypeClientExtension {
-    open spec fn spec_from(m: SpecClientCertTypeClientExtensionInner) -> SpecClientCertTypeClientExtension {
-        let (l, list) = m;
-        SpecClientCertTypeClientExtension { l, list }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct ClientCertTypeClientExtension {
-    pub l: u8,
-    pub list: RepeatResult<u8>,
-}
-
-impl View for ClientCertTypeClientExtension {
-    type V = SpecClientCertTypeClientExtension;
-
-    open spec fn view(&self) -> Self::V {
-        SpecClientCertTypeClientExtension {
-            l: self.l@,
-            list: self.list@,
-        }
-    }
-}
-pub type ClientCertTypeClientExtensionInner = (u8, RepeatResult<u8>);
-
-pub type ClientCertTypeClientExtensionInnerRef<'a> = (&'a u8, &'a RepeatResult<u8>);
-impl<'a> From<&'a ClientCertTypeClientExtension> for ClientCertTypeClientExtensionInnerRef<'a> {
-    fn ex_from(m: &'a ClientCertTypeClientExtension) -> ClientCertTypeClientExtensionInnerRef<'a> {
-        (&m.l, &m.list)
-    }
-}
-
-impl From<ClientCertTypeClientExtensionInner> for ClientCertTypeClientExtension {
-    fn ex_from(m: ClientCertTypeClientExtensionInner) -> ClientCertTypeClientExtension {
-        let (l, list) = m;
-        ClientCertTypeClientExtension { l, list }
-    }
-}
-
-pub struct ClientCertTypeClientExtensionMapper;
-impl View for ClientCertTypeClientExtensionMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ClientCertTypeClientExtensionMapper {
-    type Src = SpecClientCertTypeClientExtensionInner;
-    type Dst = SpecClientCertTypeClientExtension;
-}
-impl SpecIsoProof for ClientCertTypeClientExtensionMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for ClientCertTypeClientExtensionMapper {
-    type Src = ClientCertTypeClientExtensionInner;
-    type Dst = ClientCertTypeClientExtension;
-    type RefSrc = ClientCertTypeClientExtensionInnerRef<'a>;
-}
 
-pub struct SpecClientCertTypeClientExtensionCombinator(pub SpecClientCertTypeClientExtensionCombinatorAlias);
+pub struct SpecCookieCombinator(pub SpecCookieCombinatorAlias);
 
-impl SpecCombinator for SpecClientCertTypeClientExtensionCombinator {
-    type Type = SpecClientCertTypeClientExtension;
+impl SpecCombinator for SpecCookieCombinator {
+    type Type = SpecCookie;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecClientCertTypeClientExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecClientCertTypeClientExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCookieCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCookieCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecClientCertTypeClientExtensionCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>>>, ClientCertTypeClientExtensionMapper>;
-pub struct Predicate13984338198318635021;
-impl View for Predicate13984338198318635021 {
-    type V = Self;
+pub type SpecCookieCombinatorAlias = SpecOpaque1FfffCombinator;
 
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u8> for Predicate13984338198318635021 {
-    fn apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        (i >= 1 && i <= 255)
-    }
-}
-impl SpecPred<u8> for Predicate13984338198318635021 {
-    open spec fn spec_apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        (i >= 1 && i <= 255)
-    }
-}
-
-pub struct ClientCertTypeClientExtensionCombinator(pub ClientCertTypeClientExtensionCombinatorAlias);
+pub struct CookieCombinator(pub CookieCombinatorAlias);
 
-impl View for ClientCertTypeClientExtensionCombinator {
-    type V = SpecClientCertTypeClientExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecClientCertTypeClientExtensionCombinator(self.0@) }
+impl View for CookieCombinator {
+    type V = SpecCookieCombinator;
+    open spec fn view(&self) -> Self::V { SpecCookieCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientCertTypeClientExtensionCombinator {
-    type Type = ClientCertTypeClientExtension;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CookieCombinator {
+    type Type = Cookie<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ClientCertTypeClientExtensionCombinatorAlias = Mapped<Pair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<CertificateTypeCombinator>>, ClientCertTypeClientExtensionCont0>, ClientCertTypeClientExtensionMapper>;
-
-
-pub open spec fn spec_client_cert_type_client_extension() -> SpecClientCertTypeClientExtensionCombinator {
-    SpecClientCertTypeClientExtensionCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, |deps| spec_client_cert_type_client_extension_cont0(deps)),
-        mapper: ClientCertTypeClientExtensionMapper,
-    })
-}
-
-pub open spec fn spec_client_cert_type_client_extension_cont0(deps: u8) -> AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_certificate_type()))
 }
+pub type CookieCombinatorAlias = Opaque1FfffCombinator;
 
-impl View for ClientCertTypeClientExtensionCont0 {
-    type V = spec_fn(u8) -> AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u8| {
-            spec_client_cert_type_client_extension_cont0(deps)
-        }
-    }
+pub open spec fn spec_cookie() -> SpecCookieCombinator {
+    SpecCookieCombinator(spec_opaque_1_ffff())
 }
 
                 
-pub fn client_cert_type_client_extension<'a>() -> (o: ClientCertTypeClientExtensionCombinator)
-    ensures o@ == spec_client_cert_type_client_extension(),
+pub fn cookie<'a>() -> (o: CookieCombinator)
+    ensures o@ == spec_cookie(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ClientCertTypeClientExtensionCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, ClientCertTypeClientExtensionCont0),
-        mapper: ClientCertTypeClientExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_client_cert_type_client_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = CookieCombinator(opaque_1_ffff());
+    // assert({
+    //     &&& combinator@ == spec_cookie()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_client_cert_type_client_extension<'a>(input: &'a [u8]) -> (res: PResult<<ClientCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_cookie<'a>(input: &'a [u8]) -> (res: PResult<<CookieCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_client_cert_type_client_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_client_cert_type_client_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_cookie().spec_parse(input@) == Some((n as int, v@)),
+        spec_cookie().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_client_cert_type_client_extension().spec_parse(input@) is None,
-        spec_client_cert_type_client_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_cookie().spec_parse(input@) is None,
+        spec_cookie().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = client_cert_type_client_extension();
+    let combinator = cookie();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_client_cert_type_client_extension<'a>(v: <ClientCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_cookie<'a>(v: <CookieCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_client_cert_type_client_extension().wf(v@),
+        spec_cookie().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_client_cert_type_client_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_client_cert_type_client_extension().spec_serialize(v@))
+            &&& n == spec_cookie().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_cookie().spec_serialize(v@))
         },
 {
-    let combinator = client_cert_type_client_extension();
+    let combinator = cookie();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn client_cert_type_client_extension_len<'a>(v: <ClientCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn cookie_len<'a>(v: <CookieCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_client_cert_type_client_extension().wf(v@),
-        spec_client_cert_type_client_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_cookie().wf(v@),
+        spec_cookie().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_client_cert_type_client_extension().spec_serialize(v@).len(),
+        serialize_len == spec_cookie().spec_serialize(v@).len(),
 {
-    let combinator = client_cert_type_client_extension();
+    let combinator = cookie();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ClientCertTypeClientExtensionCont0;
-type ClientCertTypeClientExtensionCont0Type<'a, 'b> = &'b u8;
-type ClientCertTypeClientExtensionCont0SType<'a, 'x> = &'x u8;
-type ClientCertTypeClientExtensionCont0Input<'a, 'b, 'x> = POrSType<ClientCertTypeClientExtensionCont0Type<'a, 'b>, ClientCertTypeClientExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ClientCertTypeClientExtensionCont0Input<'a, 'b, 'x>> for ClientCertTypeClientExtensionCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<CertificateTypeCombinator>>;
-
-    open spec fn requires(&self, deps: ClientCertTypeClientExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: ClientCertTypeClientExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_client_cert_type_client_extension_cont0(deps@)
-    }
-
-    fn apply(&self, deps: ClientCertTypeClientExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(certificate_type()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(certificate_type()))
-            }
-        }
-    }
-}
                 
-
-pub struct SpecServerCertTypeClientExtension {
-    pub l: u8,
-    pub list: Seq<u8>,
+pub mod NamedGroup {
+    use super::*;
+    pub spec const SPEC_Sect163k1: u16 = 1;
+    pub spec const SPEC_Sect163r1: u16 = 2;
+    pub spec const SPEC_Sect163r2: u16 = 3;
+    pub spec const SPEC_Sect193r1: u16 = 4;
+    pub spec const SPEC_Sect193r2: u16 = 5;
+    pub spec const SPEC_Sect233k1: u16 = 6;
+    pub spec const SPEC_Sect233r1: u16 = 7;
+    pub spec const SPEC_Sect239k1: u16 = 8;
+    pub spec const SPEC_Sect283k1: u16 = 9;
+    pub spec const SPEC_Sect283r1: u16 = 10;
+    pub spec const SPEC_Sect409k1: u16 = 11;
+    pub spec const SPEC_Sect409r1: u16 = 12;
+    pub spec const SPEC_Sect571k1: u16 = 13;
+    pub spec const SPEC_Sect571r1: u16 = 14;
+    pub spec const SPEC_Secp160k1: u16 = 15;
+    pub spec const SPEC_Secp160r1: u16 = 16;
+    pub spec const SPEC_Secp160r2: u16 = 17;
+    pub spec const SPEC_Secp192k1: u16 = 18;
+    pub spec const SPEC_Secp192r1: u16 = 19;
+    pub spec const SPEC_Secp224k1: u16 = 20;
+    pub spec const SPEC_Secp224r1: u16 = 21;
+    pub spec const SPEC_Secp256k1: u16 = 22;
+    pub spec const SPEC_Secp256r1: u16 = 23;
+    pub spec const SPEC_Secp384r1: u16 = 24;
+    pub spec const SPEC_Secp521r1: u16 = 25;
+    pub spec const SPEC_X25519: u16 = 29;
+    pub spec const SPEC_X448: u16 = 30;
+    pub spec const SPEC_Ffdhe2048: u16 = 256;
+    pub spec const SPEC_Ffdhe3072: u16 = 257;
+    pub spec const SPEC_Ffdhe4096: u16 = 258;
+    pub spec const SPEC_Ffdhe6144: u16 = 259;
+    pub spec const SPEC_Ffdhe8192: u16 = 260;
+    pub exec const Sect163k1: u16 ensures Sect163k1 == SPEC_Sect163k1 { 1 }
+    pub exec const Sect163r1: u16 ensures Sect163r1 == SPEC_Sect163r1 { 2 }
+    pub exec const Sect163r2: u16 ensures Sect163r2 == SPEC_Sect163r2 { 3 }
+    pub exec const Sect193r1: u16 ensures Sect193r1 == SPEC_Sect193r1 { 4 }
+    pub exec const Sect193r2: u16 ensures Sect193r2 == SPEC_Sect193r2 { 5 }
+    pub exec const Sect233k1: u16 ensures Sect233k1 == SPEC_Sect233k1 { 6 }
+    pub exec const Sect233r1: u16 ensures Sect233r1 == SPEC_Sect233r1 { 7 }
+    pub exec const Sect239k1: u16 ensures Sect239k1 == SPEC_Sect239k1 { 8 }
+    pub exec const Sect283k1: u16 ensures Sect283k1 == SPEC_Sect283k1 { 9 }
+    pub exec const Sect283r1: u16 ensures Sect283r1 == SPEC_Sect283r1 { 10 }
+    pub exec const Sect409k1: u16 ensures Sect409k1 == SPEC_Sect409k1 { 11 }
+    pub exec const Sect409r1: u16 ensures Sect409r1 == SPEC_Sect409r1 { 12 }
+    pub exec const Sect571k1: u16 ensures Sect571k1 == SPEC_Sect571k1 { 13 }
+    pub exec const Sect571r1: u16 ensures Sect571r1 == SPEC_Sect571r1 { 14 }
+    pub exec const Secp160k1: u16 ensures Secp160k1 == SPEC_Secp160k1 { 15 }
+    pub exec const Secp160r1: u16 ensures Secp160r1 == SPEC_Secp160r1 { 16 }
+    pub exec const Secp160r2: u16 ensures Secp160r2 == SPEC_Secp160r2 { 17 }
+    pub exec const Secp192k1: u16 ensures Secp192k1 == SPEC_Secp192k1 { 18 }
+    pub exec const Secp192r1: u16 ensures Secp192r1 == SPEC_Secp192r1 { 19 }
+    pub exec const Secp224k1: u16 ensures Secp224k1 == SPEC_Secp224k1 { 20 }
+    pub exec const Secp224r1: u16 ensures Secp224r1 == SPEC_Secp224r1 { 21 }
+    pub exec const Secp256k1: u16 ensures Secp256k1 == SPEC_Secp256k1 { 22 }
+    pub exec const Secp256r1: u16 ensures Secp256r1 == SPEC_Secp256r1 { 23 }
+    pub exec const Secp384r1: u16 ensures Secp384r1 == SPEC_Secp384r1 { 24 }
+    pub exec const Secp521r1: u16 ensures Secp521r1 == SPEC_Secp521r1 { 25 }
+    pub exec const X25519: u16 ensures X25519 == SPEC_X25519 { 29 }
+    pub exec const X448: u16 ensures X448 == SPEC_X448 { 30 }
+    pub exec const Ffdhe2048: u16 ensures Ffdhe2048 == SPEC_Ffdhe2048 { 256 }
+    pub exec const Ffdhe3072: u16 ensures Ffdhe3072 == SPEC_Ffdhe3072 { 257 }
+    pub exec const Ffdhe4096: u16 ensures Ffdhe4096 == SPEC_Ffdhe4096 { 258 }
+    pub exec const Ffdhe6144: u16 ensures Ffdhe6144 == SPEC_Ffdhe6144 { 259 }
+    pub exec const Ffdhe8192: u16 ensures Ffdhe8192 == SPEC_Ffdhe8192 { 260 }
 }
 
-pub type SpecServerCertTypeClientExtensionInner = (u8, Seq<u8>);
-
 
-impl SpecFrom<SpecServerCertTypeClientExtension> for SpecServerCertTypeClientExtensionInner {
-    open spec fn spec_from(m: SpecServerCertTypeClientExtension) -> SpecServerCertTypeClientExtensionInner {
-        (m.l, m.list)
-    }
-}
+pub struct SpecNamedGroupCombinator(pub SpecNamedGroupCombinatorAlias);
 
-impl SpecFrom<SpecServerCertTypeClientExtensionInner> for SpecServerCertTypeClientExtension {
-    open spec fn spec_from(m: SpecServerCertTypeClientExtensionInner) -> SpecServerCertTypeClientExtension {
-        let (l, list) = m;
-        SpecServerCertTypeClientExtension { l, list }
-    }
+impl SpecCombinator for SpecNamedGroupCombinator {
+    type Type = u16;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct ServerCertTypeClientExtension {
-    pub l: u8,
-    pub list: RepeatResult<u8>,
+impl SecureSpecCombinator for SpecNamedGroupCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNamedGroupCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
 }
+pub type SpecNamedGroupCombinatorAlias = U16Be;
 
-impl View for ServerCertTypeClientExtension {
-    type V = SpecServerCertTypeClientExtension;
+pub struct NamedGroupCombinator(pub NamedGroupCombinatorAlias);
 
-    open spec fn view(&self) -> Self::V {
-        SpecServerCertTypeClientExtension {
-            l: self.l@,
-            list: self.list@,
-        }
-    }
+impl View for NamedGroupCombinator {
+    type V = SpecNamedGroupCombinator;
+    open spec fn view(&self) -> Self::V { SpecNamedGroupCombinator(self.0@) }
 }
-pub type ServerCertTypeClientExtensionInner = (u8, RepeatResult<u8>);
-
-pub type ServerCertTypeClientExtensionInnerRef<'a> = (&'a u8, &'a RepeatResult<u8>);
-impl<'a> From<&'a ServerCertTypeClientExtension> for ServerCertTypeClientExtensionInnerRef<'a> {
-    fn ex_from(m: &'a ServerCertTypeClientExtension) -> ServerCertTypeClientExtensionInnerRef<'a> {
-        (&m.l, &m.list)
-    }
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NamedGroupCombinator {
+    type Type = u16;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+pub type NamedGroupCombinatorAlias = U16Be;
 
-impl From<ServerCertTypeClientExtensionInner> for ServerCertTypeClientExtension {
-    fn ex_from(m: ServerCertTypeClientExtensionInner) -> ServerCertTypeClientExtension {
-        let (l, list) = m;
-        ServerCertTypeClientExtension { l, list }
-    }
-}
-
-pub struct ServerCertTypeClientExtensionMapper;
-impl View for ServerCertTypeClientExtensionMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ServerCertTypeClientExtensionMapper {
-    type Src = SpecServerCertTypeClientExtensionInner;
-    type Dst = SpecServerCertTypeClientExtension;
-}
-impl SpecIsoProof for ServerCertTypeClientExtensionMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for ServerCertTypeClientExtensionMapper {
-    type Src = ServerCertTypeClientExtensionInner;
-    type Dst = ServerCertTypeClientExtension;
-    type RefSrc = ServerCertTypeClientExtensionInnerRef<'a>;
-}
-
-pub struct SpecServerCertTypeClientExtensionCombinator(pub SpecServerCertTypeClientExtensionCombinatorAlias);
-
-impl SpecCombinator for SpecServerCertTypeClientExtensionCombinator {
-    type Type = SpecServerCertTypeClientExtension;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecServerCertTypeClientExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecServerCertTypeClientExtensionCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
-}
-pub type SpecServerCertTypeClientExtensionCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>>>, ServerCertTypeClientExtensionMapper>;
-
-pub struct ServerCertTypeClientExtensionCombinator(pub ServerCertTypeClientExtensionCombinatorAlias);
-
-impl View for ServerCertTypeClientExtensionCombinator {
-    type V = SpecServerCertTypeClientExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecServerCertTypeClientExtensionCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerCertTypeClientExtensionCombinator {
-    type Type = ServerCertTypeClientExtension;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ServerCertTypeClientExtensionCombinatorAlias = Mapped<Pair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<CertificateTypeCombinator>>, ServerCertTypeClientExtensionCont0>, ServerCertTypeClientExtensionMapper>;
-
-
-pub open spec fn spec_server_cert_type_client_extension() -> SpecServerCertTypeClientExtensionCombinator {
-    SpecServerCertTypeClientExtensionCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, |deps| spec_server_cert_type_client_extension_cont0(deps)),
-        mapper: ServerCertTypeClientExtensionMapper,
-    })
-}
-
-pub open spec fn spec_server_cert_type_client_extension_cont0(deps: u8) -> AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_certificate_type()))
-}
-
-impl View for ServerCertTypeClientExtensionCont0 {
-    type V = spec_fn(u8) -> AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u8| {
-            spec_server_cert_type_client_extension_cont0(deps)
-        }
-    }
+
+pub open spec fn spec_named_group() -> SpecNamedGroupCombinator {
+    SpecNamedGroupCombinator(U16Be)
 }
 
                 
-pub fn server_cert_type_client_extension<'a>() -> (o: ServerCertTypeClientExtensionCombinator)
-    ensures o@ == spec_server_cert_type_client_extension(),
+pub fn named_group<'a>() -> (o: NamedGroupCombinator)
+    ensures o@ == spec_named_group(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ServerCertTypeClientExtensionCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, ServerCertTypeClientExtensionCont0),
-        mapper: ServerCertTypeClientExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_server_cert_type_client_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = NamedGroupCombinator(U16Be);
+    // assert({
+    //     &&& combinator@ == spec_named_group()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_server_cert_type_client_extension<'a>(input: &'a [u8]) -> (res: PResult<<ServerCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_named_group<'a>(input: &'a [u8]) -> (res: PResult<<NamedGroupCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_server_cert_type_client_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_server_cert_type_client_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_named_group().spec_parse(input@) == Some((n as int, v@)),
+        spec_named_group().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_server_cert_type_client_extension().spec_parse(input@) is None,
-        spec_server_cert_type_client_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_named_group().spec_parse(input@) is None,
+        spec_named_group().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = server_cert_type_client_extension();
+    let combinator = named_group();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_server_cert_type_client_extension<'a>(v: <ServerCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_named_group<'a>(v: <NamedGroupCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_server_cert_type_client_extension().wf(v@),
+        spec_named_group().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_server_cert_type_client_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_server_cert_type_client_extension().spec_serialize(v@))
+            &&& n == spec_named_group().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_named_group().spec_serialize(v@))
         },
 {
-    let combinator = server_cert_type_client_extension();
+    let combinator = named_group();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn server_cert_type_client_extension_len<'a>(v: <ServerCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn named_group_len<'a>(v: <NamedGroupCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_server_cert_type_client_extension().wf(v@),
-        spec_server_cert_type_client_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_named_group().wf(v@),
+        spec_named_group().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_server_cert_type_client_extension().spec_serialize(v@).len(),
+        serialize_len == spec_named_group().spec_serialize(v@).len(),
 {
-    let combinator = server_cert_type_client_extension();
+    let combinator = named_group();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ServerCertTypeClientExtensionCont0;
-type ServerCertTypeClientExtensionCont0Type<'a, 'b> = &'b u8;
-type ServerCertTypeClientExtensionCont0SType<'a, 'x> = &'x u8;
-type ServerCertTypeClientExtensionCont0Input<'a, 'b, 'x> = POrSType<ServerCertTypeClientExtensionCont0Type<'a, 'b>, ServerCertTypeClientExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ServerCertTypeClientExtensionCont0Input<'a, 'b, 'x>> for ServerCertTypeClientExtensionCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<CertificateTypeCombinator>>;
-
-    open spec fn requires(&self, deps: ServerCertTypeClientExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: ServerCertTypeClientExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_server_cert_type_client_extension_cont0(deps@)
-    }
-
-    fn apply(&self, deps: ServerCertTypeClientExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(certificate_type()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(certificate_type()))
-            }
-        }
-    }
-}
                 
 
-pub enum SpecEncryptedExtensionExtensionData {
-    ServerName(SpecEmpty),
-    MaxFragmentLength(u8),
-    SupportedGroups(SpecNamedGroupList),
-    Heartbeat(u8),
-    ApplicationLayerProtocolNegotiation(SpecProtocolNameList),
-    ClientCertificateType(SpecClientCertTypeClientExtension),
-    ServerCertificateType(SpecServerCertTypeClientExtension),
-    EarlyData(SpecEmpty),
+pub enum SpecHelloRetryExtensionExtensionData {
+    SupportedVersions(u16),
+    Cookie(SpecCookie),
+    KeyShare(u16),
     Unrecognized(Seq<u8>),
 }
 
-pub type SpecEncryptedExtensionExtensionDataInner = Either<SpecEmpty, Either<u8, Either<SpecNamedGroupList, Either<u8, Either<SpecProtocolNameList, Either<SpecClientCertTypeClientExtension, Either<SpecServerCertTypeClientExtension, Either<SpecEmpty, Seq<u8>>>>>>>>>;
+pub type SpecHelloRetryExtensionExtensionDataInner = Either<u16, Either<SpecCookie, Either<u16, Seq<u8>>>>;
 
-impl SpecFrom<SpecEncryptedExtensionExtensionData> for SpecEncryptedExtensionExtensionDataInner {
-    open spec fn spec_from(m: SpecEncryptedExtensionExtensionData) -> SpecEncryptedExtensionExtensionDataInner {
+impl SpecFrom<SpecHelloRetryExtensionExtensionData> for SpecHelloRetryExtensionExtensionDataInner {
+    open spec fn spec_from(m: SpecHelloRetryExtensionExtensionData) -> SpecHelloRetryExtensionExtensionDataInner {
         match m {
-            SpecEncryptedExtensionExtensionData::ServerName(m) => Either::Left(m),
-            SpecEncryptedExtensionExtensionData::MaxFragmentLength(m) => Either::Right(Either::Left(m)),
-            SpecEncryptedExtensionExtensionData::SupportedGroups(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecEncryptedExtensionExtensionData::Heartbeat(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            SpecEncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            SpecEncryptedExtensionExtensionData::ClientCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            SpecEncryptedExtensionExtensionData::ServerCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
-            SpecEncryptedExtensionExtensionData::EarlyData(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
-            SpecEncryptedExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))),
+            SpecHelloRetryExtensionExtensionData::SupportedVersions(m) => Either::Left(m),
+            SpecHelloRetryExtensionExtensionData::Cookie(m) => Either::Right(Either::Left(m)),
+            SpecHelloRetryExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecHelloRetryExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(m))),
         }
     }
 
 }
 
                 
-impl SpecFrom<SpecEncryptedExtensionExtensionDataInner> for SpecEncryptedExtensionExtensionData {
-    open spec fn spec_from(m: SpecEncryptedExtensionExtensionDataInner) -> SpecEncryptedExtensionExtensionData {
+impl SpecFrom<SpecHelloRetryExtensionExtensionDataInner> for SpecHelloRetryExtensionExtensionData {
+    open spec fn spec_from(m: SpecHelloRetryExtensionExtensionDataInner) -> SpecHelloRetryExtensionExtensionData {
         match m {
-            Either::Left(m) => SpecEncryptedExtensionExtensionData::ServerName(m),
-            Either::Right(Either::Left(m)) => SpecEncryptedExtensionExtensionData::MaxFragmentLength(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecEncryptedExtensionExtensionData::SupportedGroups(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecEncryptedExtensionExtensionData::Heartbeat(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecEncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecEncryptedExtensionExtensionData::ClientCertificateType(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => SpecEncryptedExtensionExtensionData::ServerCertificateType(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => SpecEncryptedExtensionExtensionData::EarlyData(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))) => SpecEncryptedExtensionExtensionData::Unrecognized(m),
+            Either::Left(m) => SpecHelloRetryExtensionExtensionData::SupportedVersions(m),
+            Either::Right(Either::Left(m)) => SpecHelloRetryExtensionExtensionData::Cookie(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecHelloRetryExtensionExtensionData::KeyShare(m),
+            Either::Right(Either::Right(Either::Right(m))) => SpecHelloRetryExtensionExtensionData::Unrecognized(m),
         }
     }
 
@@ -6216,88 +5563,68 @@ impl SpecFrom<SpecEncryptedExtensionExtensionDataInner> for SpecEncryptedExtensi
 
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum EncryptedExtensionExtensionData<'a> {
-    ServerName(Empty<'a>),
-    MaxFragmentLength(u8),
-    SupportedGroups(NamedGroupList),
-    Heartbeat(u8),
-    ApplicationLayerProtocolNegotiation(ProtocolNameList<'a>),
-    ClientCertificateType(ClientCertTypeClientExtension),
-    ServerCertificateType(ServerCertTypeClientExtension),
-    EarlyData(Empty<'a>),
+pub enum HelloRetryExtensionExtensionData<'a> {
+    SupportedVersions(u16),
+    Cookie(Cookie<'a>),
+    KeyShare(u16),
     Unrecognized(&'a [u8]),
 }
 
-pub type EncryptedExtensionExtensionDataInner<'a> = Either<Empty<'a>, Either<u8, Either<NamedGroupList, Either<u8, Either<ProtocolNameList<'a>, Either<ClientCertTypeClientExtension, Either<ServerCertTypeClientExtension, Either<Empty<'a>, &'a [u8]>>>>>>>>;
+pub type HelloRetryExtensionExtensionDataInner<'a> = Either<u16, Either<Cookie<'a>, Either<u16, &'a [u8]>>>;
 
-pub type EncryptedExtensionExtensionDataInnerRef<'a> = Either<&'a Empty<'a>, Either<&'a u8, Either<&'a NamedGroupList, Either<&'a u8, Either<&'a ProtocolNameList<'a>, Either<&'a ClientCertTypeClientExtension, Either<&'a ServerCertTypeClientExtension, Either<&'a Empty<'a>, &'a &'a [u8]>>>>>>>>;
+pub type HelloRetryExtensionExtensionDataInnerRef<'a> = Either<&'a u16, Either<&'a Cookie<'a>, Either<&'a u16, &'a &'a [u8]>>>;
 
 
-impl<'a> View for EncryptedExtensionExtensionData<'a> {
-    type V = SpecEncryptedExtensionExtensionData;
+impl<'a> View for HelloRetryExtensionExtensionData<'a> {
+    type V = SpecHelloRetryExtensionExtensionData;
     open spec fn view(&self) -> Self::V {
         match self {
-            EncryptedExtensionExtensionData::ServerName(m) => SpecEncryptedExtensionExtensionData::ServerName(m@),
-            EncryptedExtensionExtensionData::MaxFragmentLength(m) => SpecEncryptedExtensionExtensionData::MaxFragmentLength(m@),
-            EncryptedExtensionExtensionData::SupportedGroups(m) => SpecEncryptedExtensionExtensionData::SupportedGroups(m@),
-            EncryptedExtensionExtensionData::Heartbeat(m) => SpecEncryptedExtensionExtensionData::Heartbeat(m@),
-            EncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => SpecEncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m@),
-            EncryptedExtensionExtensionData::ClientCertificateType(m) => SpecEncryptedExtensionExtensionData::ClientCertificateType(m@),
-            EncryptedExtensionExtensionData::ServerCertificateType(m) => SpecEncryptedExtensionExtensionData::ServerCertificateType(m@),
-            EncryptedExtensionExtensionData::EarlyData(m) => SpecEncryptedExtensionExtensionData::EarlyData(m@),
-            EncryptedExtensionExtensionData::Unrecognized(m) => SpecEncryptedExtensionExtensionData::Unrecognized(m@),
+            HelloRetryExtensionExtensionData::SupportedVersions(m) => SpecHelloRetryExtensionExtensionData::SupportedVersions(m@),
+            HelloRetryExtensionExtensionData::Cookie(m) => SpecHelloRetryExtensionExtensionData::Cookie(m@),
+            HelloRetryExtensionExtensionData::KeyShare(m) => SpecHelloRetryExtensionExtensionData::KeyShare(m@),
+            HelloRetryExtensionExtensionData::Unrecognized(m) => SpecHelloRetryExtensionExtensionData::Unrecognized(m@),
         }
     }
 }
 
 
-impl<'a> From<&'a EncryptedExtensionExtensionData<'a>> for EncryptedExtensionExtensionDataInnerRef<'a> {
-    fn ex_from(m: &'a EncryptedExtensionExtensionData<'a>) -> EncryptedExtensionExtensionDataInnerRef<'a> {
+impl<'a> From<&'a HelloRetryExtensionExtensionData<'a>> for HelloRetryExtensionExtensionDataInnerRef<'a> {
+    fn ex_from(m: &'a HelloRetryExtensionExtensionData<'a>) -> HelloRetryExtensionExtensionDataInnerRef<'a> {
         match m {
-            EncryptedExtensionExtensionData::ServerName(m) => Either::Left(m),
-            EncryptedExtensionExtensionData::MaxFragmentLength(m) => Either::Right(Either::Left(m)),
-            EncryptedExtensionExtensionData::SupportedGroups(m) => Either::Right(Either::Right(Either::Left(m))),
-            EncryptedExtensionExtensionData::Heartbeat(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            EncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            EncryptedExtensionExtensionData::ClientCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            EncryptedExtensionExtensionData::ServerCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
-            EncryptedExtensionExtensionData::EarlyData(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
-            EncryptedExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))),
+            HelloRetryExtensionExtensionData::SupportedVersions(m) => Either::Left(m),
+            HelloRetryExtensionExtensionData::Cookie(m) => Either::Right(Either::Left(m)),
+            HelloRetryExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Left(m))),
+            HelloRetryExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(m))),
         }
     }
 
 }
 
-impl<'a> From<EncryptedExtensionExtensionDataInner<'a>> for EncryptedExtensionExtensionData<'a> {
-    fn ex_from(m: EncryptedExtensionExtensionDataInner<'a>) -> EncryptedExtensionExtensionData<'a> {
+impl<'a> From<HelloRetryExtensionExtensionDataInner<'a>> for HelloRetryExtensionExtensionData<'a> {
+    fn ex_from(m: HelloRetryExtensionExtensionDataInner<'a>) -> HelloRetryExtensionExtensionData<'a> {
         match m {
-            Either::Left(m) => EncryptedExtensionExtensionData::ServerName(m),
-            Either::Right(Either::Left(m)) => EncryptedExtensionExtensionData::MaxFragmentLength(m),
-            Either::Right(Either::Right(Either::Left(m))) => EncryptedExtensionExtensionData::SupportedGroups(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => EncryptedExtensionExtensionData::Heartbeat(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => EncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => EncryptedExtensionExtensionData::ClientCertificateType(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => EncryptedExtensionExtensionData::ServerCertificateType(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => EncryptedExtensionExtensionData::EarlyData(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))) => EncryptedExtensionExtensionData::Unrecognized(m),
+            Either::Left(m) => HelloRetryExtensionExtensionData::SupportedVersions(m),
+            Either::Right(Either::Left(m)) => HelloRetryExtensionExtensionData::Cookie(m),
+            Either::Right(Either::Right(Either::Left(m))) => HelloRetryExtensionExtensionData::KeyShare(m),
+            Either::Right(Either::Right(Either::Right(m))) => HelloRetryExtensionExtensionData::Unrecognized(m),
         }
     }
     
 }
 
 
-pub struct EncryptedExtensionExtensionDataMapper;
-impl View for EncryptedExtensionExtensionDataMapper {
+pub struct HelloRetryExtensionExtensionDataMapper;
+impl View for HelloRetryExtensionExtensionDataMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for EncryptedExtensionExtensionDataMapper {
-    type Src = SpecEncryptedExtensionExtensionDataInner;
-    type Dst = SpecEncryptedExtensionExtensionData;
+impl SpecIso for HelloRetryExtensionExtensionDataMapper {
+    type Src = SpecHelloRetryExtensionExtensionDataInner;
+    type Dst = SpecHelloRetryExtensionExtensionData;
 }
-impl SpecIsoProof for EncryptedExtensionExtensionDataMapper {
+impl SpecIsoProof for HelloRetryExtensionExtensionDataMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -6305,263 +5632,227 @@ impl SpecIsoProof for EncryptedExtensionExtensionDataMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for EncryptedExtensionExtensionDataMapper {
-    type Src = EncryptedExtensionExtensionDataInner<'a>;
-    type Dst = EncryptedExtensionExtensionData<'a>;
-    type RefSrc = EncryptedExtensionExtensionDataInnerRef<'a>;
+impl<'a> Iso<'a> for HelloRetryExtensionExtensionDataMapper {
+    type Src = HelloRetryExtensionExtensionDataInner<'a>;
+    type Dst = HelloRetryExtensionExtensionData<'a>;
+    type RefSrc = HelloRetryExtensionExtensionDataInnerRef<'a>;
 }
 
-type SpecEncryptedExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecEmptyCombinator>, Cond<bytes::Variable>>;
-type SpecEncryptedExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecServerCertTypeClientExtensionCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias1>;
-type SpecEncryptedExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SpecClientCertTypeClientExtensionCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias2>;
-type SpecEncryptedExtensionExtensionDataCombinatorAlias4 = Choice<Cond<SpecProtocolNameListCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias3>;
-type SpecEncryptedExtensionExtensionDataCombinatorAlias5 = Choice<Cond<SpecHeartbeatModeCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias4>;
-type SpecEncryptedExtensionExtensionDataCombinatorAlias6 = Choice<Cond<SpecNamedGroupListCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias5>;
-type SpecEncryptedExtensionExtensionDataCombinatorAlias7 = Choice<Cond<SpecMaxFragmentLengthCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias6>;
-type SpecEncryptedExtensionExtensionDataCombinatorAlias8 = Choice<Cond<SpecEmptyCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias7>;
-pub struct SpecEncryptedExtensionExtensionDataCombinator(pub SpecEncryptedExtensionExtensionDataCombinatorAlias);
+type SpecHelloRetryExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecNamedGroupCombinator>, Cond<bytes::Variable>>;
+type SpecHelloRetryExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecCookieCombinator>, SpecHelloRetryExtensionExtensionDataCombinatorAlias1>;
+type SpecHelloRetryExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SpecSupportedVersionsServerCombinator>, SpecHelloRetryExtensionExtensionDataCombinatorAlias2>;
+pub struct SpecHelloRetryExtensionExtensionDataCombinator(pub SpecHelloRetryExtensionExtensionDataCombinatorAlias);
 
-impl SpecCombinator for SpecEncryptedExtensionExtensionDataCombinator {
-    type Type = SpecEncryptedExtensionExtensionData;
+impl SpecCombinator for SpecHelloRetryExtensionExtensionDataCombinator {
+    type Type = SpecHelloRetryExtensionExtensionData;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecEncryptedExtensionExtensionDataCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecEncryptedExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecHelloRetryExtensionExtensionDataCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHelloRetryExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecEncryptedExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecEncryptedExtensionExtensionDataCombinatorAlias8, EncryptedExtensionExtensionDataMapper>>;
-type EncryptedExtensionExtensionDataCombinatorAlias1 = Choice<Cond<EmptyCombinator>, Cond<bytes::Variable>>;
-type EncryptedExtensionExtensionDataCombinatorAlias2 = Choice<Cond<ServerCertTypeClientExtensionCombinator>, EncryptedExtensionExtensionDataCombinator1>;
-type EncryptedExtensionExtensionDataCombinatorAlias3 = Choice<Cond<ClientCertTypeClientExtensionCombinator>, EncryptedExtensionExtensionDataCombinator2>;
-type EncryptedExtensionExtensionDataCombinatorAlias4 = Choice<Cond<ProtocolNameListCombinator>, EncryptedExtensionExtensionDataCombinator3>;
-type EncryptedExtensionExtensionDataCombinatorAlias5 = Choice<Cond<HeartbeatModeCombinator>, EncryptedExtensionExtensionDataCombinator4>;
-type EncryptedExtensionExtensionDataCombinatorAlias6 = Choice<Cond<NamedGroupListCombinator>, EncryptedExtensionExtensionDataCombinator5>;
-type EncryptedExtensionExtensionDataCombinatorAlias7 = Choice<Cond<MaxFragmentLengthCombinator>, EncryptedExtensionExtensionDataCombinator6>;
-type EncryptedExtensionExtensionDataCombinatorAlias8 = Choice<Cond<EmptyCombinator>, EncryptedExtensionExtensionDataCombinator7>;
-pub struct EncryptedExtensionExtensionDataCombinator1(pub EncryptedExtensionExtensionDataCombinatorAlias1);
-impl View for EncryptedExtensionExtensionDataCombinator1 {
-    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator1, EncryptedExtensionExtensionDataCombinatorAlias1);
-
-pub struct EncryptedExtensionExtensionDataCombinator2(pub EncryptedExtensionExtensionDataCombinatorAlias2);
-impl View for EncryptedExtensionExtensionDataCombinator2 {
-    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator2, EncryptedExtensionExtensionDataCombinatorAlias2);
-
-pub struct EncryptedExtensionExtensionDataCombinator3(pub EncryptedExtensionExtensionDataCombinatorAlias3);
-impl View for EncryptedExtensionExtensionDataCombinator3 {
-    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator3, EncryptedExtensionExtensionDataCombinatorAlias3);
-
-pub struct EncryptedExtensionExtensionDataCombinator4(pub EncryptedExtensionExtensionDataCombinatorAlias4);
-impl View for EncryptedExtensionExtensionDataCombinator4 {
-    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator4, EncryptedExtensionExtensionDataCombinatorAlias4);
-
-pub struct EncryptedExtensionExtensionDataCombinator5(pub EncryptedExtensionExtensionDataCombinatorAlias5);
-impl View for EncryptedExtensionExtensionDataCombinator5 {
-    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias5;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator5, EncryptedExtensionExtensionDataCombinatorAlias5);
-
-pub struct EncryptedExtensionExtensionDataCombinator6(pub EncryptedExtensionExtensionDataCombinatorAlias6);
-impl View for EncryptedExtensionExtensionDataCombinator6 {
-    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias6;
+pub type SpecHelloRetryExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecHelloRetryExtensionExtensionDataCombinatorAlias3, HelloRetryExtensionExtensionDataMapper>>;
+type HelloRetryExtensionExtensionDataCombinatorAlias1 = Choice<Cond<NamedGroupCombinator>, Cond<bytes::Variable>>;
+type HelloRetryExtensionExtensionDataCombinatorAlias2 = Choice<Cond<CookieCombinator>, HelloRetryExtensionExtensionDataCombinator1>;
+type HelloRetryExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SupportedVersionsServerCombinator>, HelloRetryExtensionExtensionDataCombinator2>;
+pub struct HelloRetryExtensionExtensionDataCombinator1(pub HelloRetryExtensionExtensionDataCombinatorAlias1);
+impl View for HelloRetryExtensionExtensionDataCombinator1 {
+    type V = SpecHelloRetryExtensionExtensionDataCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator6, EncryptedExtensionExtensionDataCombinatorAlias6);
+impl_wrapper_combinator!(HelloRetryExtensionExtensionDataCombinator1, HelloRetryExtensionExtensionDataCombinatorAlias1);
 
-pub struct EncryptedExtensionExtensionDataCombinator7(pub EncryptedExtensionExtensionDataCombinatorAlias7);
-impl View for EncryptedExtensionExtensionDataCombinator7 {
-    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias7;
+pub struct HelloRetryExtensionExtensionDataCombinator2(pub HelloRetryExtensionExtensionDataCombinatorAlias2);
+impl View for HelloRetryExtensionExtensionDataCombinator2 {
+    type V = SpecHelloRetryExtensionExtensionDataCombinatorAlias2;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator7, EncryptedExtensionExtensionDataCombinatorAlias7);
+impl_wrapper_combinator!(HelloRetryExtensionExtensionDataCombinator2, HelloRetryExtensionExtensionDataCombinatorAlias2);
 
-pub struct EncryptedExtensionExtensionDataCombinator8(pub EncryptedExtensionExtensionDataCombinatorAlias8);
-impl View for EncryptedExtensionExtensionDataCombinator8 {
-    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias8;
+pub struct HelloRetryExtensionExtensionDataCombinator3(pub HelloRetryExtensionExtensionDataCombinatorAlias3);
+impl View for HelloRetryExtensionExtensionDataCombinator3 {
+    type V = SpecHelloRetryExtensionExtensionDataCombinatorAlias3;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator8, EncryptedExtensionExtensionDataCombinatorAlias8);
+impl_wrapper_combinator!(HelloRetryExtensionExtensionDataCombinator3, HelloRetryExtensionExtensionDataCombinatorAlias3);
 
-pub struct EncryptedExtensionExtensionDataCombinator(pub EncryptedExtensionExtensionDataCombinatorAlias);
+pub struct HelloRetryExtensionExtensionDataCombinator(pub HelloRetryExtensionExtensionDataCombinatorAlias);
 
-impl View for EncryptedExtensionExtensionDataCombinator {
-    type V = SpecEncryptedExtensionExtensionDataCombinator;
-    open spec fn view(&self) -> Self::V { SpecEncryptedExtensionExtensionDataCombinator(self.0@) }
+impl View for HelloRetryExtensionExtensionDataCombinator {
+    type V = SpecHelloRetryExtensionExtensionDataCombinator;
+    open spec fn view(&self) -> Self::V { SpecHelloRetryExtensionExtensionDataCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EncryptedExtensionExtensionDataCombinator {
-    type Type = EncryptedExtensionExtensionData<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HelloRetryExtensionExtensionDataCombinator {
+    type Type = HelloRetryExtensionExtensionData<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type EncryptedExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<EncryptedExtensionExtensionDataCombinator8, EncryptedExtensionExtensionDataMapper>>;
+}
+pub type HelloRetryExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<HelloRetryExtensionExtensionDataCombinator3, HelloRetryExtensionExtensionDataMapper>>;
 
 
-pub open spec fn spec_encrypted_extension_extension_data(ext_len: u16, extension_type: u16) -> SpecEncryptedExtensionExtensionDataCombinator {
-    SpecEncryptedExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.spec_into()), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_ServerName, inner: spec_empty() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_MaxFragmentLength, inner: spec_max_fragment_length() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SupportedGroups, inner: spec_named_group_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_Heartbeat, inner: spec_heartbeat_mode() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ApplicationLayerProtocolNegotiation, inner: spec_protocol_name_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ClientCertificateType, inner: spec_client_cert_type_client_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ServerCertificateType, inner: spec_server_cert_type_client_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_EarlyData, inner: spec_empty() }, Cond { cond: !(extension_type == ExtensionType::SPEC_ServerName || extension_type == ExtensionType::SPEC_MaxFragmentLength || extension_type == ExtensionType::SPEC_SupportedGroups || extension_type == ExtensionType::SPEC_Heartbeat || extension_type == ExtensionType::SPEC_ApplicationLayerProtocolNegotiation || extension_type == ExtensionType::SPEC_ClientCertificateType || extension_type == ExtensionType::SPEC_ServerCertificateType || extension_type == ExtensionType::SPEC_EarlyData), inner: bytes::Variable(ext_len.spec_into()) })))))))), mapper: EncryptedExtensionExtensionDataMapper }))
+pub open spec fn spec_hello_retry_extension_extension_data(extension_type: u16, ext_len: u16) -> SpecHelloRetryExtensionExtensionDataCombinator {
+    SpecHelloRetryExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::spec_from(ext_len)) as usize), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_SupportedVersions, inner: spec_supported_versions_server() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_Cookie, inner: spec_cookie() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_KeyShare, inner: spec_named_group() }, Cond { cond: !(extension_type == ExtensionType::SPEC_SupportedVersions || extension_type == ExtensionType::SPEC_Cookie || extension_type == ExtensionType::SPEC_KeyShare), inner: bytes::Variable((usize::spec_from(ext_len)) as usize) }))), mapper: HelloRetryExtensionExtensionDataMapper }))
 }
 
-pub fn encrypted_extension_extension_data<'a>(ext_len: u16, extension_type: u16) -> (o: EncryptedExtensionExtensionDataCombinator)
-    ensures o@ == spec_encrypted_extension_extension_data(ext_len@, extension_type@),
+pub fn hello_retry_extension_extension_data<'a>(extension_type: u16, ext_len: u16) -> (o: HelloRetryExtensionExtensionDataCombinator)
+    requires
+        spec_extension_type().wf(extension_type@),
+
+    ensures o@ == spec_hello_retry_extension_extension_data(extension_type@, ext_len@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = EncryptedExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.ex_into()), Mapped { inner: EncryptedExtensionExtensionDataCombinator8(Choice::new(Cond { cond: extension_type == ExtensionType::ServerName, inner: empty() }, EncryptedExtensionExtensionDataCombinator7(Choice::new(Cond { cond: extension_type == ExtensionType::MaxFragmentLength, inner: max_fragment_length() }, EncryptedExtensionExtensionDataCombinator6(Choice::new(Cond { cond: extension_type == ExtensionType::SupportedGroups, inner: named_group_list() }, EncryptedExtensionExtensionDataCombinator5(Choice::new(Cond { cond: extension_type == ExtensionType::Heartbeat, inner: heartbeat_mode() }, EncryptedExtensionExtensionDataCombinator4(Choice::new(Cond { cond: extension_type == ExtensionType::ApplicationLayerProtocolNegotiation, inner: protocol_name_list() }, EncryptedExtensionExtensionDataCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::ClientCertificateType, inner: client_cert_type_client_extension() }, EncryptedExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::ServerCertificateType, inner: server_cert_type_client_extension() }, EncryptedExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::EarlyData, inner: empty() }, Cond { cond: !(extension_type == ExtensionType::ServerName || extension_type == ExtensionType::MaxFragmentLength || extension_type == ExtensionType::SupportedGroups || extension_type == ExtensionType::Heartbeat || extension_type == ExtensionType::ApplicationLayerProtocolNegotiation || extension_type == ExtensionType::ClientCertificateType || extension_type == ExtensionType::ServerCertificateType || extension_type == ExtensionType::EarlyData), inner: bytes::Variable(ext_len.ex_into()) })))))))))))))))), mapper: EncryptedExtensionExtensionDataMapper }));
-    assert({
-        &&& combinator@ == spec_encrypted_extension_extension_data(ext_len@, extension_type@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = HelloRetryExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::ex_from(ext_len)) as usize), Mapped { inner: HelloRetryExtensionExtensionDataCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::SupportedVersions, inner: supported_versions_server() }, HelloRetryExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::Cookie, inner: cookie() }, HelloRetryExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::KeyShare, inner: named_group() }, Cond { cond: !(extension_type == ExtensionType::SupportedVersions || extension_type == ExtensionType::Cookie || extension_type == ExtensionType::KeyShare), inner: bytes::Variable((usize::ex_from(ext_len)) as usize) })))))), mapper: HelloRetryExtensionExtensionDataMapper }));
+    // assert({
+    //     &&& combinator@ == spec_hello_retry_extension_extension_data(extension_type@, ext_len@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_encrypted_extension_extension_data<'a>(input: &'a [u8], ext_len: u16, extension_type: u16) -> (res: PResult<<EncryptedExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_hello_retry_extension_extension_data<'a>(input: &'a [u8], extension_type: u16, ext_len: u16) -> (res: PResult<<HelloRetryExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) == Some((n as int, v@)),
-        spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) == Some((n as int, v@)),
+        spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None,
-        spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None,
+        spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = encrypted_extension_extension_data( ext_len, extension_type );
+    let combinator = hello_retry_extension_extension_data( extension_type, ext_len );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_encrypted_extension_extension_data<'a>(v: <EncryptedExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16, extension_type: u16) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_hello_retry_extension_extension_data<'a>(v: <HelloRetryExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, extension_type: u16, ext_len: u16) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_encrypted_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_hello_retry_extension_extension_data(extension_type@, ext_len@).wf(v@),
+        spec_extension_type().wf(extension_type@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@))
+            &&& n == spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@))
         },
 {
-    let combinator = encrypted_extension_extension_data( ext_len, extension_type );
+    let combinator = hello_retry_extension_extension_data( extension_type, ext_len );
     combinator.serialize(v, data, pos)
 }
 
-pub fn encrypted_extension_extension_data_len<'a>(v: <EncryptedExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16, extension_type: u16) -> (serialize_len: usize)
+pub fn hello_retry_extension_extension_data_len<'a>(v: <HelloRetryExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, extension_type: u16, ext_len: u16) -> (serialize_len: usize)
     requires
-        spec_encrypted_extension_extension_data(ext_len@, extension_type@).wf(v@),
-        spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_hello_retry_extension_extension_data(extension_type@, ext_len@).wf(v@),
+        spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        serialize_len == spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len(),
+        serialize_len == spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len(),
 {
-    let combinator = encrypted_extension_extension_data( ext_len, extension_type );
+    let combinator = hello_retry_extension_extension_data( extension_type, ext_len );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
 
-pub struct SpecEncryptedExtension {
+pub struct SpecHelloRetryExtension {
     pub extension_type: u16,
     pub ext_len: u16,
-    pub extension_data: SpecEncryptedExtensionExtensionData,
+    pub extension_data: SpecHelloRetryExtensionExtensionData,
 }
 
-pub type SpecEncryptedExtensionInner = ((u16, u16), SpecEncryptedExtensionExtensionData);
+pub type SpecHelloRetryExtensionInner = ((u16, u16), SpecHelloRetryExtensionExtensionData);
 
 
-impl SpecFrom<SpecEncryptedExtension> for SpecEncryptedExtensionInner {
-    open spec fn spec_from(m: SpecEncryptedExtension) -> SpecEncryptedExtensionInner {
+impl SpecFrom<SpecHelloRetryExtension> for SpecHelloRetryExtensionInner {
+    open spec fn spec_from(m: SpecHelloRetryExtension) -> SpecHelloRetryExtensionInner {
         ((m.extension_type, m.ext_len), m.extension_data)
     }
 }
 
-impl SpecFrom<SpecEncryptedExtensionInner> for SpecEncryptedExtension {
-    open spec fn spec_from(m: SpecEncryptedExtensionInner) -> SpecEncryptedExtension {
+impl SpecFrom<SpecHelloRetryExtensionInner> for SpecHelloRetryExtension {
+    open spec fn spec_from(m: SpecHelloRetryExtensionInner) -> SpecHelloRetryExtension {
         let ((extension_type, ext_len), extension_data) = m;
-        SpecEncryptedExtension { extension_type, ext_len, extension_data }
+        SpecHelloRetryExtension { extension_type, ext_len, extension_data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct EncryptedExtension<'a> {
+pub struct HelloRetryExtension<'a> {
     pub extension_type: u16,
     pub ext_len: u16,
-    pub extension_data: EncryptedExtensionExtensionData<'a>,
+    pub extension_data: HelloRetryExtensionExtensionData<'a>,
 }
 
-impl View for EncryptedExtension<'_> {
-    type V = SpecEncryptedExtension;
+impl View for HelloRetryExtension<'_> {
+    type V = SpecHelloRetryExtension;
 
     open spec fn view(&self) -> Self::V {
-        SpecEncryptedExtension {
+        SpecHelloRetryExtension {
             extension_type: self.extension_type@,
             ext_len: self.ext_len@,
             extension_data: self.extension_data@,
         }
     }
 }
-pub type EncryptedExtensionInner<'a> = ((u16, u16), EncryptedExtensionExtensionData<'a>);
+pub type HelloRetryExtensionInner<'a> = ((u16, u16), HelloRetryExtensionExtensionData<'a>);
 
-pub type EncryptedExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a EncryptedExtensionExtensionData<'a>);
-impl<'a> From<&'a EncryptedExtension<'a>> for EncryptedExtensionInnerRef<'a> {
-    fn ex_from(m: &'a EncryptedExtension) -> EncryptedExtensionInnerRef<'a> {
+pub type HelloRetryExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a HelloRetryExtensionExtensionData<'a>);
+impl<'a> From<&'a HelloRetryExtension<'a>> for HelloRetryExtensionInnerRef<'a> {
+    fn ex_from(m: &'a HelloRetryExtension) -> HelloRetryExtensionInnerRef<'a> {
         ((&m.extension_type, &m.ext_len), &m.extension_data)
     }
 }
 
-impl<'a> From<EncryptedExtensionInner<'a>> for EncryptedExtension<'a> {
-    fn ex_from(m: EncryptedExtensionInner) -> EncryptedExtension {
+impl<'a> From<HelloRetryExtensionInner<'a>> for HelloRetryExtension<'a> {
+    fn ex_from(m: HelloRetryExtensionInner) -> HelloRetryExtension {
         let ((extension_type, ext_len), extension_data) = m;
-        EncryptedExtension { extension_type, ext_len, extension_data }
+        HelloRetryExtension { extension_type, ext_len, extension_data }
     }
 }
 
-pub struct EncryptedExtensionMapper;
-impl View for EncryptedExtensionMapper {
+pub struct HelloRetryExtensionMapper;
+impl View for HelloRetryExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for EncryptedExtensionMapper {
-    type Src = SpecEncryptedExtensionInner;
-    type Dst = SpecEncryptedExtension;
+impl SpecIso for HelloRetryExtensionMapper {
+    type Src = SpecHelloRetryExtensionInner;
+    type Dst = SpecHelloRetryExtension;
 }
-impl SpecIsoProof for EncryptedExtensionMapper {
+impl SpecIsoProof for HelloRetryExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -6569,179 +5860,183 @@ impl SpecIsoProof for EncryptedExtensionMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for EncryptedExtensionMapper {
-    type Src = EncryptedExtensionInner<'a>;
-    type Dst = EncryptedExtension<'a>;
-    type RefSrc = EncryptedExtensionInnerRef<'a>;
+impl<'a> Iso<'a> for HelloRetryExtensionMapper {
+    type Src = HelloRetryExtensionInner<'a>;
+    type Dst = HelloRetryExtension<'a>;
+    type RefSrc = HelloRetryExtensionInnerRef<'a>;
 }
 
-pub struct SpecEncryptedExtensionCombinator(pub SpecEncryptedExtensionCombinatorAlias);
+pub struct SpecHelloRetryExtensionCombinator(pub SpecHelloRetryExtensionCombinatorAlias);
 
-impl SpecCombinator for SpecEncryptedExtensionCombinator {
-    type Type = SpecEncryptedExtension;
+impl SpecCombinator for SpecHelloRetryExtensionCombinator {
+    type Type = SpecHelloRetryExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecEncryptedExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecEncryptedExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecHelloRetryExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHelloRetryExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecEncryptedExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecEncryptedExtensionExtensionDataCombinator>, EncryptedExtensionMapper>;
+pub type SpecHelloRetryExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecHelloRetryExtensionExtensionDataCombinator>, HelloRetryExtensionMapper>;
 
-pub struct EncryptedExtensionCombinator(pub EncryptedExtensionCombinatorAlias);
+pub struct HelloRetryExtensionCombinator(pub HelloRetryExtensionCombinatorAlias);
 
-impl View for EncryptedExtensionCombinator {
-    type V = SpecEncryptedExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecEncryptedExtensionCombinator(self.0@) }
+impl View for HelloRetryExtensionCombinator {
+    type V = SpecHelloRetryExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecHelloRetryExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EncryptedExtensionCombinator {
-    type Type = EncryptedExtension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HelloRetryExtensionCombinator {
+    type Type = HelloRetryExtension<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type EncryptedExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, EncryptedExtensionCont1>, EncryptedExtensionExtensionDataCombinator, EncryptedExtensionCont0>, EncryptedExtensionMapper>;
+}
+pub type HelloRetryExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, HelloRetryExtensionCont1>, HelloRetryExtensionExtensionDataCombinator, HelloRetryExtensionCont0>, HelloRetryExtensionMapper>;
 
 
-pub open spec fn spec_encrypted_extension() -> SpecEncryptedExtensionCombinator {
-    SpecEncryptedExtensionCombinator(
+pub open spec fn spec_hello_retry_extension() -> SpecHelloRetryExtensionCombinator {
+    SpecHelloRetryExtensionCombinator(
     Mapped {
-        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_encrypted_extension_cont1(deps)), |deps| spec_encrypted_extension_cont0(deps)),
-        mapper: EncryptedExtensionMapper,
+        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_hello_retry_extension_cont1(deps)), |deps| spec_hello_retry_extension_cont0(deps)),
+        mapper: HelloRetryExtensionMapper,
     })
 }
 
-pub open spec fn spec_encrypted_extension_cont1(deps: u16) -> U16Be {
+pub open spec fn spec_hello_retry_extension_cont1(deps: u16) -> U16Be {
     let extension_type = deps;
     U16Be
 }
 
-impl View for EncryptedExtensionCont1 {
+impl View for HelloRetryExtensionCont1 {
     type V = spec_fn(u16) -> U16Be;
 
     open spec fn view(&self) -> Self::V {
         |deps: u16| {
-            spec_encrypted_extension_cont1(deps)
+            spec_hello_retry_extension_cont1(deps)
         }
     }
 }
 
-pub open spec fn spec_encrypted_extension_cont0(deps: (u16, u16)) -> SpecEncryptedExtensionExtensionDataCombinator {
+pub open spec fn spec_hello_retry_extension_cont0(deps: (u16, u16)) -> SpecHelloRetryExtensionExtensionDataCombinator {
     let (extension_type, ext_len) = deps;
-    spec_encrypted_extension_extension_data(ext_len, extension_type)
+    spec_hello_retry_extension_extension_data(extension_type, ext_len)
 }
 
-impl View for EncryptedExtensionCont0 {
-    type V = spec_fn((u16, u16)) -> SpecEncryptedExtensionExtensionDataCombinator;
+impl View for HelloRetryExtensionCont0 {
+    type V = spec_fn((u16, u16)) -> SpecHelloRetryExtensionExtensionDataCombinator;
 
     open spec fn view(&self) -> Self::V {
         |deps: (u16, u16)| {
-            spec_encrypted_extension_cont0(deps)
+            spec_hello_retry_extension_cont0(deps)
         }
     }
 }
 
                 
-pub fn encrypted_extension<'a>() -> (o: EncryptedExtensionCombinator)
-    ensures o@ == spec_encrypted_extension(),
+pub fn hello_retry_extension<'a>() -> (o: HelloRetryExtensionCombinator)
+    ensures o@ == spec_hello_retry_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = EncryptedExtensionCombinator(
+    let combinator = HelloRetryExtensionCombinator(
     Mapped {
-        inner: Pair::new(Pair::new(extension_type(), EncryptedExtensionCont1), EncryptedExtensionCont0),
-        mapper: EncryptedExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_encrypted_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Pair::new(extension_type(), HelloRetryExtensionCont1), HelloRetryExtensionCont0),
+        mapper: HelloRetryExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_hello_retry_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_encrypted_extension<'a>(input: &'a [u8]) -> (res: PResult<<EncryptedExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_hello_retry_extension<'a>(input: &'a [u8]) -> (res: PResult<<HelloRetryExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_encrypted_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_encrypted_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_hello_retry_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_hello_retry_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_encrypted_extension().spec_parse(input@) is None,
-        spec_encrypted_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_hello_retry_extension().spec_parse(input@) is None,
+        spec_hello_retry_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = encrypted_extension();
+    let combinator = hello_retry_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_encrypted_extension<'a>(v: <EncryptedExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_hello_retry_extension<'a>(v: <HelloRetryExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_encrypted_extension().wf(v@),
+        spec_hello_retry_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_encrypted_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_encrypted_extension().spec_serialize(v@))
+            &&& n == spec_hello_retry_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_hello_retry_extension().spec_serialize(v@))
         },
 {
-    let combinator = encrypted_extension();
+    let combinator = hello_retry_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn encrypted_extension_len<'a>(v: <EncryptedExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn hello_retry_extension_len<'a>(v: <HelloRetryExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_encrypted_extension().wf(v@),
-        spec_encrypted_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_hello_retry_extension().wf(v@),
+        spec_hello_retry_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_encrypted_extension().spec_serialize(v@).len(),
+        serialize_len == spec_hello_retry_extension().spec_serialize(v@).len(),
 {
-    let combinator = encrypted_extension();
+    let combinator = hello_retry_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct EncryptedExtensionCont1;
-type EncryptedExtensionCont1Type<'a, 'b> = &'b u16;
-type EncryptedExtensionCont1SType<'a, 'x> = &'x u16;
-type EncryptedExtensionCont1Input<'a, 'b, 'x> = POrSType<EncryptedExtensionCont1Type<'a, 'b>, EncryptedExtensionCont1SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<EncryptedExtensionCont1Input<'a, 'b, 'x>> for EncryptedExtensionCont1 {
+pub struct HelloRetryExtensionCont1;
+type HelloRetryExtensionCont1Type<'a, 'b> = &'b u16;
+type HelloRetryExtensionCont1SType<'a, 'x> = &'x u16;
+type HelloRetryExtensionCont1Input<'a, 'b, 'x> = POrSType<HelloRetryExtensionCont1Type<'a, 'b>, HelloRetryExtensionCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<HelloRetryExtensionCont1Input<'a, 'b, 'x>> for HelloRetryExtensionCont1 {
     type Output = U16Be;
 
-    open spec fn requires(&self, deps: EncryptedExtensionCont1Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: HelloRetryExtensionCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_extension_type()).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: EncryptedExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_encrypted_extension_cont1(deps@)
+    open spec fn ensures(&self, deps: HelloRetryExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_hello_retry_extension_cont1(deps@)
     }
 
-    fn apply(&self, deps: EncryptedExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: HelloRetryExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let extension_type = *deps;
+                let extension_type = deps;
+                let extension_type = *extension_type;
                 U16Be
             }
             POrSType::S(deps) => {
@@ -6752,100 +6047,106 @@ impl<'a, 'b, 'x> Continuation<EncryptedExtensionCont1Input<'a, 'b, 'x>> for Encr
         }
     }
 }
-pub struct EncryptedExtensionCont0;
-type EncryptedExtensionCont0Type<'a, 'b> = &'b (u16, u16);
-type EncryptedExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
-type EncryptedExtensionCont0Input<'a, 'b, 'x> = POrSType<EncryptedExtensionCont0Type<'a, 'b>, EncryptedExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<EncryptedExtensionCont0Input<'a, 'b, 'x>> for EncryptedExtensionCont0 {
-    type Output = EncryptedExtensionExtensionDataCombinator;
+pub struct HelloRetryExtensionCont0;
+type HelloRetryExtensionCont0Type<'a, 'b> = &'b (u16, u16);
+type HelloRetryExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
+type HelloRetryExtensionCont0Input<'a, 'b, 'x> = POrSType<HelloRetryExtensionCont0Type<'a, 'b>, HelloRetryExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<HelloRetryExtensionCont0Input<'a, 'b, 'x>> for HelloRetryExtensionCont0 {
+    type Output = HelloRetryExtensionExtensionDataCombinator;
 
-    open spec fn requires(&self, deps: EncryptedExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: HelloRetryExtensionCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_extension_type(), |deps| spec_hello_retry_extension_cont1(deps))).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: EncryptedExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_encrypted_extension_cont0(deps@)
+    open spec fn ensures(&self, deps: HelloRetryExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_hello_retry_extension_cont0(deps@)
     }
 
-    fn apply(&self, deps: EncryptedExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: HelloRetryExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let (extension_type, ext_len) = *deps;
-                encrypted_extension_extension_data(ext_len, extension_type)
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                hello_retry_extension_extension_data(extension_type, ext_len)
             }
             POrSType::S(deps) => {
                 let (extension_type, ext_len) = deps;
-                let (extension_type, ext_len) = (*extension_type, *ext_len);
-                encrypted_extension_extension_data(ext_len, extension_type)
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                hello_retry_extension_extension_data(extension_type, ext_len)
             }
         }
     }
 }
                 
 
-pub struct SpecEncryptedExtensions {
+pub struct SpecHelloRetryExtensions {
     pub l: u16,
-    pub list: Seq<SpecEncryptedExtension>,
+    pub list: Seq<SpecHelloRetryExtension>,
 }
 
-pub type SpecEncryptedExtensionsInner = (u16, Seq<SpecEncryptedExtension>);
+pub type SpecHelloRetryExtensionsInner = (u16, Seq<SpecHelloRetryExtension>);
 
 
-impl SpecFrom<SpecEncryptedExtensions> for SpecEncryptedExtensionsInner {
-    open spec fn spec_from(m: SpecEncryptedExtensions) -> SpecEncryptedExtensionsInner {
+impl SpecFrom<SpecHelloRetryExtensions> for SpecHelloRetryExtensionsInner {
+    open spec fn spec_from(m: SpecHelloRetryExtensions) -> SpecHelloRetryExtensionsInner {
         (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecEncryptedExtensionsInner> for SpecEncryptedExtensions {
-    open spec fn spec_from(m: SpecEncryptedExtensionsInner) -> SpecEncryptedExtensions {
+impl SpecFrom<SpecHelloRetryExtensionsInner> for SpecHelloRetryExtensions {
+    open spec fn spec_from(m: SpecHelloRetryExtensionsInner) -> SpecHelloRetryExtensions {
         let (l, list) = m;
-        SpecEncryptedExtensions { l, list }
+        SpecHelloRetryExtensions { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct EncryptedExtensions<'a> {
+pub struct HelloRetryExtensions<'a> {
     pub l: u16,
-    pub list: RepeatResult<EncryptedExtension<'a>>,
+    pub list: RepeatResult<HelloRetryExtension<'a>>,
 }
 
-impl View for EncryptedExtensions<'_> {
-    type V = SpecEncryptedExtensions;
+impl View for HelloRetryExtensions<'_> {
+    type V = SpecHelloRetryExtensions;
 
     open spec fn view(&self) -> Self::V {
-        SpecEncryptedExtensions {
+        SpecHelloRetryExtensions {
             l: self.l@,
             list: self.list@,
         }
     }
 }
-pub type EncryptedExtensionsInner<'a> = (u16, RepeatResult<EncryptedExtension<'a>>);
+pub type HelloRetryExtensionsInner<'a> = (u16, RepeatResult<HelloRetryExtension<'a>>);
 
-pub type EncryptedExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<EncryptedExtension<'a>>);
-impl<'a> From<&'a EncryptedExtensions<'a>> for EncryptedExtensionsInnerRef<'a> {
-    fn ex_from(m: &'a EncryptedExtensions) -> EncryptedExtensionsInnerRef<'a> {
+pub type HelloRetryExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<HelloRetryExtension<'a>>);
+impl<'a> From<&'a HelloRetryExtensions<'a>> for HelloRetryExtensionsInnerRef<'a> {
+    fn ex_from(m: &'a HelloRetryExtensions) -> HelloRetryExtensionsInnerRef<'a> {
         (&m.l, &m.list)
     }
 }
 
-impl<'a> From<EncryptedExtensionsInner<'a>> for EncryptedExtensions<'a> {
-    fn ex_from(m: EncryptedExtensionsInner) -> EncryptedExtensions {
+impl<'a> From<HelloRetryExtensionsInner<'a>> for HelloRetryExtensions<'a> {
+    fn ex_from(m: HelloRetryExtensionsInner) -> HelloRetryExtensions {
         let (l, list) = m;
-        EncryptedExtensions { l, list }
+        HelloRetryExtensions { l, list }
     }
 }
 
-pub struct EncryptedExtensionsMapper;
-impl View for EncryptedExtensionsMapper {
+pub struct HelloRetryExtensionsMapper;
+impl View for HelloRetryExtensionsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for EncryptedExtensionsMapper {
-    type Src = SpecEncryptedExtensionsInner;
-    type Dst = SpecEncryptedExtensions;
+impl SpecIso for HelloRetryExtensionsMapper {
+    type Src = SpecHelloRetryExtensionsInner;
+    type Dst = SpecHelloRetryExtensions;
 }
-impl SpecIsoProof for EncryptedExtensionsMapper {
+impl SpecIsoProof for HelloRetryExtensionsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -6853,483 +6154,697 @@ impl SpecIsoProof for EncryptedExtensionsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for EncryptedExtensionsMapper {
-    type Src = EncryptedExtensionsInner<'a>;
-    type Dst = EncryptedExtensions<'a>;
-    type RefSrc = EncryptedExtensionsInnerRef<'a>;
+impl<'a> Iso<'a> for HelloRetryExtensionsMapper {
+    type Src = HelloRetryExtensionsInner<'a>;
+    type Dst = HelloRetryExtensions<'a>;
+    type RefSrc = HelloRetryExtensionsInnerRef<'a>;
 }
 
-pub struct SpecEncryptedExtensionsCombinator(pub SpecEncryptedExtensionsCombinatorAlias);
+pub struct SpecHelloRetryExtensionsCombinator(pub SpecHelloRetryExtensionsCombinatorAlias);
 
-impl SpecCombinator for SpecEncryptedExtensionsCombinator {
-    type Type = SpecEncryptedExtensions;
+impl SpecCombinator for SpecHelloRetryExtensionsCombinator {
+    type Type = SpecHelloRetryExtensions;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecEncryptedExtensionsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecEncryptedExtensionsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecHelloRetryExtensionsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHelloRetryExtensionsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecEncryptedExtensionsCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecEncryptedExtensionCombinator>>>, EncryptedExtensionsMapper>;
+pub type SpecHelloRetryExtensionsCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate14496530480760116989>, AndThen<bytes::Variable, Repeat<SpecHelloRetryExtensionCombinator>>>, HelloRetryExtensionsMapper>;
+pub struct Predicate14496530480760116989;
+impl View for Predicate14496530480760116989 {
+    type V = Self;
 
-pub struct EncryptedExtensionsCombinator(pub EncryptedExtensionsCombinatorAlias);
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate14496530480760116989 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 6 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate14496530480760116989 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 6 && i <= 65535)
+    }
+}
 
-impl View for EncryptedExtensionsCombinator {
-    type V = SpecEncryptedExtensionsCombinator;
-    open spec fn view(&self) -> Self::V { SpecEncryptedExtensionsCombinator(self.0@) }
+pub struct HelloRetryExtensionsCombinator(pub HelloRetryExtensionsCombinatorAlias);
+
+impl View for HelloRetryExtensionsCombinator {
+    type V = SpecHelloRetryExtensionsCombinator;
+    open spec fn view(&self) -> Self::V { SpecHelloRetryExtensionsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EncryptedExtensionsCombinator {
-    type Type = EncryptedExtensions<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HelloRetryExtensionsCombinator {
+    type Type = HelloRetryExtensions<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type EncryptedExtensionsCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<EncryptedExtensionCombinator>>, EncryptedExtensionsCont0>, EncryptedExtensionsMapper>;
+}
+pub type HelloRetryExtensionsCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate14496530480760116989>, AndThen<bytes::Variable, Repeat<HelloRetryExtensionCombinator>>, HelloRetryExtensionsCont0>, HelloRetryExtensionsMapper>;
 
 
-pub open spec fn spec_encrypted_extensions() -> SpecEncryptedExtensionsCombinator {
-    SpecEncryptedExtensionsCombinator(
+pub open spec fn spec_hello_retry_extensions() -> SpecHelloRetryExtensionsCombinator {
+    SpecHelloRetryExtensionsCombinator(
     Mapped {
-        inner: Pair::spec_new(U16Be, |deps| spec_encrypted_extensions_cont0(deps)),
-        mapper: EncryptedExtensionsMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate14496530480760116989 }, |deps| spec_hello_retry_extensions_cont0(deps)),
+        mapper: HelloRetryExtensionsMapper,
     })
 }
 
-pub open spec fn spec_encrypted_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecEncryptedExtensionCombinator>> {
+pub open spec fn spec_hello_retry_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecHelloRetryExtensionCombinator>> {
     let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_encrypted_extension()))
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_hello_retry_extension()))
 }
 
-impl View for EncryptedExtensionsCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecEncryptedExtensionCombinator>>;
+impl View for HelloRetryExtensionsCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecHelloRetryExtensionCombinator>>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u16| {
-            spec_encrypted_extensions_cont0(deps)
+            spec_hello_retry_extensions_cont0(deps)
         }
     }
 }
 
                 
-pub fn encrypted_extensions<'a>() -> (o: EncryptedExtensionsCombinator)
-    ensures o@ == spec_encrypted_extensions(),
+pub fn hello_retry_extensions<'a>() -> (o: HelloRetryExtensionsCombinator)
+    ensures o@ == spec_hello_retry_extensions(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = EncryptedExtensionsCombinator(
+    let combinator = HelloRetryExtensionsCombinator(
     Mapped {
-        inner: Pair::new(U16Be, EncryptedExtensionsCont0),
-        mapper: EncryptedExtensionsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_encrypted_extensions()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate14496530480760116989 }, HelloRetryExtensionsCont0),
+        mapper: HelloRetryExtensionsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_hello_retry_extensions()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_encrypted_extensions<'a>(input: &'a [u8]) -> (res: PResult<<EncryptedExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_hello_retry_extensions<'a>(input: &'a [u8]) -> (res: PResult<<HelloRetryExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_encrypted_extensions().spec_parse(input@) == Some((n as int, v@)),
-        spec_encrypted_extensions().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_hello_retry_extensions().spec_parse(input@) == Some((n as int, v@)),
+        spec_hello_retry_extensions().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_encrypted_extensions().spec_parse(input@) is None,
-        spec_encrypted_extensions().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_hello_retry_extensions().spec_parse(input@) is None,
+        spec_hello_retry_extensions().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = encrypted_extensions();
+    let combinator = hello_retry_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_encrypted_extensions<'a>(v: <EncryptedExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_hello_retry_extensions<'a>(v: <HelloRetryExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_encrypted_extensions().wf(v@),
+        spec_hello_retry_extensions().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_encrypted_extensions().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_encrypted_extensions().spec_serialize(v@))
+            &&& n == spec_hello_retry_extensions().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_hello_retry_extensions().spec_serialize(v@))
         },
 {
-    let combinator = encrypted_extensions();
+    let combinator = hello_retry_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn encrypted_extensions_len<'a>(v: <EncryptedExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn hello_retry_extensions_len<'a>(v: <HelloRetryExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_encrypted_extensions().wf(v@),
-        spec_encrypted_extensions().spec_serialize(v@).len() <= usize::MAX,
+        spec_hello_retry_extensions().wf(v@),
+        spec_hello_retry_extensions().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_encrypted_extensions().spec_serialize(v@).len(),
+        serialize_len == spec_hello_retry_extensions().spec_serialize(v@).len(),
 {
-    let combinator = encrypted_extensions();
+    let combinator = hello_retry_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct EncryptedExtensionsCont0;
-type EncryptedExtensionsCont0Type<'a, 'b> = &'b u16;
-type EncryptedExtensionsCont0SType<'a, 'x> = &'x u16;
-type EncryptedExtensionsCont0Input<'a, 'b, 'x> = POrSType<EncryptedExtensionsCont0Type<'a, 'b>, EncryptedExtensionsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<EncryptedExtensionsCont0Input<'a, 'b, 'x>> for EncryptedExtensionsCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<EncryptedExtensionCombinator>>;
+pub struct HelloRetryExtensionsCont0;
+type HelloRetryExtensionsCont0Type<'a, 'b> = &'b u16;
+type HelloRetryExtensionsCont0SType<'a, 'x> = &'x u16;
+type HelloRetryExtensionsCont0Input<'a, 'b, 'x> = POrSType<HelloRetryExtensionsCont0Type<'a, 'b>, HelloRetryExtensionsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<HelloRetryExtensionsCont0Input<'a, 'b, 'x>> for HelloRetryExtensionsCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<HelloRetryExtensionCombinator>>;
 
-    open spec fn requires(&self, deps: EncryptedExtensionsCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: HelloRetryExtensionsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate14496530480760116989 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: EncryptedExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_encrypted_extensions_cont0(deps@)
+    open spec fn ensures(&self, deps: HelloRetryExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_hello_retry_extensions_cont0(deps@)
     }
 
-    fn apply(&self, deps: EncryptedExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: HelloRetryExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(encrypted_extension()))
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(hello_retry_extension()))
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(encrypted_extension()))
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(hello_retry_extension()))
             }
         }
     }
 }
                 
-pub mod EcPointFormat {
-    use super::*;
-    pub spec const SPEC_Uncompressed: u8 = 0;
-    pub spec const SPEC_AnsiX962CompressedPrime: u8 = 1;
-    pub spec const SPEC_AnsiX962CompressedChar2: u8 = 2;
-    pub exec const Uncompressed: u8 ensures Uncompressed == SPEC_Uncompressed { 0 }
-    pub exec const AnsiX962CompressedPrime: u8 ensures AnsiX962CompressedPrime == SPEC_AnsiX962CompressedPrime { 1 }
-    pub exec const AnsiX962CompressedChar2: u8 ensures AnsiX962CompressedChar2 == SPEC_AnsiX962CompressedChar2 { 2 }
+
+pub struct SpecHelloRetryRequest {
+    pub legacy_session_id_echo: SpecSessionId,
+    pub cipher_suite: u16,
+    pub legacy_compression_method: u8,
+    pub extensions: SpecHelloRetryExtensions,
 }
 
+pub type SpecHelloRetryRequestInner = (SpecSessionId, (u16, (u8, SpecHelloRetryExtensions)));
 
-pub struct SpecEcPointFormatCombinator(pub SpecEcPointFormatCombinatorAlias);
 
-impl SpecCombinator for SpecEcPointFormatCombinator {
-    type Type = u8;
+impl SpecFrom<SpecHelloRetryRequest> for SpecHelloRetryRequestInner {
+    open spec fn spec_from(m: SpecHelloRetryRequest) -> SpecHelloRetryRequestInner {
+        (m.legacy_session_id_echo, (m.cipher_suite, (m.legacy_compression_method, m.extensions)))
+    }
+}
+
+impl SpecFrom<SpecHelloRetryRequestInner> for SpecHelloRetryRequest {
+    open spec fn spec_from(m: SpecHelloRetryRequestInner) -> SpecHelloRetryRequest {
+        let (legacy_session_id_echo, (cipher_suite, (legacy_compression_method, extensions))) = m;
+        SpecHelloRetryRequest { legacy_session_id_echo, cipher_suite, legacy_compression_method, extensions }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct HelloRetryRequest<'a> {
+    pub legacy_session_id_echo: SessionId<'a>,
+    pub cipher_suite: u16,
+    pub legacy_compression_method: u8,
+    pub extensions: HelloRetryExtensions<'a>,
+}
+
+impl View for HelloRetryRequest<'_> {
+    type V = SpecHelloRetryRequest;
+
+    open spec fn view(&self) -> Self::V {
+        SpecHelloRetryRequest {
+            legacy_session_id_echo: self.legacy_session_id_echo@,
+            cipher_suite: self.cipher_suite@,
+            legacy_compression_method: self.legacy_compression_method@,
+            extensions: self.extensions@,
+        }
+    }
+}
+pub type HelloRetryRequestInner<'a> = (SessionId<'a>, (u16, (u8, HelloRetryExtensions<'a>)));
+
+pub type HelloRetryRequestInnerRef<'a> = (&'a SessionId<'a>, (&'a u16, (&'a u8, &'a HelloRetryExtensions<'a>)));
+impl<'a> From<&'a HelloRetryRequest<'a>> for HelloRetryRequestInnerRef<'a> {
+    fn ex_from(m: &'a HelloRetryRequest) -> HelloRetryRequestInnerRef<'a> {
+        (&m.legacy_session_id_echo, (&m.cipher_suite, (&m.legacy_compression_method, &m.extensions)))
+    }
+}
+
+impl<'a> From<HelloRetryRequestInner<'a>> for HelloRetryRequest<'a> {
+    fn ex_from(m: HelloRetryRequestInner) -> HelloRetryRequest {
+        let (legacy_session_id_echo, (cipher_suite, (legacy_compression_method, extensions))) = m;
+        HelloRetryRequest { legacy_session_id_echo, cipher_suite, legacy_compression_method, extensions }
+    }
+}
+
+pub struct HelloRetryRequestMapper;
+impl View for HelloRetryRequestMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for HelloRetryRequestMapper {
+    type Src = SpecHelloRetryRequestInner;
+    type Dst = SpecHelloRetryRequest;
+}
+impl SpecIsoProof for HelloRetryRequestMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for HelloRetryRequestMapper {
+    type Src = HelloRetryRequestInner<'a>;
+    type Dst = HelloRetryRequest<'a>;
+    type RefSrc = HelloRetryRequestInnerRef<'a>;
+}
+pub const HELLORETRYREQUESTLEGACY_COMPRESSION_METHOD_CONST: u8 = 0;
+type SpecHelloRetryRequestCombinatorAlias1 = (Refined<U8, TagPred<u8>>, SpecHelloRetryExtensionsCombinator);
+type SpecHelloRetryRequestCombinatorAlias2 = (SpecCipherSuiteCombinator, SpecHelloRetryRequestCombinatorAlias1);
+type SpecHelloRetryRequestCombinatorAlias3 = (SpecSessionIdCombinator, SpecHelloRetryRequestCombinatorAlias2);
+pub struct SpecHelloRetryRequestCombinator(pub SpecHelloRetryRequestCombinatorAlias);
+
+impl SpecCombinator for SpecHelloRetryRequestCombinator {
+    type Type = SpecHelloRetryRequest;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecEcPointFormatCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecEcPointFormatCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecHelloRetryRequestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHelloRetryRequestCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecEcPointFormatCombinatorAlias = U8;
+pub type SpecHelloRetryRequestCombinatorAlias = Mapped<SpecHelloRetryRequestCombinatorAlias3, HelloRetryRequestMapper>;
+type HelloRetryRequestCombinatorAlias1 = (Refined<U8, TagPred<u8>>, HelloRetryExtensionsCombinator);
+type HelloRetryRequestCombinatorAlias2 = (CipherSuiteCombinator, HelloRetryRequestCombinator1);
+type HelloRetryRequestCombinatorAlias3 = (SessionIdCombinator, HelloRetryRequestCombinator2);
+pub struct HelloRetryRequestCombinator1(pub HelloRetryRequestCombinatorAlias1);
+impl View for HelloRetryRequestCombinator1 {
+    type V = SpecHelloRetryRequestCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(HelloRetryRequestCombinator1, HelloRetryRequestCombinatorAlias1);
 
-pub struct EcPointFormatCombinator(pub EcPointFormatCombinatorAlias);
+pub struct HelloRetryRequestCombinator2(pub HelloRetryRequestCombinatorAlias2);
+impl View for HelloRetryRequestCombinator2 {
+    type V = SpecHelloRetryRequestCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(HelloRetryRequestCombinator2, HelloRetryRequestCombinatorAlias2);
 
-impl View for EcPointFormatCombinator {
-    type V = SpecEcPointFormatCombinator;
-    open spec fn view(&self) -> Self::V { SpecEcPointFormatCombinator(self.0@) }
+pub struct HelloRetryRequestCombinator3(pub HelloRetryRequestCombinatorAlias3);
+impl View for HelloRetryRequestCombinator3 {
+    type V = SpecHelloRetryRequestCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EcPointFormatCombinator {
-    type Type = u8;
+impl_wrapper_combinator!(HelloRetryRequestCombinator3, HelloRetryRequestCombinatorAlias3);
+
+pub struct HelloRetryRequestCombinator(pub HelloRetryRequestCombinatorAlias);
+
+impl View for HelloRetryRequestCombinator {
+    type V = SpecHelloRetryRequestCombinator;
+    open spec fn view(&self) -> Self::V { SpecHelloRetryRequestCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HelloRetryRequestCombinator {
+    type Type = HelloRetryRequest<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type EcPointFormatCombinatorAlias = U8;
+}
+pub type HelloRetryRequestCombinatorAlias = Mapped<HelloRetryRequestCombinator3, HelloRetryRequestMapper>;
 
 
-pub open spec fn spec_ec_point_format() -> SpecEcPointFormatCombinator {
-    SpecEcPointFormatCombinator(U8)
+pub open spec fn spec_hello_retry_request() -> SpecHelloRetryRequestCombinator {
+    SpecHelloRetryRequestCombinator(
+    Mapped {
+        inner: (spec_session_id(), (spec_cipher_suite(), (Refined { inner: U8, predicate: TagPred(HELLORETRYREQUESTLEGACY_COMPRESSION_METHOD_CONST) }, spec_hello_retry_extensions()))),
+        mapper: HelloRetryRequestMapper,
+    })
 }
 
                 
-pub fn ec_point_format<'a>() -> (o: EcPointFormatCombinator)
-    ensures o@ == spec_ec_point_format(),
+pub fn hello_retry_request<'a>() -> (o: HelloRetryRequestCombinator)
+    ensures o@ == spec_hello_retry_request(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = EcPointFormatCombinator(U8);
-    assert({
-        &&& combinator@ == spec_ec_point_format()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = HelloRetryRequestCombinator(
+    Mapped {
+        inner: HelloRetryRequestCombinator3((session_id(), HelloRetryRequestCombinator2((cipher_suite(), HelloRetryRequestCombinator1((Refined { inner: U8, predicate: TagPred(HELLORETRYREQUESTLEGACY_COMPRESSION_METHOD_CONST) }, hello_retry_extensions())))))),
+        mapper: HelloRetryRequestMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_hello_retry_request()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_ec_point_format<'a>(input: &'a [u8]) -> (res: PResult<<EcPointFormatCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_hello_retry_request<'a>(input: &'a [u8]) -> (res: PResult<<HelloRetryRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_ec_point_format().spec_parse(input@) == Some((n as int, v@)),
-        spec_ec_point_format().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_hello_retry_request().spec_parse(input@) == Some((n as int, v@)),
+        spec_hello_retry_request().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_ec_point_format().spec_parse(input@) is None,
-        spec_ec_point_format().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_hello_retry_request().spec_parse(input@) is None,
+        spec_hello_retry_request().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = ec_point_format();
+    let combinator = hello_retry_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_ec_point_format<'a>(v: <EcPointFormatCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_hello_retry_request<'a>(v: <HelloRetryRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_ec_point_format().wf(v@),
+        spec_hello_retry_request().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_ec_point_format().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_ec_point_format().spec_serialize(v@))
+            &&& n == spec_hello_retry_request().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_hello_retry_request().spec_serialize(v@))
         },
 {
-    let combinator = ec_point_format();
+    let combinator = hello_retry_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn ec_point_format_len<'a>(v: <EcPointFormatCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn hello_retry_request_len<'a>(v: <HelloRetryRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_ec_point_format().wf(v@),
-        spec_ec_point_format().spec_serialize(v@).len() <= usize::MAX,
+        spec_hello_retry_request().wf(v@),
+        spec_hello_retry_request().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_ec_point_format().spec_serialize(v@).len(),
+        serialize_len == spec_hello_retry_request().spec_serialize(v@).len(),
 {
-    let combinator = ec_point_format();
+    let combinator = hello_retry_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub type SpecOcspResponse = SpecOpaque1Ffffff;
-pub type OcspResponse<'a> = Opaque1Ffffff<'a>;
-pub type OcspResponseRef<'a> = &'a Opaque1Ffffff<'a>;
 
+pub struct SpecPreSharedKeyServerExtension {
+    pub selected_identity: u16,
+}
 
-pub struct SpecOcspResponseCombinator(pub SpecOcspResponseCombinatorAlias);
+pub type SpecPreSharedKeyServerExtensionInner = u16;
 
-impl SpecCombinator for SpecOcspResponseCombinator {
-    type Type = SpecOcspResponse;
+
+impl SpecFrom<SpecPreSharedKeyServerExtension> for SpecPreSharedKeyServerExtensionInner {
+    open spec fn spec_from(m: SpecPreSharedKeyServerExtension) -> SpecPreSharedKeyServerExtensionInner {
+        m.selected_identity
+    }
+}
+
+impl SpecFrom<SpecPreSharedKeyServerExtensionInner> for SpecPreSharedKeyServerExtension {
+    open spec fn spec_from(m: SpecPreSharedKeyServerExtensionInner) -> SpecPreSharedKeyServerExtension {
+        let selected_identity = m;
+        SpecPreSharedKeyServerExtension { selected_identity }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct PreSharedKeyServerExtension {
+    pub selected_identity: u16,
+}
+
+impl View for PreSharedKeyServerExtension {
+    type V = SpecPreSharedKeyServerExtension;
+
+    open spec fn view(&self) -> Self::V {
+        SpecPreSharedKeyServerExtension {
+            selected_identity: self.selected_identity@,
+        }
+    }
+}
+pub type PreSharedKeyServerExtensionInner = u16;
+
+pub type PreSharedKeyServerExtensionInnerRef<'a> = &'a u16;
+impl<'a> From<&'a PreSharedKeyServerExtension> for PreSharedKeyServerExtensionInnerRef<'a> {
+    fn ex_from(m: &'a PreSharedKeyServerExtension) -> PreSharedKeyServerExtensionInnerRef<'a> {
+        &m.selected_identity
+    }
+}
+
+impl From<PreSharedKeyServerExtensionInner> for PreSharedKeyServerExtension {
+    fn ex_from(m: PreSharedKeyServerExtensionInner) -> PreSharedKeyServerExtension {
+        let selected_identity = m;
+        PreSharedKeyServerExtension { selected_identity }
+    }
+}
+
+pub struct PreSharedKeyServerExtensionMapper;
+impl View for PreSharedKeyServerExtensionMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for PreSharedKeyServerExtensionMapper {
+    type Src = SpecPreSharedKeyServerExtensionInner;
+    type Dst = SpecPreSharedKeyServerExtension;
+}
+impl SpecIsoProof for PreSharedKeyServerExtensionMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for PreSharedKeyServerExtensionMapper {
+    type Src = PreSharedKeyServerExtensionInner;
+    type Dst = PreSharedKeyServerExtension;
+    type RefSrc = PreSharedKeyServerExtensionInnerRef<'a>;
+}
+
+pub struct SpecPreSharedKeyServerExtensionCombinator(pub SpecPreSharedKeyServerExtensionCombinatorAlias);
+
+impl SpecCombinator for SpecPreSharedKeyServerExtensionCombinator {
+    type Type = SpecPreSharedKeyServerExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOcspResponseCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOcspResponseCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecPreSharedKeyServerExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPreSharedKeyServerExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOcspResponseCombinatorAlias = SpecOpaque1FfffffCombinator;
+pub type SpecPreSharedKeyServerExtensionCombinatorAlias = Mapped<U16Be, PreSharedKeyServerExtensionMapper>;
 
-pub struct OcspResponseCombinator(pub OcspResponseCombinatorAlias);
+pub struct PreSharedKeyServerExtensionCombinator(pub PreSharedKeyServerExtensionCombinatorAlias);
 
-impl View for OcspResponseCombinator {
-    type V = SpecOcspResponseCombinator;
-    open spec fn view(&self) -> Self::V { SpecOcspResponseCombinator(self.0@) }
+impl View for PreSharedKeyServerExtensionCombinator {
+    type V = SpecPreSharedKeyServerExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecPreSharedKeyServerExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OcspResponseCombinator {
-    type Type = OcspResponse<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PreSharedKeyServerExtensionCombinator {
+    type Type = PreSharedKeyServerExtension;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type OcspResponseCombinatorAlias = Opaque1FfffffCombinator;
+}
+pub type PreSharedKeyServerExtensionCombinatorAlias = Mapped<U16Be, PreSharedKeyServerExtensionMapper>;
 
 
-pub open spec fn spec_ocsp_response() -> SpecOcspResponseCombinator {
-    SpecOcspResponseCombinator(spec_opaque_1_ffffff())
+pub open spec fn spec_pre_shared_key_server_extension() -> SpecPreSharedKeyServerExtensionCombinator {
+    SpecPreSharedKeyServerExtensionCombinator(
+    Mapped {
+        inner: U16Be,
+        mapper: PreSharedKeyServerExtensionMapper,
+    })
 }
 
                 
-pub fn ocsp_response<'a>() -> (o: OcspResponseCombinator)
-    ensures o@ == spec_ocsp_response(),
+pub fn pre_shared_key_server_extension<'a>() -> (o: PreSharedKeyServerExtensionCombinator)
+    ensures o@ == spec_pre_shared_key_server_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = OcspResponseCombinator(opaque_1_ffffff());
-    assert({
-        &&& combinator@ == spec_ocsp_response()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = PreSharedKeyServerExtensionCombinator(
+    Mapped {
+        inner: U16Be,
+        mapper: PreSharedKeyServerExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_pre_shared_key_server_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_ocsp_response<'a>(input: &'a [u8]) -> (res: PResult<<OcspResponseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_pre_shared_key_server_extension<'a>(input: &'a [u8]) -> (res: PResult<<PreSharedKeyServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_ocsp_response().spec_parse(input@) == Some((n as int, v@)),
-        spec_ocsp_response().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_pre_shared_key_server_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_pre_shared_key_server_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_ocsp_response().spec_parse(input@) is None,
-        spec_ocsp_response().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_pre_shared_key_server_extension().spec_parse(input@) is None,
+        spec_pre_shared_key_server_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = ocsp_response();
+    let combinator = pre_shared_key_server_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_ocsp_response<'a>(v: <OcspResponseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_pre_shared_key_server_extension<'a>(v: <PreSharedKeyServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_ocsp_response().wf(v@),
+        spec_pre_shared_key_server_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_ocsp_response().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_ocsp_response().spec_serialize(v@))
+            &&& n == spec_pre_shared_key_server_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_pre_shared_key_server_extension().spec_serialize(v@))
         },
 {
-    let combinator = ocsp_response();
+    let combinator = pre_shared_key_server_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn ocsp_response_len<'a>(v: <OcspResponseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn pre_shared_key_server_extension_len<'a>(v: <PreSharedKeyServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_ocsp_response().wf(v@),
-        spec_ocsp_response().spec_serialize(v@).len() <= usize::MAX,
+        spec_pre_shared_key_server_extension().wf(v@),
+        spec_pre_shared_key_server_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_ocsp_response().spec_serialize(v@).len(),
+        serialize_len == spec_pre_shared_key_server_extension().spec_serialize(v@).len(),
 {
-    let combinator = ocsp_response();
+    let combinator = pre_shared_key_server_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecCertificateStatus {
-    pub status_type: u8,
-    pub response: SpecOcspResponse,
+pub struct SpecKeyShareEntry {
+    pub group: u16,
+    pub l: u16,
+    pub key_exchange: Seq<u8>,
 }
 
-pub type SpecCertificateStatusInner = (u8, SpecOcspResponse);
+pub type SpecKeyShareEntryInner = ((u16, u16), Seq<u8>);
 
 
-impl SpecFrom<SpecCertificateStatus> for SpecCertificateStatusInner {
-    open spec fn spec_from(m: SpecCertificateStatus) -> SpecCertificateStatusInner {
-        (m.status_type, m.response)
+impl SpecFrom<SpecKeyShareEntry> for SpecKeyShareEntryInner {
+    open spec fn spec_from(m: SpecKeyShareEntry) -> SpecKeyShareEntryInner {
+        ((m.group, m.l), m.key_exchange)
     }
 }
 
-impl SpecFrom<SpecCertificateStatusInner> for SpecCertificateStatus {
-    open spec fn spec_from(m: SpecCertificateStatusInner) -> SpecCertificateStatus {
-        let (status_type, response) = m;
-        SpecCertificateStatus { status_type, response }
+impl SpecFrom<SpecKeyShareEntryInner> for SpecKeyShareEntry {
+    open spec fn spec_from(m: SpecKeyShareEntryInner) -> SpecKeyShareEntry {
+        let ((group, l), key_exchange) = m;
+        SpecKeyShareEntry { group, l, key_exchange }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CertificateStatus<'a> {
-    pub status_type: u8,
-    pub response: OcspResponse<'a>,
+pub struct KeyShareEntry<'a> {
+    pub group: u16,
+    pub l: u16,
+    pub key_exchange: &'a [u8],
 }
 
-impl View for CertificateStatus<'_> {
-    type V = SpecCertificateStatus;
+impl View for KeyShareEntry<'_> {
+    type V = SpecKeyShareEntry;
 
     open spec fn view(&self) -> Self::V {
-        SpecCertificateStatus {
-            status_type: self.status_type@,
-            response: self.response@,
+        SpecKeyShareEntry {
+            group: self.group@,
+            l: self.l@,
+            key_exchange: self.key_exchange@,
         }
     }
 }
-pub type CertificateStatusInner<'a> = (u8, OcspResponse<'a>);
+pub type KeyShareEntryInner<'a> = ((u16, u16), &'a [u8]);
 
-pub type CertificateStatusInnerRef<'a> = (&'a u8, &'a OcspResponse<'a>);
-impl<'a> From<&'a CertificateStatus<'a>> for CertificateStatusInnerRef<'a> {
-    fn ex_from(m: &'a CertificateStatus) -> CertificateStatusInnerRef<'a> {
-        (&m.status_type, &m.response)
+pub type KeyShareEntryInnerRef<'a> = ((&'a u16, &'a u16), &'a &'a [u8]);
+impl<'a> From<&'a KeyShareEntry<'a>> for KeyShareEntryInnerRef<'a> {
+    fn ex_from(m: &'a KeyShareEntry) -> KeyShareEntryInnerRef<'a> {
+        ((&m.group, &m.l), &m.key_exchange)
     }
 }
 
-impl<'a> From<CertificateStatusInner<'a>> for CertificateStatus<'a> {
-    fn ex_from(m: CertificateStatusInner) -> CertificateStatus {
-        let (status_type, response) = m;
-        CertificateStatus { status_type, response }
+impl<'a> From<KeyShareEntryInner<'a>> for KeyShareEntry<'a> {
+    fn ex_from(m: KeyShareEntryInner) -> KeyShareEntry {
+        let ((group, l), key_exchange) = m;
+        KeyShareEntry { group, l, key_exchange }
     }
 }
 
-pub struct CertificateStatusMapper;
-impl View for CertificateStatusMapper {
+pub struct KeyShareEntryMapper;
+impl View for KeyShareEntryMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateStatusMapper {
-    type Src = SpecCertificateStatusInner;
-    type Dst = SpecCertificateStatus;
+impl SpecIso for KeyShareEntryMapper {
+    type Src = SpecKeyShareEntryInner;
+    type Dst = SpecKeyShareEntry;
 }
-impl SpecIsoProof for CertificateStatusMapper {
+impl SpecIsoProof for KeyShareEntryMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -7337,325 +6852,327 @@ impl SpecIsoProof for CertificateStatusMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateStatusMapper {
-    type Src = CertificateStatusInner<'a>;
-    type Dst = CertificateStatus<'a>;
-    type RefSrc = CertificateStatusInnerRef<'a>;
+impl<'a> Iso<'a> for KeyShareEntryMapper {
+    type Src = KeyShareEntryInner<'a>;
+    type Dst = KeyShareEntry<'a>;
+    type RefSrc = KeyShareEntryInnerRef<'a>;
 }
-pub const CERTIFICATESTATUSSTATUS_TYPE_CONST: u8 = 1;
-type SpecCertificateStatusCombinatorAlias1 = (Refined<U8, TagPred<u8>>, SpecOcspResponseCombinator);
-pub struct SpecCertificateStatusCombinator(pub SpecCertificateStatusCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateStatusCombinator {
-    type Type = SpecCertificateStatus;
+pub struct SpecKeyShareEntryCombinator(pub SpecKeyShareEntryCombinatorAlias);
+
+impl SpecCombinator for SpecKeyShareEntryCombinator {
+    type Type = SpecKeyShareEntry;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateStatusCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateStatusCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecKeyShareEntryCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecKeyShareEntryCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateStatusCombinatorAlias = Mapped<SpecCertificateStatusCombinatorAlias1, CertificateStatusMapper>;
-type CertificateStatusCombinatorAlias1 = (Refined<U8, TagPred<u8>>, OcspResponseCombinator);
-pub struct CertificateStatusCombinator1(pub CertificateStatusCombinatorAlias1);
-impl View for CertificateStatusCombinator1 {
-    type V = SpecCertificateStatusCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateStatusCombinator1, CertificateStatusCombinatorAlias1);
+pub type SpecKeyShareEntryCombinatorAlias = Mapped<SpecPair<SpecPair<SpecNamedGroupCombinator, Refined<U16Be, Predicate16977634203518580913>>, bytes::Variable>, KeyShareEntryMapper>;
 
-pub struct CertificateStatusCombinator(pub CertificateStatusCombinatorAlias);
+pub struct KeyShareEntryCombinator(pub KeyShareEntryCombinatorAlias);
 
-impl View for CertificateStatusCombinator {
-    type V = SpecCertificateStatusCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateStatusCombinator(self.0@) }
+impl View for KeyShareEntryCombinator {
+    type V = SpecKeyShareEntryCombinator;
+    open spec fn view(&self) -> Self::V { SpecKeyShareEntryCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateStatusCombinator {
-    type Type = CertificateStatus<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for KeyShareEntryCombinator {
+    type Type = KeyShareEntry<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateStatusCombinatorAlias = Mapped<CertificateStatusCombinator1, CertificateStatusMapper>;
+}
+pub type KeyShareEntryCombinatorAlias = Mapped<Pair<Pair<NamedGroupCombinator, Refined<U16Be, Predicate16977634203518580913>, KeyShareEntryCont1>, bytes::Variable, KeyShareEntryCont0>, KeyShareEntryMapper>;
 
 
-pub open spec fn spec_certificate_status() -> SpecCertificateStatusCombinator {
-    SpecCertificateStatusCombinator(
+pub open spec fn spec_key_share_entry() -> SpecKeyShareEntryCombinator {
+    SpecKeyShareEntryCombinator(
     Mapped {
-        inner: (Refined { inner: U8, predicate: TagPred(CERTIFICATESTATUSSTATUS_TYPE_CONST) }, spec_ocsp_response()),
-        mapper: CertificateStatusMapper,
+        inner: Pair::spec_new(Pair::spec_new(spec_named_group(), |deps| spec_key_share_entry_cont1(deps)), |deps| spec_key_share_entry_cont0(deps)),
+        mapper: KeyShareEntryMapper,
     })
 }
 
-                
-pub fn certificate_status<'a>() -> (o: CertificateStatusCombinator)
-    ensures o@ == spec_certificate_status(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = CertificateStatusCombinator(
-    Mapped {
-        inner: CertificateStatusCombinator1((Refined { inner: U8, predicate: TagPred(CERTIFICATESTATUSSTATUS_TYPE_CONST) }, ocsp_response())),
-        mapper: CertificateStatusMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_status()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
-
-pub fn parse_certificate_status<'a>(input: &'a [u8]) -> (res: PResult<<CertificateStatusCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_certificate_status().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_status().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_status().spec_parse(input@) is None,
-        spec_certificate_status().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = certificate_status();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
-}
-
-pub fn serialize_certificate_status<'a>(v: <CertificateStatusCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_status().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_status().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_status().spec_serialize(v@))
-        },
-{
-    let combinator = certificate_status();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
-}
-
-pub fn certificate_status_len<'a>(v: <CertificateStatusCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_certificate_status().wf(v@),
-        spec_certificate_status().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_certificate_status().spec_serialize(v@).len(),
-{
-    let combinator = certificate_status();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+pub open spec fn spec_key_share_entry_cont1(deps: u16) -> Refined<U16Be, Predicate16977634203518580913> {
+    let group = deps;
+    Refined { inner: U16Be, predicate: Predicate16977634203518580913 }
 }
 
-                
-pub type SpecSerializedSct = SpecOpaque1Ffff;
-pub type SerializedSct<'a> = Opaque1Ffff<'a>;
-pub type SerializedSctRef<'a> = &'a Opaque1Ffff<'a>;
-
-
-pub struct SpecSerializedSctCombinator(pub SpecSerializedSctCombinatorAlias);
+impl View for KeyShareEntryCont1 {
+    type V = spec_fn(u16) -> Refined<U16Be, Predicate16977634203518580913>;
 
-impl SpecCombinator for SpecSerializedSctCombinator {
-    type Type = SpecSerializedSct;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecSerializedSctCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSerializedSctCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_key_share_entry_cont1(deps)
+        }
+    }
 }
-pub type SpecSerializedSctCombinatorAlias = SpecOpaque1FfffCombinator;
-
-pub struct SerializedSctCombinator(pub SerializedSctCombinatorAlias);
 
-impl View for SerializedSctCombinator {
-    type V = SpecSerializedSctCombinator;
-    open spec fn view(&self) -> Self::V { SpecSerializedSctCombinator(self.0@) }
+pub open spec fn spec_key_share_entry_cont0(deps: (u16, u16)) -> bytes::Variable {
+    let (group, l) = deps;
+    bytes::Variable((usize::spec_from(l)) as usize)
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SerializedSctCombinator {
-    type Type = SerializedSct<'a>;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SerializedSctCombinatorAlias = Opaque1FfffCombinator;
 
+impl View for KeyShareEntryCont0 {
+    type V = spec_fn((u16, u16)) -> bytes::Variable;
 
-pub open spec fn spec_serialized_sct() -> SpecSerializedSctCombinator {
-    SpecSerializedSctCombinator(spec_opaque_1_ffff())
+    open spec fn view(&self) -> Self::V {
+        |deps: (u16, u16)| {
+            spec_key_share_entry_cont0(deps)
+        }
+    }
 }
 
                 
-pub fn serialized_sct<'a>() -> (o: SerializedSctCombinator)
-    ensures o@ == spec_serialized_sct(),
+pub fn key_share_entry<'a>() -> (o: KeyShareEntryCombinator)
+    ensures o@ == spec_key_share_entry(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = SerializedSctCombinator(opaque_1_ffff());
-    assert({
-        &&& combinator@ == spec_serialized_sct()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = KeyShareEntryCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(named_group(), KeyShareEntryCont1), KeyShareEntryCont0),
+        mapper: KeyShareEntryMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_key_share_entry()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_serialized_sct<'a>(input: &'a [u8]) -> (res: PResult<<SerializedSctCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_key_share_entry<'a>(input: &'a [u8]) -> (res: PResult<<KeyShareEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_serialized_sct().spec_parse(input@) == Some((n as int, v@)),
-        spec_serialized_sct().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_key_share_entry().spec_parse(input@) == Some((n as int, v@)),
+        spec_key_share_entry().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_serialized_sct().spec_parse(input@) is None,
-        spec_serialized_sct().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_key_share_entry().spec_parse(input@) is None,
+        spec_key_share_entry().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = serialized_sct();
+    let combinator = key_share_entry();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_serialized_sct<'a>(v: <SerializedSctCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_key_share_entry<'a>(v: <KeyShareEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_serialized_sct().wf(v@),
+        spec_key_share_entry().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_serialized_sct().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_serialized_sct().spec_serialize(v@))
+            &&& n == spec_key_share_entry().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_key_share_entry().spec_serialize(v@))
         },
 {
-    let combinator = serialized_sct();
+    let combinator = key_share_entry();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn serialized_sct_len<'a>(v: <SerializedSctCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn key_share_entry_len<'a>(v: <KeyShareEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_serialized_sct().wf(v@),
-        spec_serialized_sct().spec_serialize(v@).len() <= usize::MAX,
+        spec_key_share_entry().wf(v@),
+        spec_key_share_entry().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_serialized_sct().spec_serialize(v@).len(),
+        serialize_len == spec_key_share_entry().spec_serialize(v@).len(),
 {
-    let combinator = serialized_sct();
+    let combinator = key_share_entry();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
-
-pub struct SpecSignedCertificateTimestampList {
-    pub l: u16,
-    pub list: Seq<SpecSerializedSct>,
-}
-
-pub type SpecSignedCertificateTimestampListInner = (u16, Seq<SpecSerializedSct>);
+pub struct KeyShareEntryCont1;
+type KeyShareEntryCont1Type<'a, 'b> = &'b u16;
+type KeyShareEntryCont1SType<'a, 'x> = &'x u16;
+type KeyShareEntryCont1Input<'a, 'b, 'x> = POrSType<KeyShareEntryCont1Type<'a, 'b>, KeyShareEntryCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<KeyShareEntryCont1Input<'a, 'b, 'x>> for KeyShareEntryCont1 {
+    type Output = Refined<U16Be, Predicate16977634203518580913>;
 
+    open spec fn requires(&self, deps: KeyShareEntryCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_named_group()).wf(deps@)
+        }
 
-impl SpecFrom<SpecSignedCertificateTimestampList> for SpecSignedCertificateTimestampListInner {
-    open spec fn spec_from(m: SpecSignedCertificateTimestampList) -> SpecSignedCertificateTimestampListInner {
-        (m.l, m.list)
+    open spec fn ensures(&self, deps: KeyShareEntryCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_key_share_entry_cont1(deps@)
     }
-}
 
-impl SpecFrom<SpecSignedCertificateTimestampListInner> for SpecSignedCertificateTimestampList {
-    open spec fn spec_from(m: SpecSignedCertificateTimestampListInner) -> SpecSignedCertificateTimestampList {
-        let (l, list) = m;
-        SpecSignedCertificateTimestampList { l, list }
+    fn apply(&self, deps: KeyShareEntryCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let group = deps;
+                let group = *group;
+                Refined { inner: U16Be, predicate: Predicate16977634203518580913 }
+            }
+            POrSType::S(deps) => {
+                let group = deps;
+                let group = *group;
+                Refined { inner: U16Be, predicate: Predicate16977634203518580913 }
+            }
+        }
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct KeyShareEntryCont0;
+type KeyShareEntryCont0Type<'a, 'b> = &'b (u16, u16);
+type KeyShareEntryCont0SType<'a, 'x> = (&'x u16, &'x u16);
+type KeyShareEntryCont0Input<'a, 'b, 'x> = POrSType<KeyShareEntryCont0Type<'a, 'b>, KeyShareEntryCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<KeyShareEntryCont0Input<'a, 'b, 'x>> for KeyShareEntryCont0 {
+    type Output = bytes::Variable;
 
-pub struct SignedCertificateTimestampList<'a> {
-    pub l: u16,
-    pub list: RepeatResult<SerializedSct<'a>>,
-}
+    open spec fn requires(&self, deps: KeyShareEntryCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_named_group(), |deps| spec_key_share_entry_cont1(deps))).wf(deps@)
+        }
 
-impl View for SignedCertificateTimestampList<'_> {
-    type V = SpecSignedCertificateTimestampList;
+    open spec fn ensures(&self, deps: KeyShareEntryCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_key_share_entry_cont0(deps@)
+    }
 
-    open spec fn view(&self) -> Self::V {
-        SpecSignedCertificateTimestampList {
-            l: self.l@,
-            list: self.list@,
+    fn apply(&self, deps: KeyShareEntryCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (group, l) = deps;
+                let group = *group;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let (group, l) = deps;
+                let group = *group;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
+            }
         }
     }
 }
-pub type SignedCertificateTimestampListInner<'a> = (u16, RepeatResult<SerializedSct<'a>>);
+                
 
-pub type SignedCertificateTimestampListInnerRef<'a> = (&'a u16, &'a RepeatResult<SerializedSct<'a>>);
-impl<'a> From<&'a SignedCertificateTimestampList<'a>> for SignedCertificateTimestampListInnerRef<'a> {
-    fn ex_from(m: &'a SignedCertificateTimestampList) -> SignedCertificateTimestampListInnerRef<'a> {
-        (&m.l, &m.list)
-    }
+pub enum SpecSeverHelloExtensionExtensionData {
+    PreSharedKey(SpecPreSharedKeyServerExtension),
+    SupportedVersions(u16),
+    KeyShare(SpecKeyShareEntry),
+    Unrecognized(Seq<u8>),
 }
 
-impl<'a> From<SignedCertificateTimestampListInner<'a>> for SignedCertificateTimestampList<'a> {
-    fn ex_from(m: SignedCertificateTimestampListInner) -> SignedCertificateTimestampList {
-        let (l, list) = m;
-        SignedCertificateTimestampList { l, list }
+pub type SpecSeverHelloExtensionExtensionDataInner = Either<SpecPreSharedKeyServerExtension, Either<u16, Either<SpecKeyShareEntry, Seq<u8>>>>;
+
+impl SpecFrom<SpecSeverHelloExtensionExtensionData> for SpecSeverHelloExtensionExtensionDataInner {
+    open spec fn spec_from(m: SpecSeverHelloExtensionExtensionData) -> SpecSeverHelloExtensionExtensionDataInner {
+        match m {
+            SpecSeverHelloExtensionExtensionData::PreSharedKey(m) => Either::Left(m),
+            SpecSeverHelloExtensionExtensionData::SupportedVersions(m) => Either::Right(Either::Left(m)),
+            SpecSeverHelloExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecSeverHelloExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(m))),
+        }
     }
+
 }
 
-pub struct SignedCertificateTimestampListMapper;
-impl View for SignedCertificateTimestampListMapper {
+                
+impl SpecFrom<SpecSeverHelloExtensionExtensionDataInner> for SpecSeverHelloExtensionExtensionData {
+    open spec fn spec_from(m: SpecSeverHelloExtensionExtensionDataInner) -> SpecSeverHelloExtensionExtensionData {
+        match m {
+            Either::Left(m) => SpecSeverHelloExtensionExtensionData::PreSharedKey(m),
+            Either::Right(Either::Left(m)) => SpecSeverHelloExtensionExtensionData::SupportedVersions(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecSeverHelloExtensionExtensionData::KeyShare(m),
+            Either::Right(Either::Right(Either::Right(m))) => SpecSeverHelloExtensionExtensionData::Unrecognized(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SeverHelloExtensionExtensionData<'a> {
+    PreSharedKey(PreSharedKeyServerExtension),
+    SupportedVersions(u16),
+    KeyShare(KeyShareEntry<'a>),
+    Unrecognized(&'a [u8]),
+}
+
+pub type SeverHelloExtensionExtensionDataInner<'a> = Either<PreSharedKeyServerExtension, Either<u16, Either<KeyShareEntry<'a>, &'a [u8]>>>;
+
+pub type SeverHelloExtensionExtensionDataInnerRef<'a> = Either<&'a PreSharedKeyServerExtension, Either<&'a u16, Either<&'a KeyShareEntry<'a>, &'a &'a [u8]>>>;
+
+
+impl<'a> View for SeverHelloExtensionExtensionData<'a> {
+    type V = SpecSeverHelloExtensionExtensionData;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            SeverHelloExtensionExtensionData::PreSharedKey(m) => SpecSeverHelloExtensionExtensionData::PreSharedKey(m@),
+            SeverHelloExtensionExtensionData::SupportedVersions(m) => SpecSeverHelloExtensionExtensionData::SupportedVersions(m@),
+            SeverHelloExtensionExtensionData::KeyShare(m) => SpecSeverHelloExtensionExtensionData::KeyShare(m@),
+            SeverHelloExtensionExtensionData::Unrecognized(m) => SpecSeverHelloExtensionExtensionData::Unrecognized(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a SeverHelloExtensionExtensionData<'a>> for SeverHelloExtensionExtensionDataInnerRef<'a> {
+    fn ex_from(m: &'a SeverHelloExtensionExtensionData<'a>) -> SeverHelloExtensionExtensionDataInnerRef<'a> {
+        match m {
+            SeverHelloExtensionExtensionData::PreSharedKey(m) => Either::Left(m),
+            SeverHelloExtensionExtensionData::SupportedVersions(m) => Either::Right(Either::Left(m)),
+            SeverHelloExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Left(m))),
+            SeverHelloExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(m))),
+        }
+    }
+
+}
+
+impl<'a> From<SeverHelloExtensionExtensionDataInner<'a>> for SeverHelloExtensionExtensionData<'a> {
+    fn ex_from(m: SeverHelloExtensionExtensionDataInner<'a>) -> SeverHelloExtensionExtensionData<'a> {
+        match m {
+            Either::Left(m) => SeverHelloExtensionExtensionData::PreSharedKey(m),
+            Either::Right(Either::Left(m)) => SeverHelloExtensionExtensionData::SupportedVersions(m),
+            Either::Right(Either::Right(Either::Left(m))) => SeverHelloExtensionExtensionData::KeyShare(m),
+            Either::Right(Either::Right(Either::Right(m))) => SeverHelloExtensionExtensionData::Unrecognized(m),
+        }
+    }
+    
+}
+
+
+pub struct SeverHelloExtensionExtensionDataMapper;
+impl View for SeverHelloExtensionExtensionDataMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for SignedCertificateTimestampListMapper {
-    type Src = SpecSignedCertificateTimestampListInner;
-    type Dst = SpecSignedCertificateTimestampList;
+impl SpecIso for SeverHelloExtensionExtensionDataMapper {
+    type Src = SpecSeverHelloExtensionExtensionDataInner;
+    type Dst = SpecSeverHelloExtensionExtensionData;
 }
-impl SpecIsoProof for SignedCertificateTimestampListMapper {
+impl SpecIsoProof for SeverHelloExtensionExtensionDataMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -7663,288 +7180,227 @@ impl SpecIsoProof for SignedCertificateTimestampListMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for SignedCertificateTimestampListMapper {
-    type Src = SignedCertificateTimestampListInner<'a>;
-    type Dst = SignedCertificateTimestampList<'a>;
-    type RefSrc = SignedCertificateTimestampListInnerRef<'a>;
+impl<'a> Iso<'a> for SeverHelloExtensionExtensionDataMapper {
+    type Src = SeverHelloExtensionExtensionDataInner<'a>;
+    type Dst = SeverHelloExtensionExtensionData<'a>;
+    type RefSrc = SeverHelloExtensionExtensionDataInnerRef<'a>;
 }
 
-pub struct SpecSignedCertificateTimestampListCombinator(pub SpecSignedCertificateTimestampListCombinatorAlias);
+type SpecSeverHelloExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecKeyShareEntryCombinator>, Cond<bytes::Variable>>;
+type SpecSeverHelloExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecSupportedVersionsServerCombinator>, SpecSeverHelloExtensionExtensionDataCombinatorAlias1>;
+type SpecSeverHelloExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SpecPreSharedKeyServerExtensionCombinator>, SpecSeverHelloExtensionExtensionDataCombinatorAlias2>;
+pub struct SpecSeverHelloExtensionExtensionDataCombinator(pub SpecSeverHelloExtensionExtensionDataCombinatorAlias);
 
-impl SpecCombinator for SpecSignedCertificateTimestampListCombinator {
-    type Type = SpecSignedCertificateTimestampList;
+impl SpecCombinator for SpecSeverHelloExtensionExtensionDataCombinator {
+    type Type = SpecSeverHelloExtensionExtensionData;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecSignedCertificateTimestampListCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSignedCertificateTimestampListCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSeverHelloExtensionExtensionDataCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSeverHelloExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecSignedCertificateTimestampListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate16977634203518580913>, AndThen<bytes::Variable, Repeat<SpecSerializedSctCombinator>>>, SignedCertificateTimestampListMapper>;
-pub struct Predicate16977634203518580913;
-impl View for Predicate16977634203518580913 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
+pub type SpecSeverHelloExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecSeverHelloExtensionExtensionDataCombinatorAlias3, SeverHelloExtensionExtensionDataMapper>>;
+type SeverHelloExtensionExtensionDataCombinatorAlias1 = Choice<Cond<KeyShareEntryCombinator>, Cond<bytes::Variable>>;
+type SeverHelloExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SupportedVersionsServerCombinator>, SeverHelloExtensionExtensionDataCombinator1>;
+type SeverHelloExtensionExtensionDataCombinatorAlias3 = Choice<Cond<PreSharedKeyServerExtensionCombinator>, SeverHelloExtensionExtensionDataCombinator2>;
+pub struct SeverHelloExtensionExtensionDataCombinator1(pub SeverHelloExtensionExtensionDataCombinatorAlias1);
+impl View for SeverHelloExtensionExtensionDataCombinator1 {
+    type V = SpecSeverHelloExtensionExtensionDataCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl Pred<u16> for Predicate16977634203518580913 {
-    fn apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 1 && i <= 65535)
-    }
+impl_wrapper_combinator!(SeverHelloExtensionExtensionDataCombinator1, SeverHelloExtensionExtensionDataCombinatorAlias1);
+
+pub struct SeverHelloExtensionExtensionDataCombinator2(pub SeverHelloExtensionExtensionDataCombinatorAlias2);
+impl View for SeverHelloExtensionExtensionDataCombinator2 {
+    type V = SpecSeverHelloExtensionExtensionDataCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl SpecPred<u16> for Predicate16977634203518580913 {
-    open spec fn spec_apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 1 && i <= 65535)
-    }
+impl_wrapper_combinator!(SeverHelloExtensionExtensionDataCombinator2, SeverHelloExtensionExtensionDataCombinatorAlias2);
+
+pub struct SeverHelloExtensionExtensionDataCombinator3(pub SeverHelloExtensionExtensionDataCombinatorAlias3);
+impl View for SeverHelloExtensionExtensionDataCombinator3 {
+    type V = SpecSeverHelloExtensionExtensionDataCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(SeverHelloExtensionExtensionDataCombinator3, SeverHelloExtensionExtensionDataCombinatorAlias3);
 
-pub struct SignedCertificateTimestampListCombinator(pub SignedCertificateTimestampListCombinatorAlias);
+pub struct SeverHelloExtensionExtensionDataCombinator(pub SeverHelloExtensionExtensionDataCombinatorAlias);
 
-impl View for SignedCertificateTimestampListCombinator {
-    type V = SpecSignedCertificateTimestampListCombinator;
-    open spec fn view(&self) -> Self::V { SpecSignedCertificateTimestampListCombinator(self.0@) }
+impl View for SeverHelloExtensionExtensionDataCombinator {
+    type V = SpecSeverHelloExtensionExtensionDataCombinator;
+    open spec fn view(&self) -> Self::V { SpecSeverHelloExtensionExtensionDataCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SignedCertificateTimestampListCombinator {
-    type Type = SignedCertificateTimestampList<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SeverHelloExtensionExtensionDataCombinator {
+    type Type = SeverHelloExtensionExtensionData<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SignedCertificateTimestampListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate16977634203518580913>, AndThen<bytes::Variable, Repeat<SerializedSctCombinator>>, SignedCertificateTimestampListCont0>, SignedCertificateTimestampListMapper>;
-
-
-pub open spec fn spec_signed_certificate_timestamp_list() -> SpecSignedCertificateTimestampListCombinator {
-    SpecSignedCertificateTimestampListCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate16977634203518580913 }, |deps| spec_signed_certificate_timestamp_list_cont0(deps)),
-        mapper: SignedCertificateTimestampListMapper,
-    })
-}
-
-pub open spec fn spec_signed_certificate_timestamp_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecSerializedSctCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_serialized_sct()))
 }
+pub type SeverHelloExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SeverHelloExtensionExtensionDataCombinator3, SeverHelloExtensionExtensionDataMapper>>;
 
-impl View for SignedCertificateTimestampListCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecSerializedSctCombinator>>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_signed_certificate_timestamp_list_cont0(deps)
-        }
-    }
+pub open spec fn spec_sever_hello_extension_extension_data(ext_len: u16, extension_type: u16) -> SpecSeverHelloExtensionExtensionDataCombinator {
+    SpecSeverHelloExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::spec_from(ext_len)) as usize), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_PreSharedKey, inner: spec_pre_shared_key_server_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SupportedVersions, inner: spec_supported_versions_server() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_KeyShare, inner: spec_key_share_entry() }, Cond { cond: !(extension_type == ExtensionType::SPEC_PreSharedKey || extension_type == ExtensionType::SPEC_SupportedVersions || extension_type == ExtensionType::SPEC_KeyShare), inner: bytes::Variable((usize::spec_from(ext_len)) as usize) }))), mapper: SeverHelloExtensionExtensionDataMapper }))
 }
 
-                
-pub fn signed_certificate_timestamp_list<'a>() -> (o: SignedCertificateTimestampListCombinator)
-    ensures o@ == spec_signed_certificate_timestamp_list(),
+pub fn sever_hello_extension_extension_data<'a>(ext_len: u16, extension_type: u16) -> (o: SeverHelloExtensionExtensionDataCombinator)
+    requires
+        spec_extension_type().wf(extension_type@),
+
+    ensures o@ == spec_sever_hello_extension_extension_data(ext_len@, extension_type@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = SignedCertificateTimestampListCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate16977634203518580913 }, SignedCertificateTimestampListCont0),
-        mapper: SignedCertificateTimestampListMapper,
-    });
-    assert({
-        &&& combinator@ == spec_signed_certificate_timestamp_list()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = SeverHelloExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::ex_from(ext_len)) as usize), Mapped { inner: SeverHelloExtensionExtensionDataCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::PreSharedKey, inner: pre_shared_key_server_extension() }, SeverHelloExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::SupportedVersions, inner: supported_versions_server() }, SeverHelloExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::KeyShare, inner: key_share_entry() }, Cond { cond: !(extension_type == ExtensionType::PreSharedKey || extension_type == ExtensionType::SupportedVersions || extension_type == ExtensionType::KeyShare), inner: bytes::Variable((usize::ex_from(ext_len)) as usize) })))))), mapper: SeverHelloExtensionExtensionDataMapper }));
+    // assert({
+    //     &&& combinator@ == spec_sever_hello_extension_extension_data(ext_len@, extension_type@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_signed_certificate_timestamp_list<'a>(input: &'a [u8]) -> (res: PResult<<SignedCertificateTimestampListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_sever_hello_extension_extension_data<'a>(input: &'a [u8], ext_len: u16, extension_type: u16) -> (res: PResult<<SeverHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_signed_certificate_timestamp_list().spec_parse(input@) == Some((n as int, v@)),
-        spec_signed_certificate_timestamp_list().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_sever_hello_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) == Some((n as int, v@)),
+        spec_sever_hello_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_signed_certificate_timestamp_list().spec_parse(input@) is None,
-        spec_signed_certificate_timestamp_list().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_sever_hello_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None,
+        spec_sever_hello_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = signed_certificate_timestamp_list();
+    let combinator = sever_hello_extension_extension_data( ext_len, extension_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_signed_certificate_timestamp_list<'a>(v: <SignedCertificateTimestampListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_sever_hello_extension_extension_data<'a>(v: <SeverHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16, extension_type: u16) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_signed_certificate_timestamp_list().wf(v@),
+        spec_sever_hello_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_extension_type().wf(extension_type@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_signed_certificate_timestamp_list().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_signed_certificate_timestamp_list().spec_serialize(v@))
+            &&& n == spec_sever_hello_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_sever_hello_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@))
         },
 {
-    let combinator = signed_certificate_timestamp_list();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = sever_hello_extension_extension_data( ext_len, extension_type );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn signed_certificate_timestamp_list_len<'a>(v: <SignedCertificateTimestampListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn sever_hello_extension_extension_data_len<'a>(v: <SeverHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16, extension_type: u16) -> (serialize_len: usize)
     requires
-        spec_signed_certificate_timestamp_list().wf(v@),
-        spec_signed_certificate_timestamp_list().spec_serialize(v@).len() <= usize::MAX,
+        spec_sever_hello_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_sever_hello_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        serialize_len == spec_signed_certificate_timestamp_list().spec_serialize(v@).len(),
+        serialize_len == spec_sever_hello_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len(),
 {
-    let combinator = signed_certificate_timestamp_list();
+    let combinator = sever_hello_extension_extension_data( ext_len, extension_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct SignedCertificateTimestampListCont0;
-type SignedCertificateTimestampListCont0Type<'a, 'b> = &'b u16;
-type SignedCertificateTimestampListCont0SType<'a, 'x> = &'x u16;
-type SignedCertificateTimestampListCont0Input<'a, 'b, 'x> = POrSType<SignedCertificateTimestampListCont0Type<'a, 'b>, SignedCertificateTimestampListCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<SignedCertificateTimestampListCont0Input<'a, 'b, 'x>> for SignedCertificateTimestampListCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<SerializedSctCombinator>>;
 
-    open spec fn requires(&self, deps: SignedCertificateTimestampListCont0Input<'a, 'b, 'x>) -> bool { true }
+pub struct SpecSeverHelloExtension {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: SpecSeverHelloExtensionExtensionData,
+}
+
+pub type SpecSeverHelloExtensionInner = ((u16, u16), SpecSeverHelloExtensionExtensionData);
 
-    open spec fn ensures(&self, deps: SignedCertificateTimestampListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_signed_certificate_timestamp_list_cont0(deps@)
-    }
 
-    fn apply(&self, deps: SignedCertificateTimestampListCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(serialized_sct()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(serialized_sct()))
-            }
-        }
+impl SpecFrom<SpecSeverHelloExtension> for SpecSeverHelloExtensionInner {
+    open spec fn spec_from(m: SpecSeverHelloExtension) -> SpecSeverHelloExtensionInner {
+        ((m.extension_type, m.ext_len), m.extension_data)
     }
 }
-                
 
-pub enum SpecCertificateExtensionExtensionData {
-    StatusRequest(SpecCertificateStatus),
-    SignedCertificateTimeStamp(SpecSignedCertificateTimestampList),
-    Unrecognized(Seq<u8>),
+impl SpecFrom<SpecSeverHelloExtensionInner> for SpecSeverHelloExtension {
+    open spec fn spec_from(m: SpecSeverHelloExtensionInner) -> SpecSeverHelloExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        SpecSeverHelloExtension { extension_type, ext_len, extension_data }
+    }
 }
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub type SpecCertificateExtensionExtensionDataInner = Either<SpecCertificateStatus, Either<SpecSignedCertificateTimestampList, Seq<u8>>>;
-
-impl SpecFrom<SpecCertificateExtensionExtensionData> for SpecCertificateExtensionExtensionDataInner {
-    open spec fn spec_from(m: SpecCertificateExtensionExtensionData) -> SpecCertificateExtensionExtensionDataInner {
-        match m {
-            SpecCertificateExtensionExtensionData::StatusRequest(m) => Either::Left(m),
-            SpecCertificateExtensionExtensionData::SignedCertificateTimeStamp(m) => Either::Right(Either::Left(m)),
-            SpecCertificateExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(m)),
-        }
-    }
-
-}
-
-                
-impl SpecFrom<SpecCertificateExtensionExtensionDataInner> for SpecCertificateExtensionExtensionData {
-    open spec fn spec_from(m: SpecCertificateExtensionExtensionDataInner) -> SpecCertificateExtensionExtensionData {
-        match m {
-            Either::Left(m) => SpecCertificateExtensionExtensionData::StatusRequest(m),
-            Either::Right(Either::Left(m)) => SpecCertificateExtensionExtensionData::SignedCertificateTimeStamp(m),
-            Either::Right(Either::Right(m)) => SpecCertificateExtensionExtensionData::Unrecognized(m),
-        }
-    }
-
-}
-
-
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum CertificateExtensionExtensionData<'a> {
-    StatusRequest(CertificateStatus<'a>),
-    SignedCertificateTimeStamp(SignedCertificateTimestampList<'a>),
-    Unrecognized(&'a [u8]),
+pub struct SeverHelloExtension<'a> {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: SeverHelloExtensionExtensionData<'a>,
 }
 
-pub type CertificateExtensionExtensionDataInner<'a> = Either<CertificateStatus<'a>, Either<SignedCertificateTimestampList<'a>, &'a [u8]>>;
-
-pub type CertificateExtensionExtensionDataInnerRef<'a> = Either<&'a CertificateStatus<'a>, Either<&'a SignedCertificateTimestampList<'a>, &'a &'a [u8]>>;
-
+impl View for SeverHelloExtension<'_> {
+    type V = SpecSeverHelloExtension;
 
-impl<'a> View for CertificateExtensionExtensionData<'a> {
-    type V = SpecCertificateExtensionExtensionData;
     open spec fn view(&self) -> Self::V {
-        match self {
-            CertificateExtensionExtensionData::StatusRequest(m) => SpecCertificateExtensionExtensionData::StatusRequest(m@),
-            CertificateExtensionExtensionData::SignedCertificateTimeStamp(m) => SpecCertificateExtensionExtensionData::SignedCertificateTimeStamp(m@),
-            CertificateExtensionExtensionData::Unrecognized(m) => SpecCertificateExtensionExtensionData::Unrecognized(m@),
+        SpecSeverHelloExtension {
+            extension_type: self.extension_type@,
+            ext_len: self.ext_len@,
+            extension_data: self.extension_data@,
         }
     }
 }
+pub type SeverHelloExtensionInner<'a> = ((u16, u16), SeverHelloExtensionExtensionData<'a>);
 
-
-impl<'a> From<&'a CertificateExtensionExtensionData<'a>> for CertificateExtensionExtensionDataInnerRef<'a> {
-    fn ex_from(m: &'a CertificateExtensionExtensionData<'a>) -> CertificateExtensionExtensionDataInnerRef<'a> {
-        match m {
-            CertificateExtensionExtensionData::StatusRequest(m) => Either::Left(m),
-            CertificateExtensionExtensionData::SignedCertificateTimeStamp(m) => Either::Right(Either::Left(m)),
-            CertificateExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(m)),
-        }
+pub type SeverHelloExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a SeverHelloExtensionExtensionData<'a>);
+impl<'a> From<&'a SeverHelloExtension<'a>> for SeverHelloExtensionInnerRef<'a> {
+    fn ex_from(m: &'a SeverHelloExtension) -> SeverHelloExtensionInnerRef<'a> {
+        ((&m.extension_type, &m.ext_len), &m.extension_data)
     }
-
 }
 
-impl<'a> From<CertificateExtensionExtensionDataInner<'a>> for CertificateExtensionExtensionData<'a> {
-    fn ex_from(m: CertificateExtensionExtensionDataInner<'a>) -> CertificateExtensionExtensionData<'a> {
-        match m {
-            Either::Left(m) => CertificateExtensionExtensionData::StatusRequest(m),
-            Either::Right(Either::Left(m)) => CertificateExtensionExtensionData::SignedCertificateTimeStamp(m),
-            Either::Right(Either::Right(m)) => CertificateExtensionExtensionData::Unrecognized(m),
-        }
+impl<'a> From<SeverHelloExtensionInner<'a>> for SeverHelloExtension<'a> {
+    fn ex_from(m: SeverHelloExtensionInner) -> SeverHelloExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        SeverHelloExtension { extension_type, ext_len, extension_data }
     }
-    
 }
 
-
-pub struct CertificateExtensionExtensionDataMapper;
-impl View for CertificateExtensionExtensionDataMapper {
+pub struct SeverHelloExtensionMapper;
+impl View for SeverHelloExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateExtensionExtensionDataMapper {
-    type Src = SpecCertificateExtensionExtensionDataInner;
-    type Dst = SpecCertificateExtensionExtensionData;
+impl SpecIso for SeverHelloExtensionMapper {
+    type Src = SpecSeverHelloExtensionInner;
+    type Dst = SpecSeverHelloExtension;
 }
-impl SpecIsoProof for CertificateExtensionExtensionDataMapper {
+impl SpecIsoProof for SeverHelloExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -7952,209 +7408,293 @@ impl SpecIsoProof for CertificateExtensionExtensionDataMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateExtensionExtensionDataMapper {
-    type Src = CertificateExtensionExtensionDataInner<'a>;
-    type Dst = CertificateExtensionExtensionData<'a>;
-    type RefSrc = CertificateExtensionExtensionDataInnerRef<'a>;
+impl<'a> Iso<'a> for SeverHelloExtensionMapper {
+    type Src = SeverHelloExtensionInner<'a>;
+    type Dst = SeverHelloExtension<'a>;
+    type RefSrc = SeverHelloExtensionInnerRef<'a>;
 }
 
-type SpecCertificateExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecSignedCertificateTimestampListCombinator>, Cond<bytes::Variable>>;
-type SpecCertificateExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecCertificateStatusCombinator>, SpecCertificateExtensionExtensionDataCombinatorAlias1>;
-pub struct SpecCertificateExtensionExtensionDataCombinator(pub SpecCertificateExtensionExtensionDataCombinatorAlias);
+pub struct SpecSeverHelloExtensionCombinator(pub SpecSeverHelloExtensionCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateExtensionExtensionDataCombinator {
-    type Type = SpecCertificateExtensionExtensionData;
+impl SpecCombinator for SpecSeverHelloExtensionCombinator {
+    type Type = SpecSeverHelloExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateExtensionExtensionDataCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSeverHelloExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSeverHelloExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecCertificateExtensionExtensionDataCombinatorAlias2, CertificateExtensionExtensionDataMapper>>;
-type CertificateExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SignedCertificateTimestampListCombinator>, Cond<bytes::Variable>>;
-type CertificateExtensionExtensionDataCombinatorAlias2 = Choice<Cond<CertificateStatusCombinator>, CertificateExtensionExtensionDataCombinator1>;
-pub struct CertificateExtensionExtensionDataCombinator1(pub CertificateExtensionExtensionDataCombinatorAlias1);
-impl View for CertificateExtensionExtensionDataCombinator1 {
-    type V = SpecCertificateExtensionExtensionDataCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateExtensionExtensionDataCombinator1, CertificateExtensionExtensionDataCombinatorAlias1);
-
-pub struct CertificateExtensionExtensionDataCombinator2(pub CertificateExtensionExtensionDataCombinatorAlias2);
-impl View for CertificateExtensionExtensionDataCombinator2 {
-    type V = SpecCertificateExtensionExtensionDataCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateExtensionExtensionDataCombinator2, CertificateExtensionExtensionDataCombinatorAlias2);
+pub type SpecSeverHelloExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecSeverHelloExtensionExtensionDataCombinator>, SeverHelloExtensionMapper>;
 
-pub struct CertificateExtensionExtensionDataCombinator(pub CertificateExtensionExtensionDataCombinatorAlias);
+pub struct SeverHelloExtensionCombinator(pub SeverHelloExtensionCombinatorAlias);
 
-impl View for CertificateExtensionExtensionDataCombinator {
-    type V = SpecCertificateExtensionExtensionDataCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateExtensionExtensionDataCombinator(self.0@) }
+impl View for SeverHelloExtensionCombinator {
+    type V = SpecSeverHelloExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecSeverHelloExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateExtensionExtensionDataCombinator {
-    type Type = CertificateExtensionExtensionData<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SeverHelloExtensionCombinator {
+    type Type = SeverHelloExtension<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<CertificateExtensionExtensionDataCombinator2, CertificateExtensionExtensionDataMapper>>;
+}
+pub type SeverHelloExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, SeverHelloExtensionCont1>, SeverHelloExtensionExtensionDataCombinator, SeverHelloExtensionCont0>, SeverHelloExtensionMapper>;
 
 
-pub open spec fn spec_certificate_extension_extension_data(ext_len: u16, extension_type: u16) -> SpecCertificateExtensionExtensionDataCombinator {
-    SpecCertificateExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.spec_into()), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_StatusRequest, inner: spec_certificate_status() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp, inner: spec_signed_certificate_timestamp_list() }, Cond { cond: !(extension_type == ExtensionType::SPEC_StatusRequest || extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp), inner: bytes::Variable(ext_len.spec_into()) })), mapper: CertificateExtensionExtensionDataMapper }))
+pub open spec fn spec_sever_hello_extension() -> SpecSeverHelloExtensionCombinator {
+    SpecSeverHelloExtensionCombinator(
+    Mapped {
+        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_sever_hello_extension_cont1(deps)), |deps| spec_sever_hello_extension_cont0(deps)),
+        mapper: SeverHelloExtensionMapper,
+    })
 }
 
-pub fn certificate_extension_extension_data<'a>(ext_len: u16, extension_type: u16) -> (o: CertificateExtensionExtensionDataCombinator)
-    ensures o@ == spec_certificate_extension_extension_data(ext_len@, extension_type@),
+pub open spec fn spec_sever_hello_extension_cont1(deps: u16) -> U16Be {
+    let extension_type = deps;
+    U16Be
+}
+
+impl View for SeverHelloExtensionCont1 {
+    type V = spec_fn(u16) -> U16Be;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_sever_hello_extension_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_sever_hello_extension_cont0(deps: (u16, u16)) -> SpecSeverHelloExtensionExtensionDataCombinator {
+    let (extension_type, ext_len) = deps;
+    spec_sever_hello_extension_extension_data(ext_len, extension_type)
+}
+
+impl View for SeverHelloExtensionCont0 {
+    type V = spec_fn((u16, u16)) -> SpecSeverHelloExtensionExtensionDataCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u16, u16)| {
+            spec_sever_hello_extension_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn sever_hello_extension<'a>() -> (o: SeverHelloExtensionCombinator)
+    ensures o@ == spec_sever_hello_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.ex_into()), Mapped { inner: CertificateExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::StatusRequest, inner: certificate_status() }, CertificateExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::SignedCertificateTimeStamp, inner: signed_certificate_timestamp_list() }, Cond { cond: !(extension_type == ExtensionType::StatusRequest || extension_type == ExtensionType::SignedCertificateTimeStamp), inner: bytes::Variable(ext_len.ex_into()) })))), mapper: CertificateExtensionExtensionDataMapper }));
-    assert({
-        &&& combinator@ == spec_certificate_extension_extension_data(ext_len@, extension_type@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = SeverHelloExtensionCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(extension_type(), SeverHelloExtensionCont1), SeverHelloExtensionCont0),
+        mapper: SeverHelloExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_sever_hello_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_extension_extension_data<'a>(input: &'a [u8], ext_len: u16, extension_type: u16) -> (res: PResult<<CertificateExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_sever_hello_extension<'a>(input: &'a [u8]) -> (res: PResult<<SeverHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_sever_hello_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_sever_hello_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None,
-        spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_sever_hello_extension().spec_parse(input@) is None,
+        spec_sever_hello_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_extension_extension_data( ext_len, extension_type );
+    let combinator = sever_hello_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_extension_extension_data<'a>(v: <CertificateExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16, extension_type: u16) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_sever_hello_extension<'a>(v: <SeverHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_sever_hello_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@))
+            &&& n == spec_sever_hello_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_sever_hello_extension().spec_serialize(v@))
         },
 {
-    let combinator = certificate_extension_extension_data( ext_len, extension_type );
-    combinator.serialize(v, data, pos)
+    let combinator = sever_hello_extension();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_extension_extension_data_len<'a>(v: <CertificateExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16, extension_type: u16) -> (serialize_len: usize)
+pub fn sever_hello_extension_len<'a>(v: <SeverHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_extension_extension_data(ext_len@, extension_type@).wf(v@),
-        spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_sever_hello_extension().wf(v@),
+        spec_sever_hello_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len(),
+        serialize_len == spec_sever_hello_extension().spec_serialize(v@).len(),
 {
-    let combinator = certificate_extension_extension_data( ext_len, extension_type );
+    let combinator = sever_hello_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct SeverHelloExtensionCont1;
+type SeverHelloExtensionCont1Type<'a, 'b> = &'b u16;
+type SeverHelloExtensionCont1SType<'a, 'x> = &'x u16;
+type SeverHelloExtensionCont1Input<'a, 'b, 'x> = POrSType<SeverHelloExtensionCont1Type<'a, 'b>, SeverHelloExtensionCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<SeverHelloExtensionCont1Input<'a, 'b, 'x>> for SeverHelloExtensionCont1 {
+    type Output = U16Be;
 
-pub struct SpecCertificateExtension {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: SpecCertificateExtensionExtensionData,
-}
-
-pub type SpecCertificateExtensionInner = ((u16, u16), SpecCertificateExtensionExtensionData);
-
+    open spec fn requires(&self, deps: SeverHelloExtensionCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_extension_type()).wf(deps@)
+        }
 
-impl SpecFrom<SpecCertificateExtension> for SpecCertificateExtensionInner {
-    open spec fn spec_from(m: SpecCertificateExtension) -> SpecCertificateExtensionInner {
-        ((m.extension_type, m.ext_len), m.extension_data)
+    open spec fn ensures(&self, deps: SeverHelloExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_sever_hello_extension_cont1(deps@)
     }
-}
 
-impl SpecFrom<SpecCertificateExtensionInner> for SpecCertificateExtension {
-    open spec fn spec_from(m: SpecCertificateExtensionInner) -> SpecCertificateExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        SpecCertificateExtension { extension_type, ext_len, extension_data }
+    fn apply(&self, deps: SeverHelloExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
+            }
+            POrSType::S(deps) => {
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
+            }
+        }
+    }
+}
+pub struct SeverHelloExtensionCont0;
+type SeverHelloExtensionCont0Type<'a, 'b> = &'b (u16, u16);
+type SeverHelloExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
+type SeverHelloExtensionCont0Input<'a, 'b, 'x> = POrSType<SeverHelloExtensionCont0Type<'a, 'b>, SeverHelloExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<SeverHelloExtensionCont0Input<'a, 'b, 'x>> for SeverHelloExtensionCont0 {
+    type Output = SeverHelloExtensionExtensionDataCombinator;
+
+    open spec fn requires(&self, deps: SeverHelloExtensionCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_extension_type(), |deps| spec_sever_hello_extension_cont1(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: SeverHelloExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_sever_hello_extension_cont0(deps@)
+    }
+
+    fn apply(&self, deps: SeverHelloExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                sever_hello_extension_extension_data(ext_len, extension_type)
+            }
+            POrSType::S(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                sever_hello_extension_extension_data(ext_len, extension_type)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecServerExtensions {
+    pub l: u16,
+    pub list: Seq<SpecSeverHelloExtension>,
+}
+
+pub type SpecServerExtensionsInner = (u16, Seq<SpecSeverHelloExtension>);
+
+
+impl SpecFrom<SpecServerExtensions> for SpecServerExtensionsInner {
+    open spec fn spec_from(m: SpecServerExtensions) -> SpecServerExtensionsInner {
+        (m.l, m.list)
+    }
+}
+
+impl SpecFrom<SpecServerExtensionsInner> for SpecServerExtensions {
+    open spec fn spec_from(m: SpecServerExtensionsInner) -> SpecServerExtensions {
+        let (l, list) = m;
+        SpecServerExtensions { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CertificateExtension<'a> {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: CertificateExtensionExtensionData<'a>,
+pub struct ServerExtensions<'a> {
+    pub l: u16,
+    pub list: RepeatResult<SeverHelloExtension<'a>>,
 }
 
-impl View for CertificateExtension<'_> {
-    type V = SpecCertificateExtension;
+impl View for ServerExtensions<'_> {
+    type V = SpecServerExtensions;
 
     open spec fn view(&self) -> Self::V {
-        SpecCertificateExtension {
-            extension_type: self.extension_type@,
-            ext_len: self.ext_len@,
-            extension_data: self.extension_data@,
+        SpecServerExtensions {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
-pub type CertificateExtensionInner<'a> = ((u16, u16), CertificateExtensionExtensionData<'a>);
+pub type ServerExtensionsInner<'a> = (u16, RepeatResult<SeverHelloExtension<'a>>);
 
-pub type CertificateExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a CertificateExtensionExtensionData<'a>);
-impl<'a> From<&'a CertificateExtension<'a>> for CertificateExtensionInnerRef<'a> {
-    fn ex_from(m: &'a CertificateExtension) -> CertificateExtensionInnerRef<'a> {
-        ((&m.extension_type, &m.ext_len), &m.extension_data)
+pub type ServerExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<SeverHelloExtension<'a>>);
+impl<'a> From<&'a ServerExtensions<'a>> for ServerExtensionsInnerRef<'a> {
+    fn ex_from(m: &'a ServerExtensions) -> ServerExtensionsInnerRef<'a> {
+        (&m.l, &m.list)
     }
 }
 
-impl<'a> From<CertificateExtensionInner<'a>> for CertificateExtension<'a> {
-    fn ex_from(m: CertificateExtensionInner) -> CertificateExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        CertificateExtension { extension_type, ext_len, extension_data }
+impl<'a> From<ServerExtensionsInner<'a>> for ServerExtensions<'a> {
+    fn ex_from(m: ServerExtensionsInner) -> ServerExtensions {
+        let (l, list) = m;
+        ServerExtensions { l, list }
     }
 }
 
-pub struct CertificateExtensionMapper;
-impl View for CertificateExtensionMapper {
+pub struct ServerExtensionsMapper;
+impl View for ServerExtensionsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateExtensionMapper {
-    type Src = SpecCertificateExtensionInner;
-    type Dst = SpecCertificateExtension;
+impl SpecIso for ServerExtensionsMapper {
+    type Src = SpecServerExtensionsInner;
+    type Dst = SpecServerExtensions;
 }
-impl SpecIsoProof for CertificateExtensionMapper {
+impl SpecIsoProof for ServerExtensionsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -8162,283 +7702,251 @@ impl SpecIsoProof for CertificateExtensionMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateExtensionMapper {
-    type Src = CertificateExtensionInner<'a>;
-    type Dst = CertificateExtension<'a>;
-    type RefSrc = CertificateExtensionInnerRef<'a>;
+impl<'a> Iso<'a> for ServerExtensionsMapper {
+    type Src = ServerExtensionsInner<'a>;
+    type Dst = ServerExtensions<'a>;
+    type RefSrc = ServerExtensionsInnerRef<'a>;
 }
 
-pub struct SpecCertificateExtensionCombinator(pub SpecCertificateExtensionCombinatorAlias);
+pub struct SpecServerExtensionsCombinator(pub SpecServerExtensionsCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateExtensionCombinator {
-    type Type = SpecCertificateExtension;
+impl SpecCombinator for SpecServerExtensionsCombinator {
+    type Type = SpecServerExtensions;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecServerExtensionsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecServerExtensionsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecCertificateExtensionExtensionDataCombinator>, CertificateExtensionMapper>;
+pub type SpecServerExtensionsCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate14496530480760116989>, AndThen<bytes::Variable, Repeat<SpecSeverHelloExtensionCombinator>>>, ServerExtensionsMapper>;
 
-pub struct CertificateExtensionCombinator(pub CertificateExtensionCombinatorAlias);
+pub struct ServerExtensionsCombinator(pub ServerExtensionsCombinatorAlias);
 
-impl View for CertificateExtensionCombinator {
-    type V = SpecCertificateExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateExtensionCombinator(self.0@) }
+impl View for ServerExtensionsCombinator {
+    type V = SpecServerExtensionsCombinator;
+    open spec fn view(&self) -> Self::V { SpecServerExtensionsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateExtensionCombinator {
-    type Type = CertificateExtension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerExtensionsCombinator {
+    type Type = ServerExtensions<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, CertificateExtensionCont1>, CertificateExtensionExtensionDataCombinator, CertificateExtensionCont0>, CertificateExtensionMapper>;
+}
+pub type ServerExtensionsCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate14496530480760116989>, AndThen<bytes::Variable, Repeat<SeverHelloExtensionCombinator>>, ServerExtensionsCont0>, ServerExtensionsMapper>;
 
 
-pub open spec fn spec_certificate_extension() -> SpecCertificateExtensionCombinator {
-    SpecCertificateExtensionCombinator(
+pub open spec fn spec_server_extensions() -> SpecServerExtensionsCombinator {
+    SpecServerExtensionsCombinator(
     Mapped {
-        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_certificate_extension_cont1(deps)), |deps| spec_certificate_extension_cont0(deps)),
-        mapper: CertificateExtensionMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate14496530480760116989 }, |deps| spec_server_extensions_cont0(deps)),
+        mapper: ServerExtensionsMapper,
     })
 }
 
-pub open spec fn spec_certificate_extension_cont1(deps: u16) -> U16Be {
-    let extension_type = deps;
-    U16Be
+pub open spec fn spec_server_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecSeverHelloExtensionCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_sever_hello_extension()))
 }
 
-impl View for CertificateExtensionCont1 {
-    type V = spec_fn(u16) -> U16Be;
+impl View for ServerExtensionsCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecSeverHelloExtensionCombinator>>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u16| {
-            spec_certificate_extension_cont1(deps)
-        }
-    }
-}
-
-pub open spec fn spec_certificate_extension_cont0(deps: (u16, u16)) -> SpecCertificateExtensionExtensionDataCombinator {
-    let (extension_type, ext_len) = deps;
-    spec_certificate_extension_extension_data(ext_len, extension_type)
-}
-
-impl View for CertificateExtensionCont0 {
-    type V = spec_fn((u16, u16)) -> SpecCertificateExtensionExtensionDataCombinator;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: (u16, u16)| {
-            spec_certificate_extension_cont0(deps)
+            spec_server_extensions_cont0(deps)
         }
     }
 }
 
                 
-pub fn certificate_extension<'a>() -> (o: CertificateExtensionCombinator)
-    ensures o@ == spec_certificate_extension(),
+pub fn server_extensions<'a>() -> (o: ServerExtensionsCombinator)
+    ensures o@ == spec_server_extensions(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateExtensionCombinator(
+    let combinator = ServerExtensionsCombinator(
     Mapped {
-        inner: Pair::new(Pair::new(extension_type(), CertificateExtensionCont1), CertificateExtensionCont0),
-        mapper: CertificateExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate14496530480760116989 }, ServerExtensionsCont0),
+        mapper: ServerExtensionsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_server_extensions()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_extension<'a>(input: &'a [u8]) -> (res: PResult<<CertificateExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_server_extensions<'a>(input: &'a [u8]) -> (res: PResult<<ServerExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_server_extensions().spec_parse(input@) == Some((n as int, v@)),
+        spec_server_extensions().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_extension().spec_parse(input@) is None,
-        spec_certificate_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_server_extensions().spec_parse(input@) is None,
+        spec_server_extensions().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_extension();
+    let combinator = server_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_extension<'a>(v: <CertificateExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_server_extensions<'a>(v: <ServerExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_extension().wf(v@),
+        spec_server_extensions().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_extension().spec_serialize(v@))
+            &&& n == spec_server_extensions().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_server_extensions().spec_serialize(v@))
         },
 {
-    let combinator = certificate_extension();
+    let combinator = server_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_extension_len<'a>(v: <CertificateExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn server_extensions_len<'a>(v: <ServerExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_extension().wf(v@),
-        spec_certificate_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_server_extensions().wf(v@),
+        spec_server_extensions().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_extension().spec_serialize(v@).len(),
+        serialize_len == spec_server_extensions().spec_serialize(v@).len(),
 {
-    let combinator = certificate_extension();
+    let combinator = server_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct CertificateExtensionCont1;
-type CertificateExtensionCont1Type<'a, 'b> = &'b u16;
-type CertificateExtensionCont1SType<'a, 'x> = &'x u16;
-type CertificateExtensionCont1Input<'a, 'b, 'x> = POrSType<CertificateExtensionCont1Type<'a, 'b>, CertificateExtensionCont1SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CertificateExtensionCont1Input<'a, 'b, 'x>> for CertificateExtensionCont1 {
-    type Output = U16Be;
+pub struct ServerExtensionsCont0;
+type ServerExtensionsCont0Type<'a, 'b> = &'b u16;
+type ServerExtensionsCont0SType<'a, 'x> = &'x u16;
+type ServerExtensionsCont0Input<'a, 'b, 'x> = POrSType<ServerExtensionsCont0Type<'a, 'b>, ServerExtensionsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ServerExtensionsCont0Input<'a, 'b, 'x>> for ServerExtensionsCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<SeverHelloExtensionCombinator>>;
 
-    open spec fn requires(&self, deps: CertificateExtensionCont1Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: ServerExtensionsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate14496530480760116989 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: CertificateExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_certificate_extension_cont1(deps@)
+    open spec fn ensures(&self, deps: ServerExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_server_extensions_cont0(deps@)
     }
 
-    fn apply(&self, deps: CertificateExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: ServerExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let extension_type = *deps;
-                U16Be
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(sever_hello_extension()))
             }
             POrSType::S(deps) => {
-                let extension_type = deps;
-                let extension_type = *extension_type;
-                U16Be
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(sever_hello_extension()))
             }
         }
     }
 }
-pub struct CertificateExtensionCont0;
-type CertificateExtensionCont0Type<'a, 'b> = &'b (u16, u16);
-type CertificateExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
-type CertificateExtensionCont0Input<'a, 'b, 'x> = POrSType<CertificateExtensionCont0Type<'a, 'b>, CertificateExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CertificateExtensionCont0Input<'a, 'b, 'x>> for CertificateExtensionCont0 {
-    type Output = CertificateExtensionExtensionDataCombinator;
+                
+
+pub struct SpecServerHello {
+    pub legacy_session_id_echo: SpecSessionId,
+    pub cipher_suite: u16,
+    pub legacy_compression_method: u8,
+    pub extensions: SpecServerExtensions,
+}
 
-    open spec fn requires(&self, deps: CertificateExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
+pub type SpecServerHelloInner = (SpecSessionId, (u16, (u8, SpecServerExtensions)));
 
-    open spec fn ensures(&self, deps: CertificateExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_certificate_extension_cont0(deps@)
+
+impl SpecFrom<SpecServerHello> for SpecServerHelloInner {
+    open spec fn spec_from(m: SpecServerHello) -> SpecServerHelloInner {
+        (m.legacy_session_id_echo, (m.cipher_suite, (m.legacy_compression_method, m.extensions)))
     }
+}
 
-    fn apply(&self, deps: CertificateExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let (extension_type, ext_len) = *deps;
-                certificate_extension_extension_data(ext_len, extension_type)
-            }
-            POrSType::S(deps) => {
-                let (extension_type, ext_len) = deps;
-                let (extension_type, ext_len) = (*extension_type, *ext_len);
-                certificate_extension_extension_data(ext_len, extension_type)
-            }
-        }
-    }
-}
-                
-
-pub struct SpecCertificateExtensions {
-    pub l: u16,
-    pub list: Seq<SpecCertificateExtension>,
-}
-
-pub type SpecCertificateExtensionsInner = (u16, Seq<SpecCertificateExtension>);
-
-
-impl SpecFrom<SpecCertificateExtensions> for SpecCertificateExtensionsInner {
-    open spec fn spec_from(m: SpecCertificateExtensions) -> SpecCertificateExtensionsInner {
-        (m.l, m.list)
-    }
-}
-
-impl SpecFrom<SpecCertificateExtensionsInner> for SpecCertificateExtensions {
-    open spec fn spec_from(m: SpecCertificateExtensionsInner) -> SpecCertificateExtensions {
-        let (l, list) = m;
-        SpecCertificateExtensions { l, list }
+impl SpecFrom<SpecServerHelloInner> for SpecServerHello {
+    open spec fn spec_from(m: SpecServerHelloInner) -> SpecServerHello {
+        let (legacy_session_id_echo, (cipher_suite, (legacy_compression_method, extensions))) = m;
+        SpecServerHello { legacy_session_id_echo, cipher_suite, legacy_compression_method, extensions }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CertificateExtensions<'a> {
-    pub l: u16,
-    pub list: RepeatResult<CertificateExtension<'a>>,
+pub struct ServerHello<'a> {
+    pub legacy_session_id_echo: SessionId<'a>,
+    pub cipher_suite: u16,
+    pub legacy_compression_method: u8,
+    pub extensions: ServerExtensions<'a>,
 }
 
-impl View for CertificateExtensions<'_> {
-    type V = SpecCertificateExtensions;
+impl View for ServerHello<'_> {
+    type V = SpecServerHello;
 
     open spec fn view(&self) -> Self::V {
-        SpecCertificateExtensions {
-            l: self.l@,
-            list: self.list@,
+        SpecServerHello {
+            legacy_session_id_echo: self.legacy_session_id_echo@,
+            cipher_suite: self.cipher_suite@,
+            legacy_compression_method: self.legacy_compression_method@,
+            extensions: self.extensions@,
         }
     }
 }
-pub type CertificateExtensionsInner<'a> = (u16, RepeatResult<CertificateExtension<'a>>);
+pub type ServerHelloInner<'a> = (SessionId<'a>, (u16, (u8, ServerExtensions<'a>)));
 
-pub type CertificateExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<CertificateExtension<'a>>);
-impl<'a> From<&'a CertificateExtensions<'a>> for CertificateExtensionsInnerRef<'a> {
-    fn ex_from(m: &'a CertificateExtensions) -> CertificateExtensionsInnerRef<'a> {
-        (&m.l, &m.list)
+pub type ServerHelloInnerRef<'a> = (&'a SessionId<'a>, (&'a u16, (&'a u8, &'a ServerExtensions<'a>)));
+impl<'a> From<&'a ServerHello<'a>> for ServerHelloInnerRef<'a> {
+    fn ex_from(m: &'a ServerHello) -> ServerHelloInnerRef<'a> {
+        (&m.legacy_session_id_echo, (&m.cipher_suite, (&m.legacy_compression_method, &m.extensions)))
     }
 }
 
-impl<'a> From<CertificateExtensionsInner<'a>> for CertificateExtensions<'a> {
-    fn ex_from(m: CertificateExtensionsInner) -> CertificateExtensions {
-        let (l, list) = m;
-        CertificateExtensions { l, list }
+impl<'a> From<ServerHelloInner<'a>> for ServerHello<'a> {
+    fn ex_from(m: ServerHelloInner) -> ServerHello {
+        let (legacy_session_id_echo, (cipher_suite, (legacy_compression_method, extensions))) = m;
+        ServerHello { legacy_session_id_echo, cipher_suite, legacy_compression_method, extensions }
     }
 }
 
-pub struct CertificateExtensionsMapper;
-impl View for CertificateExtensionsMapper {
+pub struct ServerHelloMapper;
+impl View for ServerHelloMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateExtensionsMapper {
-    type Src = SpecCertificateExtensionsInner;
-    type Dst = SpecCertificateExtensions;
+impl SpecIso for ServerHelloMapper {
+    type Src = SpecServerHelloInner;
+    type Dst = SpecServerHello;
 }
-impl SpecIsoProof for CertificateExtensionsMapper {
+impl SpecIsoProof for ServerHelloMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -8446,521 +7954,450 @@ impl SpecIsoProof for CertificateExtensionsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateExtensionsMapper {
-    type Src = CertificateExtensionsInner<'a>;
-    type Dst = CertificateExtensions<'a>;
-    type RefSrc = CertificateExtensionsInnerRef<'a>;
+impl<'a> Iso<'a> for ServerHelloMapper {
+    type Src = ServerHelloInner<'a>;
+    type Dst = ServerHello<'a>;
+    type RefSrc = ServerHelloInnerRef<'a>;
 }
+pub const SERVERHELLOLEGACY_COMPRESSION_METHOD_CONST: u8 = 0;
+type SpecServerHelloCombinatorAlias1 = (Refined<U8, TagPred<u8>>, SpecServerExtensionsCombinator);
+type SpecServerHelloCombinatorAlias2 = (SpecCipherSuiteCombinator, SpecServerHelloCombinatorAlias1);
+type SpecServerHelloCombinatorAlias3 = (SpecSessionIdCombinator, SpecServerHelloCombinatorAlias2);
+pub struct SpecServerHelloCombinator(pub SpecServerHelloCombinatorAlias);
 
-pub struct SpecCertificateExtensionsCombinator(pub SpecCertificateExtensionsCombinatorAlias);
-
-impl SpecCombinator for SpecCertificateExtensionsCombinator {
-    type Type = SpecCertificateExtensions;
+impl SpecCombinator for SpecServerHelloCombinator {
+    type Type = SpecServerHello;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateExtensionsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateExtensionsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecServerHelloCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecServerHelloCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateExtensionsCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecCertificateExtensionCombinator>>>, CertificateExtensionsMapper>;
+pub type SpecServerHelloCombinatorAlias = Mapped<SpecServerHelloCombinatorAlias3, ServerHelloMapper>;
+type ServerHelloCombinatorAlias1 = (Refined<U8, TagPred<u8>>, ServerExtensionsCombinator);
+type ServerHelloCombinatorAlias2 = (CipherSuiteCombinator, ServerHelloCombinator1);
+type ServerHelloCombinatorAlias3 = (SessionIdCombinator, ServerHelloCombinator2);
+pub struct ServerHelloCombinator1(pub ServerHelloCombinatorAlias1);
+impl View for ServerHelloCombinator1 {
+    type V = SpecServerHelloCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ServerHelloCombinator1, ServerHelloCombinatorAlias1);
 
-pub struct CertificateExtensionsCombinator(pub CertificateExtensionsCombinatorAlias);
+pub struct ServerHelloCombinator2(pub ServerHelloCombinatorAlias2);
+impl View for ServerHelloCombinator2 {
+    type V = SpecServerHelloCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ServerHelloCombinator2, ServerHelloCombinatorAlias2);
 
-impl View for CertificateExtensionsCombinator {
-    type V = SpecCertificateExtensionsCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateExtensionsCombinator(self.0@) }
+pub struct ServerHelloCombinator3(pub ServerHelloCombinatorAlias3);
+impl View for ServerHelloCombinator3 {
+    type V = SpecServerHelloCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateExtensionsCombinator {
-    type Type = CertificateExtensions<'a>;
+impl_wrapper_combinator!(ServerHelloCombinator3, ServerHelloCombinatorAlias3);
+
+pub struct ServerHelloCombinator(pub ServerHelloCombinatorAlias);
+
+impl View for ServerHelloCombinator {
+    type V = SpecServerHelloCombinator;
+    open spec fn view(&self) -> Self::V { SpecServerHelloCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerHelloCombinator {
+    type Type = ServerHello<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateExtensionsCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<CertificateExtensionCombinator>>, CertificateExtensionsCont0>, CertificateExtensionsMapper>;
+}
+pub type ServerHelloCombinatorAlias = Mapped<ServerHelloCombinator3, ServerHelloMapper>;
 
 
-pub open spec fn spec_certificate_extensions() -> SpecCertificateExtensionsCombinator {
-    SpecCertificateExtensionsCombinator(
+pub open spec fn spec_server_hello() -> SpecServerHelloCombinator {
+    SpecServerHelloCombinator(
     Mapped {
-        inner: Pair::spec_new(U16Be, |deps| spec_certificate_extensions_cont0(deps)),
-        mapper: CertificateExtensionsMapper,
+        inner: (spec_session_id(), (spec_cipher_suite(), (Refined { inner: U8, predicate: TagPred(SERVERHELLOLEGACY_COMPRESSION_METHOD_CONST) }, spec_server_extensions()))),
+        mapper: ServerHelloMapper,
     })
 }
 
-pub open spec fn spec_certificate_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecCertificateExtensionCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_certificate_extension()))
-}
-
-impl View for CertificateExtensionsCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecCertificateExtensionCombinator>>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_certificate_extensions_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn certificate_extensions<'a>() -> (o: CertificateExtensionsCombinator)
-    ensures o@ == spec_certificate_extensions(),
+pub fn server_hello<'a>() -> (o: ServerHelloCombinator)
+    ensures o@ == spec_server_hello(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateExtensionsCombinator(
+    let combinator = ServerHelloCombinator(
     Mapped {
-        inner: Pair::new(U16Be, CertificateExtensionsCont0),
-        mapper: CertificateExtensionsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_extensions()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: ServerHelloCombinator3((session_id(), ServerHelloCombinator2((cipher_suite(), ServerHelloCombinator1((Refined { inner: U8, predicate: TagPred(SERVERHELLOLEGACY_COMPRESSION_METHOD_CONST) }, server_extensions())))))),
+        mapper: ServerHelloMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_server_hello()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_extensions<'a>(input: &'a [u8]) -> (res: PResult<<CertificateExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_server_hello<'a>(input: &'a [u8]) -> (res: PResult<<ServerHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_extensions().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_extensions().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_server_hello().spec_parse(input@) == Some((n as int, v@)),
+        spec_server_hello().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_extensions().spec_parse(input@) is None,
-        spec_certificate_extensions().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_server_hello().spec_parse(input@) is None,
+        spec_server_hello().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_extensions();
+    let combinator = server_hello();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_extensions<'a>(v: <CertificateExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_server_hello<'a>(v: <ServerHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_extensions().wf(v@),
+        spec_server_hello().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_extensions().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_extensions().spec_serialize(v@))
+            &&& n == spec_server_hello().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_server_hello().spec_serialize(v@))
         },
 {
-    let combinator = certificate_extensions();
+    let combinator = server_hello();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_extensions_len<'a>(v: <CertificateExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn server_hello_len<'a>(v: <ServerHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_extensions().wf(v@),
-        spec_certificate_extensions().spec_serialize(v@).len() <= usize::MAX,
+        spec_server_hello().wf(v@),
+        spec_server_hello().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_extensions().spec_serialize(v@).len(),
+        serialize_len == spec_server_hello().spec_serialize(v@).len(),
 {
-    let combinator = certificate_extensions();
+    let combinator = server_hello();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct CertificateExtensionsCont0;
-type CertificateExtensionsCont0Type<'a, 'b> = &'b u16;
-type CertificateExtensionsCont0SType<'a, 'x> = &'x u16;
-type CertificateExtensionsCont0Input<'a, 'b, 'x> = POrSType<CertificateExtensionsCont0Type<'a, 'b>, CertificateExtensionsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CertificateExtensionsCont0Input<'a, 'b, 'x>> for CertificateExtensionsCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<CertificateExtensionCombinator>>;
+                
 
-    open spec fn requires(&self, deps: CertificateExtensionsCont0Input<'a, 'b, 'x>) -> bool { true }
+pub enum SpecShOrHrrPayload {
+    Variant0(SpecHelloRetryRequest),
+    Variant1(SpecServerHello),
+}
 
-    open spec fn ensures(&self, deps: CertificateExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_certificate_extensions_cont0(deps@)
-    }
+pub type SpecShOrHrrPayloadInner = Either<SpecHelloRetryRequest, SpecServerHello>;
 
-    fn apply(&self, deps: CertificateExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(certificate_extension()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(certificate_extension()))
-            }
+impl SpecFrom<SpecShOrHrrPayload> for SpecShOrHrrPayloadInner {
+    open spec fn spec_from(m: SpecShOrHrrPayload) -> SpecShOrHrrPayloadInner {
+        match m {
+            SpecShOrHrrPayload::Variant0(m) => Either::Left(m),
+            SpecShOrHrrPayload::Variant1(m) => Either::Right(m),
         }
     }
-}
-                
-pub mod CipherSuite {
-    use super::*;
-    pub spec const SPEC_TLS_AES_128_GCM_SHA256: u16 = 4865;
-    pub spec const SPEC_TLS_AES_256_GCM_SHA384: u16 = 4866;
-    pub spec const SPEC_TLS_CHACHA20_POLY1305_SHA256: u16 = 4867;
-    pub spec const SPEC_TLS_AES_128_CCM_SHA256: u16 = 4868;
-    pub spec const SPEC_TLS_AES_128_CCM_8_SHA256: u16 = 4869;
-    pub exec const TLS_AES_128_GCM_SHA256: u16 ensures TLS_AES_128_GCM_SHA256 == SPEC_TLS_AES_128_GCM_SHA256 { 4865 }
-    pub exec const TLS_AES_256_GCM_SHA384: u16 ensures TLS_AES_256_GCM_SHA384 == SPEC_TLS_AES_256_GCM_SHA384 { 4866 }
-    pub exec const TLS_CHACHA20_POLY1305_SHA256: u16 ensures TLS_CHACHA20_POLY1305_SHA256 == SPEC_TLS_CHACHA20_POLY1305_SHA256 { 4867 }
-    pub exec const TLS_AES_128_CCM_SHA256: u16 ensures TLS_AES_128_CCM_SHA256 == SPEC_TLS_AES_128_CCM_SHA256 { 4868 }
-    pub exec const TLS_AES_128_CCM_8_SHA256: u16 ensures TLS_AES_128_CCM_8_SHA256 == SPEC_TLS_AES_128_CCM_8_SHA256 { 4869 }
-}
-
 
-pub struct SpecCipherSuiteCombinator(pub SpecCipherSuiteCombinatorAlias);
+}
+
+                
+impl SpecFrom<SpecShOrHrrPayloadInner> for SpecShOrHrrPayload {
+    open spec fn spec_from(m: SpecShOrHrrPayloadInner) -> SpecShOrHrrPayload {
+        match m {
+            Either::Left(m) => SpecShOrHrrPayload::Variant0(m),
+            Either::Right(m) => SpecShOrHrrPayload::Variant1(m),
+        }
+    }
 
-impl SpecCombinator for SpecCipherSuiteCombinator {
-    type Type = u16;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecCipherSuiteCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCipherSuiteCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCipherSuiteCombinatorAlias = U16Be;
 
-pub struct CipherSuiteCombinator(pub CipherSuiteCombinatorAlias);
 
-impl View for CipherSuiteCombinator {
-    type V = SpecCipherSuiteCombinator;
-    open spec fn view(&self) -> Self::V { SpecCipherSuiteCombinator(self.0@) }
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ShOrHrrPayload<'a> {
+    Variant0(HelloRetryRequest<'a>),
+    Variant1(ServerHello<'a>),
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CipherSuiteCombinator {
-    type Type = u16;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CipherSuiteCombinatorAlias = U16Be;
 
+pub type ShOrHrrPayloadInner<'a> = Either<HelloRetryRequest<'a>, ServerHello<'a>>;
 
-pub open spec fn spec_cipher_suite() -> SpecCipherSuiteCombinator {
-    SpecCipherSuiteCombinator(U16Be)
-}
+pub type ShOrHrrPayloadInnerRef<'a> = Either<&'a HelloRetryRequest<'a>, &'a ServerHello<'a>>;
 
-                
-pub fn cipher_suite<'a>() -> (o: CipherSuiteCombinator)
-    ensures o@ == spec_cipher_suite(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = CipherSuiteCombinator(U16Be);
-    assert({
-        &&& combinator@ == spec_cipher_suite()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
 
-pub fn parse_cipher_suite<'a>(input: &'a [u8]) -> (res: PResult<<CipherSuiteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_cipher_suite().spec_parse(input@) == Some((n as int, v@)),
-        spec_cipher_suite().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_cipher_suite().spec_parse(input@) is None,
-        spec_cipher_suite().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = cipher_suite();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+impl<'a> View for ShOrHrrPayload<'a> {
+    type V = SpecShOrHrrPayload;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            ShOrHrrPayload::Variant0(m) => SpecShOrHrrPayload::Variant0(m@),
+            ShOrHrrPayload::Variant1(m) => SpecShOrHrrPayload::Variant1(m@),
+        }
+    }
 }
 
-pub fn serialize_cipher_suite<'a>(v: <CipherSuiteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_cipher_suite().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_cipher_suite().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_cipher_suite().spec_serialize(v@))
-        },
-{
-    let combinator = cipher_suite();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+
+impl<'a> From<&'a ShOrHrrPayload<'a>> for ShOrHrrPayloadInnerRef<'a> {
+    fn ex_from(m: &'a ShOrHrrPayload<'a>) -> ShOrHrrPayloadInnerRef<'a> {
+        match m {
+            ShOrHrrPayload::Variant0(m) => Either::Left(m),
+            ShOrHrrPayload::Variant1(m) => Either::Right(m),
+        }
+    }
+
 }
 
-pub fn cipher_suite_len<'a>(v: <CipherSuiteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_cipher_suite().wf(v@),
-        spec_cipher_suite().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_cipher_suite().spec_serialize(v@).len(),
-{
-    let combinator = cipher_suite();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+impl<'a> From<ShOrHrrPayloadInner<'a>> for ShOrHrrPayload<'a> {
+    fn ex_from(m: ShOrHrrPayloadInner<'a>) -> ShOrHrrPayload<'a> {
+        match m {
+            Either::Left(m) => ShOrHrrPayload::Variant0(m),
+            Either::Right(m) => ShOrHrrPayload::Variant1(m),
+        }
+    }
+    
 }
 
-                
-pub type SpecCookie = SpecOpaque1Ffff;
-pub type Cookie<'a> = Opaque1Ffff<'a>;
-pub type CookieRef<'a> = &'a Opaque1Ffff<'a>;
 
+pub struct ShOrHrrPayloadMapper;
+impl View for ShOrHrrPayloadMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ShOrHrrPayloadMapper {
+    type Src = SpecShOrHrrPayloadInner;
+    type Dst = SpecShOrHrrPayload;
+}
+impl SpecIsoProof for ShOrHrrPayloadMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ShOrHrrPayloadMapper {
+    type Src = ShOrHrrPayloadInner<'a>;
+    type Dst = ShOrHrrPayload<'a>;
+    type RefSrc = ShOrHrrPayloadInnerRef<'a>;
+}
 
-pub struct SpecCookieCombinator(pub SpecCookieCombinatorAlias);
+type SpecShOrHrrPayloadCombinatorAlias1 = Choice<Cond<SpecHelloRetryRequestCombinator>, Cond<SpecServerHelloCombinator>>;
+pub struct SpecShOrHrrPayloadCombinator(pub SpecShOrHrrPayloadCombinatorAlias);
 
-impl SpecCombinator for SpecCookieCombinator {
-    type Type = SpecCookie;
+impl SpecCombinator for SpecShOrHrrPayloadCombinator {
+    type Type = SpecShOrHrrPayload;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCookieCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCookieCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecShOrHrrPayloadCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecShOrHrrPayloadCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCookieCombinatorAlias = SpecOpaque1FfffCombinator;
+pub type SpecShOrHrrPayloadCombinatorAlias = Mapped<SpecShOrHrrPayloadCombinatorAlias1, ShOrHrrPayloadMapper>;
+type ShOrHrrPayloadCombinatorAlias1 = Choice<Cond<HelloRetryRequestCombinator>, Cond<ServerHelloCombinator>>;
+pub struct ShOrHrrPayloadCombinator1(pub ShOrHrrPayloadCombinatorAlias1);
+impl View for ShOrHrrPayloadCombinator1 {
+    type V = SpecShOrHrrPayloadCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ShOrHrrPayloadCombinator1, ShOrHrrPayloadCombinatorAlias1);
 
-pub struct CookieCombinator(pub CookieCombinatorAlias);
+pub struct ShOrHrrPayloadCombinator(pub ShOrHrrPayloadCombinatorAlias);
 
-impl View for CookieCombinator {
-    type V = SpecCookieCombinator;
-    open spec fn view(&self) -> Self::V { SpecCookieCombinator(self.0@) }
+impl View for ShOrHrrPayloadCombinator {
+    type V = SpecShOrHrrPayloadCombinator;
+    open spec fn view(&self) -> Self::V { SpecShOrHrrPayloadCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CookieCombinator {
-    type Type = Cookie<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ShOrHrrPayloadCombinator {
+    type Type = ShOrHrrPayload<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CookieCombinatorAlias = Opaque1FfffCombinator;
+}
+pub type ShOrHrrPayloadCombinatorAlias = Mapped<ShOrHrrPayloadCombinator1, ShOrHrrPayloadMapper>;
 
 
-pub open spec fn spec_cookie() -> SpecCookieCombinator {
-    SpecCookieCombinator(spec_opaque_1_ffff())
+pub open spec fn spec_sh_or_hrr_payload(random: Seq<u8>) -> SpecShOrHrrPayloadCombinator {
+    SpecShOrHrrPayloadCombinator(Mapped { inner: Choice(Cond { cond: random == seq![207u8, 33u8, 173u8, 116u8, 229u8, 154u8, 97u8, 17u8, 190u8, 29u8, 140u8, 2u8, 30u8, 101u8, 184u8, 145u8, 194u8, 162u8, 17u8, 22u8, 122u8, 187u8, 140u8, 94u8, 7u8, 158u8, 9u8, 226u8, 200u8, 168u8, 51u8, 156u8], inner: spec_hello_retry_request() }, Cond { cond: !(random == seq![207u8, 33u8, 173u8, 116u8, 229u8, 154u8, 97u8, 17u8, 190u8, 29u8, 140u8, 2u8, 30u8, 101u8, 184u8, 145u8, 194u8, 162u8, 17u8, 22u8, 122u8, 187u8, 140u8, 94u8, 7u8, 158u8, 9u8, 226u8, 200u8, 168u8, 51u8, 156u8]), inner: spec_server_hello() }), mapper: ShOrHrrPayloadMapper })
 }
 
-                
-pub fn cookie<'a>() -> (o: CookieCombinator)
-    ensures o@ == spec_cookie(),
+pub fn sh_or_hrr_payload<'a>(random: &'a [u8]) -> (o: ShOrHrrPayloadCombinator)
+
+    ensures o@ == spec_sh_or_hrr_payload(random@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CookieCombinator(opaque_1_ffff());
-    assert({
-        &&& combinator@ == spec_cookie()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ShOrHrrPayloadCombinator(Mapped { inner: ShOrHrrPayloadCombinator1(Choice::new(Cond { cond: compare_slice(random, [207u8, 33u8, 173u8, 116u8, 229u8, 154u8, 97u8, 17u8, 190u8, 29u8, 140u8, 2u8, 30u8, 101u8, 184u8, 145u8, 194u8, 162u8, 17u8, 22u8, 122u8, 187u8, 140u8, 94u8, 7u8, 158u8, 9u8, 226u8, 200u8, 168u8, 51u8, 156u8].as_slice()), inner: hello_retry_request() }, Cond { cond: !(compare_slice(random, [207u8, 33u8, 173u8, 116u8, 229u8, 154u8, 97u8, 17u8, 190u8, 29u8, 140u8, 2u8, 30u8, 101u8, 184u8, 145u8, 194u8, 162u8, 17u8, 22u8, 122u8, 187u8, 140u8, 94u8, 7u8, 158u8, 9u8, 226u8, 200u8, 168u8, 51u8, 156u8].as_slice())), inner: server_hello() })), mapper: ShOrHrrPayloadMapper });
+    // assert({
+    //     &&& combinator@ == spec_sh_or_hrr_payload(random@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_cookie<'a>(input: &'a [u8]) -> (res: PResult<<CookieCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_sh_or_hrr_payload<'a>(input: &'a [u8], random: &'a [u8]) -> (res: PResult<<ShOrHrrPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
-        res matches Ok((n, v)) ==> spec_cookie().spec_parse(input@) == Some((n as int, v@)),
-        spec_cookie().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_sh_or_hrr_payload(random@).spec_parse(input@) == Some((n as int, v@)),
+        spec_sh_or_hrr_payload(random@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_cookie().spec_parse(input@) is None,
-        spec_cookie().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_sh_or_hrr_payload(random@).spec_parse(input@) is None,
+        spec_sh_or_hrr_payload(random@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = cookie();
+    let combinator = sh_or_hrr_payload( random );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_cookie<'a>(v: <CookieCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_sh_or_hrr_payload<'a>(v: <ShOrHrrPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, random: &'a [u8]) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_cookie().wf(v@),
+        spec_sh_or_hrr_payload(random@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_cookie().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_cookie().spec_serialize(v@))
+            &&& n == spec_sh_or_hrr_payload(random@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_sh_or_hrr_payload(random@).spec_serialize(v@))
         },
 {
-    let combinator = cookie();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = sh_or_hrr_payload( random );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn cookie_len<'a>(v: <CookieCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn sh_or_hrr_payload_len<'a>(v: <ShOrHrrPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, random: &'a [u8]) -> (serialize_len: usize)
     requires
-        spec_cookie().wf(v@),
-        spec_cookie().spec_serialize(v@).len() <= usize::MAX,
+        spec_sh_or_hrr_payload(random@).wf(v@),
+        spec_sh_or_hrr_payload(random@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
-        serialize_len == spec_cookie().spec_serialize(v@).len(),
+        serialize_len == spec_sh_or_hrr_payload(random@).spec_serialize(v@).len(),
 {
-    let combinator = cookie();
+    let combinator = sh_or_hrr_payload( random );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
 
-pub enum SpecHelloRetryExtensionExtensionData {
-    SupportedVersions(u16),
-    Cookie(SpecCookie),
-    KeyShare(u16),
-    Unrecognized(Seq<u8>),
+pub struct SpecShOrHrr {
+    pub legacy_version: u16,
+    pub random: Seq<u8>,
+    pub payload: SpecShOrHrrPayload,
 }
 
-pub type SpecHelloRetryExtensionExtensionDataInner = Either<u16, Either<SpecCookie, Either<u16, Seq<u8>>>>;
+pub type SpecShOrHrrInner = ((u16, Seq<u8>), SpecShOrHrrPayload);
 
-impl SpecFrom<SpecHelloRetryExtensionExtensionData> for SpecHelloRetryExtensionExtensionDataInner {
-    open spec fn spec_from(m: SpecHelloRetryExtensionExtensionData) -> SpecHelloRetryExtensionExtensionDataInner {
-        match m {
-            SpecHelloRetryExtensionExtensionData::SupportedVersions(m) => Either::Left(m),
-            SpecHelloRetryExtensionExtensionData::Cookie(m) => Either::Right(Either::Left(m)),
-            SpecHelloRetryExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecHelloRetryExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(m))),
-        }
-    }
 
+impl SpecFrom<SpecShOrHrr> for SpecShOrHrrInner {
+    open spec fn spec_from(m: SpecShOrHrr) -> SpecShOrHrrInner {
+        ((m.legacy_version, m.random), m.payload)
+    }
 }
 
-                
-impl SpecFrom<SpecHelloRetryExtensionExtensionDataInner> for SpecHelloRetryExtensionExtensionData {
-    open spec fn spec_from(m: SpecHelloRetryExtensionExtensionDataInner) -> SpecHelloRetryExtensionExtensionData {
-        match m {
-            Either::Left(m) => SpecHelloRetryExtensionExtensionData::SupportedVersions(m),
-            Either::Right(Either::Left(m)) => SpecHelloRetryExtensionExtensionData::Cookie(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecHelloRetryExtensionExtensionData::KeyShare(m),
-            Either::Right(Either::Right(Either::Right(m))) => SpecHelloRetryExtensionExtensionData::Unrecognized(m),
-        }
+impl SpecFrom<SpecShOrHrrInner> for SpecShOrHrr {
+    open spec fn spec_from(m: SpecShOrHrrInner) -> SpecShOrHrr {
+        let ((legacy_version, random), payload) = m;
+        SpecShOrHrr { legacy_version, random, payload }
     }
-
 }
-
-
-
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum HelloRetryExtensionExtensionData<'a> {
-    SupportedVersions(u16),
-    Cookie(Cookie<'a>),
-    KeyShare(u16),
-    Unrecognized(&'a [u8]),
-}
 
-pub type HelloRetryExtensionExtensionDataInner<'a> = Either<u16, Either<Cookie<'a>, Either<u16, &'a [u8]>>>;
-
-pub type HelloRetryExtensionExtensionDataInnerRef<'a> = Either<&'a u16, Either<&'a Cookie<'a>, Either<&'a u16, &'a &'a [u8]>>>;
+pub struct ShOrHrr<'a> {
+    pub legacy_version: u16,
+    pub random: &'a [u8],
+    pub payload: ShOrHrrPayload<'a>,
+}
 
+impl View for ShOrHrr<'_> {
+    type V = SpecShOrHrr;
 
-impl<'a> View for HelloRetryExtensionExtensionData<'a> {
-    type V = SpecHelloRetryExtensionExtensionData;
     open spec fn view(&self) -> Self::V {
-        match self {
-            HelloRetryExtensionExtensionData::SupportedVersions(m) => SpecHelloRetryExtensionExtensionData::SupportedVersions(m@),
-            HelloRetryExtensionExtensionData::Cookie(m) => SpecHelloRetryExtensionExtensionData::Cookie(m@),
-            HelloRetryExtensionExtensionData::KeyShare(m) => SpecHelloRetryExtensionExtensionData::KeyShare(m@),
-            HelloRetryExtensionExtensionData::Unrecognized(m) => SpecHelloRetryExtensionExtensionData::Unrecognized(m@),
+        SpecShOrHrr {
+            legacy_version: self.legacy_version@,
+            random: self.random@,
+            payload: self.payload@,
         }
     }
 }
+pub type ShOrHrrInner<'a> = ((u16, &'a [u8]), ShOrHrrPayload<'a>);
 
-
-impl<'a> From<&'a HelloRetryExtensionExtensionData<'a>> for HelloRetryExtensionExtensionDataInnerRef<'a> {
-    fn ex_from(m: &'a HelloRetryExtensionExtensionData<'a>) -> HelloRetryExtensionExtensionDataInnerRef<'a> {
-        match m {
-            HelloRetryExtensionExtensionData::SupportedVersions(m) => Either::Left(m),
-            HelloRetryExtensionExtensionData::Cookie(m) => Either::Right(Either::Left(m)),
-            HelloRetryExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Left(m))),
-            HelloRetryExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(m))),
-        }
+pub type ShOrHrrInnerRef<'a> = ((&'a u16, &'a &'a [u8]), &'a ShOrHrrPayload<'a>);
+impl<'a> From<&'a ShOrHrr<'a>> for ShOrHrrInnerRef<'a> {
+    fn ex_from(m: &'a ShOrHrr) -> ShOrHrrInnerRef<'a> {
+        ((&m.legacy_version, &m.random), &m.payload)
     }
-
 }
 
-impl<'a> From<HelloRetryExtensionExtensionDataInner<'a>> for HelloRetryExtensionExtensionData<'a> {
-    fn ex_from(m: HelloRetryExtensionExtensionDataInner<'a>) -> HelloRetryExtensionExtensionData<'a> {
-        match m {
-            Either::Left(m) => HelloRetryExtensionExtensionData::SupportedVersions(m),
-            Either::Right(Either::Left(m)) => HelloRetryExtensionExtensionData::Cookie(m),
-            Either::Right(Either::Right(Either::Left(m))) => HelloRetryExtensionExtensionData::KeyShare(m),
-            Either::Right(Either::Right(Either::Right(m))) => HelloRetryExtensionExtensionData::Unrecognized(m),
-        }
+impl<'a> From<ShOrHrrInner<'a>> for ShOrHrr<'a> {
+    fn ex_from(m: ShOrHrrInner) -> ShOrHrr {
+        let ((legacy_version, random), payload) = m;
+        ShOrHrr { legacy_version, random, payload }
     }
-    
 }
 
-
-pub struct HelloRetryExtensionExtensionDataMapper;
-impl View for HelloRetryExtensionExtensionDataMapper {
+pub struct ShOrHrrMapper;
+impl View for ShOrHrrMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for HelloRetryExtensionExtensionDataMapper {
-    type Src = SpecHelloRetryExtensionExtensionDataInner;
-    type Dst = SpecHelloRetryExtensionExtensionData;
+impl SpecIso for ShOrHrrMapper {
+    type Src = SpecShOrHrrInner;
+    type Dst = SpecShOrHrr;
 }
-impl SpecIsoProof for HelloRetryExtensionExtensionDataMapper {
+impl SpecIsoProof for ShOrHrrMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -8968,502 +8405,526 @@ impl SpecIsoProof for HelloRetryExtensionExtensionDataMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for HelloRetryExtensionExtensionDataMapper {
-    type Src = HelloRetryExtensionExtensionDataInner<'a>;
-    type Dst = HelloRetryExtensionExtensionData<'a>;
-    type RefSrc = HelloRetryExtensionExtensionDataInnerRef<'a>;
+impl<'a> Iso<'a> for ShOrHrrMapper {
+    type Src = ShOrHrrInner<'a>;
+    type Dst = ShOrHrr<'a>;
+    type RefSrc = ShOrHrrInnerRef<'a>;
 }
+pub const SHORHRRLEGACY_VERSION_CONST: u16 = 771;
 
-type SpecHelloRetryExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecNamedGroupCombinator>, Cond<bytes::Variable>>;
-type SpecHelloRetryExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecCookieCombinator>, SpecHelloRetryExtensionExtensionDataCombinatorAlias1>;
-type SpecHelloRetryExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SpecSupportedVersionsServerCombinator>, SpecHelloRetryExtensionExtensionDataCombinatorAlias2>;
-pub struct SpecHelloRetryExtensionExtensionDataCombinator(pub SpecHelloRetryExtensionExtensionDataCombinatorAlias);
+pub struct SpecShOrHrrCombinator(pub SpecShOrHrrCombinatorAlias);
 
-impl SpecCombinator for SpecHelloRetryExtensionExtensionDataCombinator {
-    type Type = SpecHelloRetryExtensionExtensionData;
+impl SpecCombinator for SpecShOrHrrCombinator {
+    type Type = SpecShOrHrr;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecHelloRetryExtensionExtensionDataCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecHelloRetryExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecShOrHrrCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecShOrHrrCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecHelloRetryExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecHelloRetryExtensionExtensionDataCombinatorAlias3, HelloRetryExtensionExtensionDataMapper>>;
-type HelloRetryExtensionExtensionDataCombinatorAlias1 = Choice<Cond<NamedGroupCombinator>, Cond<bytes::Variable>>;
-type HelloRetryExtensionExtensionDataCombinatorAlias2 = Choice<Cond<CookieCombinator>, HelloRetryExtensionExtensionDataCombinator1>;
-type HelloRetryExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SupportedVersionsServerCombinator>, HelloRetryExtensionExtensionDataCombinator2>;
-pub struct HelloRetryExtensionExtensionDataCombinator1(pub HelloRetryExtensionExtensionDataCombinatorAlias1);
-impl View for HelloRetryExtensionExtensionDataCombinator1 {
-    type V = SpecHelloRetryExtensionExtensionDataCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HelloRetryExtensionExtensionDataCombinator1, HelloRetryExtensionExtensionDataCombinatorAlias1);
-
-pub struct HelloRetryExtensionExtensionDataCombinator2(pub HelloRetryExtensionExtensionDataCombinatorAlias2);
-impl View for HelloRetryExtensionExtensionDataCombinator2 {
-    type V = SpecHelloRetryExtensionExtensionDataCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HelloRetryExtensionExtensionDataCombinator2, HelloRetryExtensionExtensionDataCombinatorAlias2);
-
-pub struct HelloRetryExtensionExtensionDataCombinator3(pub HelloRetryExtensionExtensionDataCombinatorAlias3);
-impl View for HelloRetryExtensionExtensionDataCombinator3 {
-    type V = SpecHelloRetryExtensionExtensionDataCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HelloRetryExtensionExtensionDataCombinator3, HelloRetryExtensionExtensionDataCombinatorAlias3);
+pub type SpecShOrHrrCombinatorAlias = Mapped<SpecPair<(Refined<U16Be, TagPred<u16>>, bytes::Fixed<32>), SpecShOrHrrPayloadCombinator>, ShOrHrrMapper>;
 
-pub struct HelloRetryExtensionExtensionDataCombinator(pub HelloRetryExtensionExtensionDataCombinatorAlias);
+pub struct ShOrHrrCombinator(pub ShOrHrrCombinatorAlias);
 
-impl View for HelloRetryExtensionExtensionDataCombinator {
-    type V = SpecHelloRetryExtensionExtensionDataCombinator;
-    open spec fn view(&self) -> Self::V { SpecHelloRetryExtensionExtensionDataCombinator(self.0@) }
+impl View for ShOrHrrCombinator {
+    type V = SpecShOrHrrCombinator;
+    open spec fn view(&self) -> Self::V { SpecShOrHrrCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HelloRetryExtensionExtensionDataCombinator {
-    type Type = HelloRetryExtensionExtensionData<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ShOrHrrCombinator {
+    type Type = ShOrHrr<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type HelloRetryExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<HelloRetryExtensionExtensionDataCombinator3, HelloRetryExtensionExtensionDataMapper>>;
+}
+pub type ShOrHrrCombinatorAlias = Mapped<Pair<(Refined<U16Be, TagPred<u16>>, bytes::Fixed<32>), ShOrHrrPayloadCombinator, ShOrHrrCont0>, ShOrHrrMapper>;
 
 
-pub open spec fn spec_hello_retry_extension_extension_data(extension_type: u16, ext_len: u16) -> SpecHelloRetryExtensionExtensionDataCombinator {
-    SpecHelloRetryExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.spec_into()), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_SupportedVersions, inner: spec_supported_versions_server() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_Cookie, inner: spec_cookie() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_KeyShare, inner: spec_named_group() }, Cond { cond: !(extension_type == ExtensionType::SPEC_SupportedVersions || extension_type == ExtensionType::SPEC_Cookie || extension_type == ExtensionType::SPEC_KeyShare), inner: bytes::Variable(ext_len.spec_into()) }))), mapper: HelloRetryExtensionExtensionDataMapper }))
+pub open spec fn spec_sh_or_hrr() -> SpecShOrHrrCombinator {
+    SpecShOrHrrCombinator(
+    Mapped {
+        inner: Pair::spec_new((Refined { inner: U16Be, predicate: TagPred(SHORHRRLEGACY_VERSION_CONST) }, bytes::Fixed::<32>), |deps| spec_sh_or_hrr_cont0(deps)),
+        mapper: ShOrHrrMapper,
+    })
 }
 
-pub fn hello_retry_extension_extension_data<'a>(extension_type: u16, ext_len: u16) -> (o: HelloRetryExtensionExtensionDataCombinator)
-    ensures o@ == spec_hello_retry_extension_extension_data(extension_type@, ext_len@),
+pub open spec fn spec_sh_or_hrr_cont0(deps: (u16, Seq<u8>)) -> SpecShOrHrrPayloadCombinator {
+    let (_, random) = deps;
+    spec_sh_or_hrr_payload(random)
+}
+
+impl View for ShOrHrrCont0 {
+    type V = spec_fn((u16, Seq<u8>)) -> SpecShOrHrrPayloadCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u16, Seq<u8>)| {
+            spec_sh_or_hrr_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn sh_or_hrr<'a>() -> (o: ShOrHrrCombinator)
+    ensures o@ == spec_sh_or_hrr(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = HelloRetryExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.ex_into()), Mapped { inner: HelloRetryExtensionExtensionDataCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::SupportedVersions, inner: supported_versions_server() }, HelloRetryExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::Cookie, inner: cookie() }, HelloRetryExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::KeyShare, inner: named_group() }, Cond { cond: !(extension_type == ExtensionType::SupportedVersions || extension_type == ExtensionType::Cookie || extension_type == ExtensionType::KeyShare), inner: bytes::Variable(ext_len.ex_into()) })))))), mapper: HelloRetryExtensionExtensionDataMapper }));
-    assert({
-        &&& combinator@ == spec_hello_retry_extension_extension_data(extension_type@, ext_len@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ShOrHrrCombinator(
+    Mapped {
+        inner: Pair::new((Refined { inner: U16Be, predicate: TagPred(SHORHRRLEGACY_VERSION_CONST) }, bytes::Fixed::<32>), ShOrHrrCont0),
+        mapper: ShOrHrrMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_sh_or_hrr()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_hello_retry_extension_extension_data<'a>(input: &'a [u8], extension_type: u16, ext_len: u16) -> (res: PResult<<HelloRetryExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_sh_or_hrr<'a>(input: &'a [u8]) -> (res: PResult<<ShOrHrrCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) == Some((n as int, v@)),
-        spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_sh_or_hrr().spec_parse(input@) == Some((n as int, v@)),
+        spec_sh_or_hrr().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None,
-        spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_sh_or_hrr().spec_parse(input@) is None,
+        spec_sh_or_hrr().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = hello_retry_extension_extension_data( extension_type, ext_len );
+    let combinator = sh_or_hrr();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_hello_retry_extension_extension_data<'a>(v: <HelloRetryExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, extension_type: u16, ext_len: u16) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_sh_or_hrr<'a>(v: <ShOrHrrCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_hello_retry_extension_extension_data(extension_type@, ext_len@).wf(v@),
+        spec_sh_or_hrr().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@))
+            &&& n == spec_sh_or_hrr().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_sh_or_hrr().spec_serialize(v@))
         },
 {
-    let combinator = hello_retry_extension_extension_data( extension_type, ext_len );
-    combinator.serialize(v, data, pos)
+    let combinator = sh_or_hrr();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn hello_retry_extension_extension_data_len<'a>(v: <HelloRetryExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, extension_type: u16, ext_len: u16) -> (serialize_len: usize)
+pub fn sh_or_hrr_len<'a>(v: <ShOrHrrCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_hello_retry_extension_extension_data(extension_type@, ext_len@).wf(v@),
-        spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len() <= usize::MAX,
+        spec_sh_or_hrr().wf(v@),
+        spec_sh_or_hrr().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_hello_retry_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len(),
+        serialize_len == spec_sh_or_hrr().spec_serialize(v@).len(),
 {
-    let combinator = hello_retry_extension_extension_data( extension_type, ext_len );
+    let combinator = sh_or_hrr();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct ShOrHrrCont0;
+type ShOrHrrCont0Type<'a, 'b> = &'b (u16, &'a [u8]);
+type ShOrHrrCont0SType<'a, 'x> = (&'x u16, &'x &'a [u8]);
+type ShOrHrrCont0Input<'a, 'b, 'x> = POrSType<ShOrHrrCont0Type<'a, 'b>, ShOrHrrCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ShOrHrrCont0Input<'a, 'b, 'x>> for ShOrHrrCont0 {
+    type Output = ShOrHrrPayloadCombinator;
 
-pub struct SpecHelloRetryExtension {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: SpecHelloRetryExtensionExtensionData,
-}
-
-pub type SpecHelloRetryExtensionInner = ((u16, u16), SpecHelloRetryExtensionExtensionData);
-
+    open spec fn requires(&self, deps: ShOrHrrCont0Input<'a, 'b, 'x>) -> bool {
+        &&& ((Refined { inner: U16Be, predicate: TagPred(SHORHRRLEGACY_VERSION_CONST) }, bytes::Fixed::<32>)).wf(deps@)
+        }
 
-impl SpecFrom<SpecHelloRetryExtension> for SpecHelloRetryExtensionInner {
-    open spec fn spec_from(m: SpecHelloRetryExtension) -> SpecHelloRetryExtensionInner {
-        ((m.extension_type, m.ext_len), m.extension_data)
+    open spec fn ensures(&self, deps: ShOrHrrCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_sh_or_hrr_cont0(deps@)
     }
-}
 
-impl SpecFrom<SpecHelloRetryExtensionInner> for SpecHelloRetryExtension {
-    open spec fn spec_from(m: SpecHelloRetryExtensionInner) -> SpecHelloRetryExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        SpecHelloRetryExtension { extension_type, ext_len, extension_data }
+    fn apply(&self, deps: ShOrHrrCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (_, random) = deps;
+                let random = *random;
+                sh_or_hrr_payload(random)
+            }
+            POrSType::S(deps) => {
+                let (_, random) = deps;
+                let random = *random;
+                sh_or_hrr_payload(random)
+            }
+        }
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+                
 
-pub struct HelloRetryExtension<'a> {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: HelloRetryExtensionExtensionData<'a>,
+pub spec const SPEC_HandshakeType_ClientHello: u8 = 1;
+pub spec const SPEC_HandshakeType_ServerHello: u8 = 2;
+pub spec const SPEC_HandshakeType_NewSessionTicket: u8 = 4;
+pub spec const SPEC_HandshakeType_EndOfEarlyData: u8 = 5;
+pub spec const SPEC_HandshakeType_EncryptedExtensions: u8 = 8;
+pub spec const SPEC_HandshakeType_Certificate: u8 = 11;
+pub spec const SPEC_HandshakeType_CertificateRequest: u8 = 13;
+pub spec const SPEC_HandshakeType_CertificateVerify: u8 = 15;
+pub spec const SPEC_HandshakeType_Finished: u8 = 20;
+pub spec const SPEC_HandshakeType_KeyUpdate: u8 = 24;
+pub exec static EXEC_HandshakeType_ClientHello: u8 ensures EXEC_HandshakeType_ClientHello == SPEC_HandshakeType_ClientHello { 1 }
+pub exec static EXEC_HandshakeType_ServerHello: u8 ensures EXEC_HandshakeType_ServerHello == SPEC_HandshakeType_ServerHello { 2 }
+pub exec static EXEC_HandshakeType_NewSessionTicket: u8 ensures EXEC_HandshakeType_NewSessionTicket == SPEC_HandshakeType_NewSessionTicket { 4 }
+pub exec static EXEC_HandshakeType_EndOfEarlyData: u8 ensures EXEC_HandshakeType_EndOfEarlyData == SPEC_HandshakeType_EndOfEarlyData { 5 }
+pub exec static EXEC_HandshakeType_EncryptedExtensions: u8 ensures EXEC_HandshakeType_EncryptedExtensions == SPEC_HandshakeType_EncryptedExtensions { 8 }
+pub exec static EXEC_HandshakeType_Certificate: u8 ensures EXEC_HandshakeType_Certificate == SPEC_HandshakeType_Certificate { 11 }
+pub exec static EXEC_HandshakeType_CertificateRequest: u8 ensures EXEC_HandshakeType_CertificateRequest == SPEC_HandshakeType_CertificateRequest { 13 }
+pub exec static EXEC_HandshakeType_CertificateVerify: u8 ensures EXEC_HandshakeType_CertificateVerify == SPEC_HandshakeType_CertificateVerify { 15 }
+pub exec static EXEC_HandshakeType_Finished: u8 ensures EXEC_HandshakeType_Finished == SPEC_HandshakeType_Finished { 20 }
+pub exec static EXEC_HandshakeType_KeyUpdate: u8 ensures EXEC_HandshakeType_KeyUpdate == SPEC_HandshakeType_KeyUpdate { 24 }
+
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum HandshakeType {
+    ClientHello = 1,
+ServerHello = 2,
+NewSessionTicket = 4,
+EndOfEarlyData = 5,
+EncryptedExtensions = 8,
+Certificate = 11,
+CertificateRequest = 13,
+CertificateVerify = 15,
+Finished = 20,
+KeyUpdate = 24
 }
+pub type SpecHandshakeType = HandshakeType;
 
-impl View for HelloRetryExtension<'_> {
-    type V = SpecHelloRetryExtension;
+pub type HandshakeTypeInner = u8;
+
+pub type HandshakeTypeInnerRef<'a> = &'a u8;
+
+impl View for HandshakeType {
+    type V = Self;
 
     open spec fn view(&self) -> Self::V {
-        SpecHelloRetryExtension {
-            extension_type: self.extension_type@,
-            ext_len: self.ext_len@,
-            extension_data: self.extension_data@,
+        *self
+    }
+}
+
+impl SpecTryFrom<HandshakeTypeInner> for HandshakeType {
+    type Error = ();
+
+    open spec fn spec_try_from(v: HandshakeTypeInner) -> Result<HandshakeType, ()> {
+        match v {
+            1u8 => Ok(HandshakeType::ClientHello),
+            2u8 => Ok(HandshakeType::ServerHello),
+            4u8 => Ok(HandshakeType::NewSessionTicket),
+            5u8 => Ok(HandshakeType::EndOfEarlyData),
+            8u8 => Ok(HandshakeType::EncryptedExtensions),
+            11u8 => Ok(HandshakeType::Certificate),
+            13u8 => Ok(HandshakeType::CertificateRequest),
+            15u8 => Ok(HandshakeType::CertificateVerify),
+            20u8 => Ok(HandshakeType::Finished),
+            24u8 => Ok(HandshakeType::KeyUpdate),
+            _ => Err(()),
         }
     }
 }
-pub type HelloRetryExtensionInner<'a> = ((u16, u16), HelloRetryExtensionExtensionData<'a>);
 
-pub type HelloRetryExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a HelloRetryExtensionExtensionData<'a>);
-impl<'a> From<&'a HelloRetryExtension<'a>> for HelloRetryExtensionInnerRef<'a> {
-    fn ex_from(m: &'a HelloRetryExtension) -> HelloRetryExtensionInnerRef<'a> {
-        ((&m.extension_type, &m.ext_len), &m.extension_data)
+impl SpecTryFrom<HandshakeType> for HandshakeTypeInner {
+    type Error = ();
+
+    open spec fn spec_try_from(v: HandshakeType) -> Result<HandshakeTypeInner, ()> {
+        match v {
+            HandshakeType::ClientHello => Ok(SPEC_HandshakeType_ClientHello),
+            HandshakeType::ServerHello => Ok(SPEC_HandshakeType_ServerHello),
+            HandshakeType::NewSessionTicket => Ok(SPEC_HandshakeType_NewSessionTicket),
+            HandshakeType::EndOfEarlyData => Ok(SPEC_HandshakeType_EndOfEarlyData),
+            HandshakeType::EncryptedExtensions => Ok(SPEC_HandshakeType_EncryptedExtensions),
+            HandshakeType::Certificate => Ok(SPEC_HandshakeType_Certificate),
+            HandshakeType::CertificateRequest => Ok(SPEC_HandshakeType_CertificateRequest),
+            HandshakeType::CertificateVerify => Ok(SPEC_HandshakeType_CertificateVerify),
+            HandshakeType::Finished => Ok(SPEC_HandshakeType_Finished),
+            HandshakeType::KeyUpdate => Ok(SPEC_HandshakeType_KeyUpdate),
+        }
     }
 }
 
-impl<'a> From<HelloRetryExtensionInner<'a>> for HelloRetryExtension<'a> {
-    fn ex_from(m: HelloRetryExtensionInner) -> HelloRetryExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        HelloRetryExtension { extension_type, ext_len, extension_data }
+impl TryFrom<HandshakeTypeInner> for HandshakeType {
+    type Error = ();
+
+    fn ex_try_from(v: HandshakeTypeInner) -> Result<HandshakeType, ()> {
+        match v {
+            1u8 => Ok(HandshakeType::ClientHello),
+            2u8 => Ok(HandshakeType::ServerHello),
+            4u8 => Ok(HandshakeType::NewSessionTicket),
+            5u8 => Ok(HandshakeType::EndOfEarlyData),
+            8u8 => Ok(HandshakeType::EncryptedExtensions),
+            11u8 => Ok(HandshakeType::Certificate),
+            13u8 => Ok(HandshakeType::CertificateRequest),
+            15u8 => Ok(HandshakeType::CertificateVerify),
+            20u8 => Ok(HandshakeType::Finished),
+            24u8 => Ok(HandshakeType::KeyUpdate),
+            _ => Err(()),
+        }
     }
 }
 
-pub struct HelloRetryExtensionMapper;
-impl View for HelloRetryExtensionMapper {
+impl<'a> TryFrom<&'a HandshakeType> for HandshakeTypeInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a HandshakeType) -> Result<HandshakeTypeInnerRef<'a>, ()> {
+        match v {
+            HandshakeType::ClientHello => Ok(&EXEC_HandshakeType_ClientHello),
+            HandshakeType::ServerHello => Ok(&EXEC_HandshakeType_ServerHello),
+            HandshakeType::NewSessionTicket => Ok(&EXEC_HandshakeType_NewSessionTicket),
+            HandshakeType::EndOfEarlyData => Ok(&EXEC_HandshakeType_EndOfEarlyData),
+            HandshakeType::EncryptedExtensions => Ok(&EXEC_HandshakeType_EncryptedExtensions),
+            HandshakeType::Certificate => Ok(&EXEC_HandshakeType_Certificate),
+            HandshakeType::CertificateRequest => Ok(&EXEC_HandshakeType_CertificateRequest),
+            HandshakeType::CertificateVerify => Ok(&EXEC_HandshakeType_CertificateVerify),
+            HandshakeType::Finished => Ok(&EXEC_HandshakeType_Finished),
+            HandshakeType::KeyUpdate => Ok(&EXEC_HandshakeType_KeyUpdate),
+        }
+    }
+}
+
+pub struct HandshakeTypeMapper;
+
+impl View for HandshakeTypeMapper {
     type V = Self;
+
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for HelloRetryExtensionMapper {
-    type Src = SpecHelloRetryExtensionInner;
-    type Dst = SpecHelloRetryExtension;
+
+impl SpecPartialIso for HandshakeTypeMapper {
+    type Src = HandshakeTypeInner;
+    type Dst = HandshakeType;
 }
-impl SpecIsoProof for HelloRetryExtensionMapper {
+
+impl SpecPartialIsoProof for HandshakeTypeMapper {
     proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
     }
+
     proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
     }
 }
-impl<'a> Iso<'a> for HelloRetryExtensionMapper {
-    type Src = HelloRetryExtensionInner<'a>;
-    type Dst = HelloRetryExtension<'a>;
-    type RefSrc = HelloRetryExtensionInnerRef<'a>;
+
+impl<'a> PartialIso<'a> for HandshakeTypeMapper {
+    type Src = HandshakeTypeInner;
+    type Dst = HandshakeType;
+    type RefSrc = HandshakeTypeInnerRef<'a>;
 }
 
-pub struct SpecHelloRetryExtensionCombinator(pub SpecHelloRetryExtensionCombinatorAlias);
 
-impl SpecCombinator for SpecHelloRetryExtensionCombinator {
-    type Type = SpecHelloRetryExtension;
+pub struct SpecHandshakeTypeCombinator(pub SpecHandshakeTypeCombinatorAlias);
+
+impl SpecCombinator for SpecHandshakeTypeCombinator {
+    type Type = SpecHandshakeType;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecHelloRetryExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecHelloRetryExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecHandshakeTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHandshakeTypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecHelloRetryExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecHelloRetryExtensionExtensionDataCombinator>, HelloRetryExtensionMapper>;
+pub type SpecHandshakeTypeCombinatorAlias = TryMap<U8, HandshakeTypeMapper>;
 
-pub struct HelloRetryExtensionCombinator(pub HelloRetryExtensionCombinatorAlias);
+pub struct HandshakeTypeCombinator(pub HandshakeTypeCombinatorAlias);
 
-impl View for HelloRetryExtensionCombinator {
-    type V = SpecHelloRetryExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecHelloRetryExtensionCombinator(self.0@) }
+impl View for HandshakeTypeCombinator {
+    type V = SpecHandshakeTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecHandshakeTypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HelloRetryExtensionCombinator {
-    type Type = HelloRetryExtension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HandshakeTypeCombinator {
+    type Type = HandshakeType;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type HelloRetryExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, HelloRetryExtensionCont1>, HelloRetryExtensionExtensionDataCombinator, HelloRetryExtensionCont0>, HelloRetryExtensionMapper>;
-
-
-pub open spec fn spec_hello_retry_extension() -> SpecHelloRetryExtensionCombinator {
-    SpecHelloRetryExtensionCombinator(
-    Mapped {
-        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_hello_retry_extension_cont1(deps)), |deps| spec_hello_retry_extension_cont0(deps)),
-        mapper: HelloRetryExtensionMapper,
-    })
-}
-
-pub open spec fn spec_hello_retry_extension_cont1(deps: u16) -> U16Be {
-    let extension_type = deps;
-    U16Be
-}
-
-impl View for HelloRetryExtensionCont1 {
-    type V = spec_fn(u16) -> U16Be;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_hello_retry_extension_cont1(deps)
-        }
-    }
-}
-
-pub open spec fn spec_hello_retry_extension_cont0(deps: (u16, u16)) -> SpecHelloRetryExtensionExtensionDataCombinator {
-    let (extension_type, ext_len) = deps;
-    spec_hello_retry_extension_extension_data(extension_type, ext_len)
 }
+pub type HandshakeTypeCombinatorAlias = TryMap<U8, HandshakeTypeMapper>;
 
-impl View for HelloRetryExtensionCont0 {
-    type V = spec_fn((u16, u16)) -> SpecHelloRetryExtensionExtensionDataCombinator;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: (u16, u16)| {
-            spec_hello_retry_extension_cont0(deps)
-        }
-    }
+pub open spec fn spec_handshake_type() -> SpecHandshakeTypeCombinator {
+    SpecHandshakeTypeCombinator(TryMap { inner: U8, mapper: HandshakeTypeMapper })
 }
 
                 
-pub fn hello_retry_extension<'a>() -> (o: HelloRetryExtensionCombinator)
-    ensures o@ == spec_hello_retry_extension(),
+pub fn handshake_type<'a>() -> (o: HandshakeTypeCombinator)
+    ensures o@ == spec_handshake_type(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = HelloRetryExtensionCombinator(
-    Mapped {
-        inner: Pair::new(Pair::new(extension_type(), HelloRetryExtensionCont1), HelloRetryExtensionCont0),
-        mapper: HelloRetryExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_hello_retry_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = HandshakeTypeCombinator(TryMap { inner: U8, mapper: HandshakeTypeMapper });
+    // assert({
+    //     &&& combinator@ == spec_handshake_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_hello_retry_extension<'a>(input: &'a [u8]) -> (res: PResult<<HelloRetryExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_handshake_type<'a>(input: &'a [u8]) -> (res: PResult<<HandshakeTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_hello_retry_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_hello_retry_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_handshake_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_handshake_type().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_hello_retry_extension().spec_parse(input@) is None,
-        spec_hello_retry_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_handshake_type().spec_parse(input@) is None,
+        spec_handshake_type().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = hello_retry_extension();
+    let combinator = handshake_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_hello_retry_extension<'a>(v: <HelloRetryExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_handshake_type<'a>(v: <HandshakeTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_hello_retry_extension().wf(v@),
+        spec_handshake_type().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_hello_retry_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_hello_retry_extension().spec_serialize(v@))
+            &&& n == spec_handshake_type().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_handshake_type().spec_serialize(v@))
         },
 {
-    let combinator = hello_retry_extension();
+    let combinator = handshake_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn hello_retry_extension_len<'a>(v: <HelloRetryExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn handshake_type_len<'a>(v: <HandshakeTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_hello_retry_extension().wf(v@),
-        spec_hello_retry_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_handshake_type().wf(v@),
+        spec_handshake_type().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_hello_retry_extension().spec_serialize(v@).len(),
+        serialize_len == spec_handshake_type().spec_serialize(v@).len(),
 {
-    let combinator = hello_retry_extension();
+    let combinator = handshake_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct HelloRetryExtensionCont1;
-type HelloRetryExtensionCont1Type<'a, 'b> = &'b u16;
-type HelloRetryExtensionCont1SType<'a, 'x> = &'x u16;
-type HelloRetryExtensionCont1Input<'a, 'b, 'x> = POrSType<HelloRetryExtensionCont1Type<'a, 'b>, HelloRetryExtensionCont1SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<HelloRetryExtensionCont1Input<'a, 'b, 'x>> for HelloRetryExtensionCont1 {
-    type Output = U16Be;
-
-    open spec fn requires(&self, deps: HelloRetryExtensionCont1Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: HelloRetryExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_hello_retry_extension_cont1(deps@)
-    }
-
-    fn apply(&self, deps: HelloRetryExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let extension_type = *deps;
-                U16Be
-            }
-            POrSType::S(deps) => {
-                let extension_type = deps;
-                let extension_type = *extension_type;
-                U16Be
-            }
-        }
-    }
-}
-pub struct HelloRetryExtensionCont0;
-type HelloRetryExtensionCont0Type<'a, 'b> = &'b (u16, u16);
-type HelloRetryExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
-type HelloRetryExtensionCont0Input<'a, 'b, 'x> = POrSType<HelloRetryExtensionCont0Type<'a, 'b>, HelloRetryExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<HelloRetryExtensionCont0Input<'a, 'b, 'x>> for HelloRetryExtensionCont0 {
-    type Output = HelloRetryExtensionExtensionDataCombinator;
-
-    open spec fn requires(&self, deps: HelloRetryExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: HelloRetryExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_hello_retry_extension_cont0(deps@)
-    }
-
-    fn apply(&self, deps: HelloRetryExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let (extension_type, ext_len) = *deps;
-                hello_retry_extension_extension_data(extension_type, ext_len)
-            }
-            POrSType::S(deps) => {
-                let (extension_type, ext_len) = deps;
-                let (extension_type, ext_len) = (*extension_type, *ext_len);
-                hello_retry_extension_extension_data(extension_type, ext_len)
-            }
-        }
-    }
-}
                 
 
-pub struct SpecHelloRetryExtensions {
+pub struct SpecCipherSuiteList {
     pub l: u16,
-    pub list: Seq<SpecHelloRetryExtension>,
+    pub list: Seq<u16>,
 }
 
-pub type SpecHelloRetryExtensionsInner = (u16, Seq<SpecHelloRetryExtension>);
+pub type SpecCipherSuiteListInner = (u16, Seq<u16>);
 
 
-impl SpecFrom<SpecHelloRetryExtensions> for SpecHelloRetryExtensionsInner {
-    open spec fn spec_from(m: SpecHelloRetryExtensions) -> SpecHelloRetryExtensionsInner {
+impl SpecFrom<SpecCipherSuiteList> for SpecCipherSuiteListInner {
+    open spec fn spec_from(m: SpecCipherSuiteList) -> SpecCipherSuiteListInner {
         (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecHelloRetryExtensionsInner> for SpecHelloRetryExtensions {
-    open spec fn spec_from(m: SpecHelloRetryExtensionsInner) -> SpecHelloRetryExtensions {
+impl SpecFrom<SpecCipherSuiteListInner> for SpecCipherSuiteList {
+    open spec fn spec_from(m: SpecCipherSuiteListInner) -> SpecCipherSuiteList {
         let (l, list) = m;
-        SpecHelloRetryExtensions { l, list }
+        SpecCipherSuiteList { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct HelloRetryExtensions<'a> {
+pub struct CipherSuiteList {
     pub l: u16,
-    pub list: RepeatResult<HelloRetryExtension<'a>>,
+    pub list: RepeatResult<u16>,
 }
 
-impl View for HelloRetryExtensions<'_> {
-    type V = SpecHelloRetryExtensions;
+impl View for CipherSuiteList {
+    type V = SpecCipherSuiteList;
 
     open spec fn view(&self) -> Self::V {
-        SpecHelloRetryExtensions {
+        SpecCipherSuiteList {
             l: self.l@,
             list: self.list@,
         }
     }
 }
-pub type HelloRetryExtensionsInner<'a> = (u16, RepeatResult<HelloRetryExtension<'a>>);
+pub type CipherSuiteListInner = (u16, RepeatResult<u16>);
 
-pub type HelloRetryExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<HelloRetryExtension<'a>>);
-impl<'a> From<&'a HelloRetryExtensions<'a>> for HelloRetryExtensionsInnerRef<'a> {
-    fn ex_from(m: &'a HelloRetryExtensions) -> HelloRetryExtensionsInnerRef<'a> {
+pub type CipherSuiteListInnerRef<'a> = (&'a u16, &'a RepeatResult<u16>);
+impl<'a> From<&'a CipherSuiteList> for CipherSuiteListInnerRef<'a> {
+    fn ex_from(m: &'a CipherSuiteList) -> CipherSuiteListInnerRef<'a> {
         (&m.l, &m.list)
     }
 }
 
-impl<'a> From<HelloRetryExtensionsInner<'a>> for HelloRetryExtensions<'a> {
-    fn ex_from(m: HelloRetryExtensionsInner) -> HelloRetryExtensions {
+impl From<CipherSuiteListInner> for CipherSuiteList {
+    fn ex_from(m: CipherSuiteListInner) -> CipherSuiteList {
         let (l, list) = m;
-        HelloRetryExtensions { l, list }
+        CipherSuiteList { l, list }
     }
 }
 
-pub struct HelloRetryExtensionsMapper;
-impl View for HelloRetryExtensionsMapper {
+pub struct CipherSuiteListMapper;
+impl View for CipherSuiteListMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for HelloRetryExtensionsMapper {
-    type Src = SpecHelloRetryExtensionsInner;
-    type Dst = SpecHelloRetryExtensions;
+impl SpecIso for CipherSuiteListMapper {
+    type Src = SpecCipherSuiteListInner;
+    type Dst = SpecCipherSuiteList;
 }
-impl SpecIsoProof for HelloRetryExtensionsMapper {
+impl SpecIsoProof for CipherSuiteListMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -9471,693 +8932,501 @@ impl SpecIsoProof for HelloRetryExtensionsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for HelloRetryExtensionsMapper {
-    type Src = HelloRetryExtensionsInner<'a>;
-    type Dst = HelloRetryExtensions<'a>;
-    type RefSrc = HelloRetryExtensionsInnerRef<'a>;
+impl<'a> Iso<'a> for CipherSuiteListMapper {
+    type Src = CipherSuiteListInner;
+    type Dst = CipherSuiteList;
+    type RefSrc = CipherSuiteListInnerRef<'a>;
 }
 
-pub struct SpecHelloRetryExtensionsCombinator(pub SpecHelloRetryExtensionsCombinatorAlias);
+pub struct SpecCipherSuiteListCombinator(pub SpecCipherSuiteListCombinatorAlias);
 
-impl SpecCombinator for SpecHelloRetryExtensionsCombinator {
-    type Type = SpecHelloRetryExtensions;
+impl SpecCombinator for SpecCipherSuiteListCombinator {
+    type Type = SpecCipherSuiteList;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecHelloRetryExtensionsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecHelloRetryExtensionsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCipherSuiteListCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCipherSuiteListCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecHelloRetryExtensionsCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate14496530480760116989>, AndThen<bytes::Variable, Repeat<SpecHelloRetryExtensionCombinator>>>, HelloRetryExtensionsMapper>;
-pub struct Predicate14496530480760116989;
-impl View for Predicate14496530480760116989 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u16> for Predicate14496530480760116989 {
-    fn apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 6 && i <= 65535)
-    }
-}
-impl SpecPred<u16> for Predicate14496530480760116989 {
-    open spec fn spec_apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 6 && i <= 65535)
-    }
-}
+pub type SpecCipherSuiteListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate15206902916018849611>, AndThen<bytes::Variable, Repeat<SpecCipherSuiteCombinator>>>, CipherSuiteListMapper>;
 
-pub struct HelloRetryExtensionsCombinator(pub HelloRetryExtensionsCombinatorAlias);
+pub struct CipherSuiteListCombinator(pub CipherSuiteListCombinatorAlias);
 
-impl View for HelloRetryExtensionsCombinator {
-    type V = SpecHelloRetryExtensionsCombinator;
-    open spec fn view(&self) -> Self::V { SpecHelloRetryExtensionsCombinator(self.0@) }
+impl View for CipherSuiteListCombinator {
+    type V = SpecCipherSuiteListCombinator;
+    open spec fn view(&self) -> Self::V { SpecCipherSuiteListCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HelloRetryExtensionsCombinator {
-    type Type = HelloRetryExtensions<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CipherSuiteListCombinator {
+    type Type = CipherSuiteList;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type HelloRetryExtensionsCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate14496530480760116989>, AndThen<bytes::Variable, Repeat<HelloRetryExtensionCombinator>>, HelloRetryExtensionsCont0>, HelloRetryExtensionsMapper>;
+}
+pub type CipherSuiteListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate15206902916018849611>, AndThen<bytes::Variable, Repeat<CipherSuiteCombinator>>, CipherSuiteListCont0>, CipherSuiteListMapper>;
 
 
-pub open spec fn spec_hello_retry_extensions() -> SpecHelloRetryExtensionsCombinator {
-    SpecHelloRetryExtensionsCombinator(
+pub open spec fn spec_cipher_suite_list() -> SpecCipherSuiteListCombinator {
+    SpecCipherSuiteListCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate14496530480760116989 }, |deps| spec_hello_retry_extensions_cont0(deps)),
-        mapper: HelloRetryExtensionsMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate15206902916018849611 }, |deps| spec_cipher_suite_list_cont0(deps)),
+        mapper: CipherSuiteListMapper,
     })
 }
 
-pub open spec fn spec_hello_retry_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecHelloRetryExtensionCombinator>> {
+pub open spec fn spec_cipher_suite_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecCipherSuiteCombinator>> {
     let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_hello_retry_extension()))
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_cipher_suite()))
 }
 
-impl View for HelloRetryExtensionsCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecHelloRetryExtensionCombinator>>;
+impl View for CipherSuiteListCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecCipherSuiteCombinator>>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u16| {
-            spec_hello_retry_extensions_cont0(deps)
+            spec_cipher_suite_list_cont0(deps)
         }
     }
 }
 
                 
-pub fn hello_retry_extensions<'a>() -> (o: HelloRetryExtensionsCombinator)
-    ensures o@ == spec_hello_retry_extensions(),
+pub fn cipher_suite_list<'a>() -> (o: CipherSuiteListCombinator)
+    ensures o@ == spec_cipher_suite_list(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = HelloRetryExtensionsCombinator(
+    let combinator = CipherSuiteListCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate14496530480760116989 }, HelloRetryExtensionsCont0),
-        mapper: HelloRetryExtensionsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_hello_retry_extensions()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate15206902916018849611 }, CipherSuiteListCont0),
+        mapper: CipherSuiteListMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_cipher_suite_list()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_hello_retry_extensions<'a>(input: &'a [u8]) -> (res: PResult<<HelloRetryExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_cipher_suite_list<'a>(input: &'a [u8]) -> (res: PResult<<CipherSuiteListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_hello_retry_extensions().spec_parse(input@) == Some((n as int, v@)),
-        spec_hello_retry_extensions().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_cipher_suite_list().spec_parse(input@) == Some((n as int, v@)),
+        spec_cipher_suite_list().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_hello_retry_extensions().spec_parse(input@) is None,
-        spec_hello_retry_extensions().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_cipher_suite_list().spec_parse(input@) is None,
+        spec_cipher_suite_list().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = hello_retry_extensions();
+    let combinator = cipher_suite_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_hello_retry_extensions<'a>(v: <HelloRetryExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_cipher_suite_list<'a>(v: <CipherSuiteListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_hello_retry_extensions().wf(v@),
+        spec_cipher_suite_list().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_hello_retry_extensions().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_hello_retry_extensions().spec_serialize(v@))
+            &&& n == spec_cipher_suite_list().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_cipher_suite_list().spec_serialize(v@))
         },
 {
-    let combinator = hello_retry_extensions();
+    let combinator = cipher_suite_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn hello_retry_extensions_len<'a>(v: <HelloRetryExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn cipher_suite_list_len<'a>(v: <CipherSuiteListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_hello_retry_extensions().wf(v@),
-        spec_hello_retry_extensions().spec_serialize(v@).len() <= usize::MAX,
+        spec_cipher_suite_list().wf(v@),
+        spec_cipher_suite_list().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_hello_retry_extensions().spec_serialize(v@).len(),
+        serialize_len == spec_cipher_suite_list().spec_serialize(v@).len(),
 {
-    let combinator = hello_retry_extensions();
+    let combinator = cipher_suite_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct HelloRetryExtensionsCont0;
-type HelloRetryExtensionsCont0Type<'a, 'b> = &'b u16;
-type HelloRetryExtensionsCont0SType<'a, 'x> = &'x u16;
-type HelloRetryExtensionsCont0Input<'a, 'b, 'x> = POrSType<HelloRetryExtensionsCont0Type<'a, 'b>, HelloRetryExtensionsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<HelloRetryExtensionsCont0Input<'a, 'b, 'x>> for HelloRetryExtensionsCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<HelloRetryExtensionCombinator>>;
+pub struct CipherSuiteListCont0;
+type CipherSuiteListCont0Type<'a, 'b> = &'b u16;
+type CipherSuiteListCont0SType<'a, 'x> = &'x u16;
+type CipherSuiteListCont0Input<'a, 'b, 'x> = POrSType<CipherSuiteListCont0Type<'a, 'b>, CipherSuiteListCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CipherSuiteListCont0Input<'a, 'b, 'x>> for CipherSuiteListCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<CipherSuiteCombinator>>;
 
-    open spec fn requires(&self, deps: HelloRetryExtensionsCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: CipherSuiteListCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate15206902916018849611 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: HelloRetryExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_hello_retry_extensions_cont0(deps@)
+    open spec fn ensures(&self, deps: CipherSuiteListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_cipher_suite_list_cont0(deps@)
     }
 
-    fn apply(&self, deps: HelloRetryExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: CipherSuiteListCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(hello_retry_extension()))
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(cipher_suite()))
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(hello_retry_extension()))
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(cipher_suite()))
             }
         }
     }
 }
                 
+pub type SpecHostName = SpecOpaque1Ffff;
+pub type HostName<'a> = Opaque1Ffff<'a>;
+pub type HostNameRef<'a> = &'a Opaque1Ffff<'a>;
 
-pub struct SpecHelloRetryRequest {
-    pub legacy_session_id_echo: SpecSessionId,
-    pub cipher_suite: u16,
-    pub legacy_compression_method: u8,
-    pub extensions: SpecHelloRetryExtensions,
-}
-
-pub type SpecHelloRetryRequestInner = (SpecSessionId, (u16, (u8, SpecHelloRetryExtensions)));
-
-
-impl SpecFrom<SpecHelloRetryRequest> for SpecHelloRetryRequestInner {
-    open spec fn spec_from(m: SpecHelloRetryRequest) -> SpecHelloRetryRequestInner {
-        (m.legacy_session_id_echo, (m.cipher_suite, (m.legacy_compression_method, m.extensions)))
-    }
-}
-
-impl SpecFrom<SpecHelloRetryRequestInner> for SpecHelloRetryRequest {
-    open spec fn spec_from(m: SpecHelloRetryRequestInner) -> SpecHelloRetryRequest {
-        let (legacy_session_id_echo, (cipher_suite, (legacy_compression_method, extensions))) = m;
-        SpecHelloRetryRequest { legacy_session_id_echo, cipher_suite, legacy_compression_method, extensions }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct HelloRetryRequest<'a> {
-    pub legacy_session_id_echo: SessionId<'a>,
-    pub cipher_suite: u16,
-    pub legacy_compression_method: u8,
-    pub extensions: HelloRetryExtensions<'a>,
-}
-
-impl View for HelloRetryRequest<'_> {
-    type V = SpecHelloRetryRequest;
 
-    open spec fn view(&self) -> Self::V {
-        SpecHelloRetryRequest {
-            legacy_session_id_echo: self.legacy_session_id_echo@,
-            cipher_suite: self.cipher_suite@,
-            legacy_compression_method: self.legacy_compression_method@,
-            extensions: self.extensions@,
-        }
-    }
-}
-pub type HelloRetryRequestInner<'a> = (SessionId<'a>, (u16, (u8, HelloRetryExtensions<'a>)));
-
-pub type HelloRetryRequestInnerRef<'a> = (&'a SessionId<'a>, (&'a u16, (&'a u8, &'a HelloRetryExtensions<'a>)));
-impl<'a> From<&'a HelloRetryRequest<'a>> for HelloRetryRequestInnerRef<'a> {
-    fn ex_from(m: &'a HelloRetryRequest) -> HelloRetryRequestInnerRef<'a> {
-        (&m.legacy_session_id_echo, (&m.cipher_suite, (&m.legacy_compression_method, &m.extensions)))
-    }
-}
-
-impl<'a> From<HelloRetryRequestInner<'a>> for HelloRetryRequest<'a> {
-    fn ex_from(m: HelloRetryRequestInner) -> HelloRetryRequest {
-        let (legacy_session_id_echo, (cipher_suite, (legacy_compression_method, extensions))) = m;
-        HelloRetryRequest { legacy_session_id_echo, cipher_suite, legacy_compression_method, extensions }
-    }
-}
-
-pub struct HelloRetryRequestMapper;
-impl View for HelloRetryRequestMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for HelloRetryRequestMapper {
-    type Src = SpecHelloRetryRequestInner;
-    type Dst = SpecHelloRetryRequest;
-}
-impl SpecIsoProof for HelloRetryRequestMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for HelloRetryRequestMapper {
-    type Src = HelloRetryRequestInner<'a>;
-    type Dst = HelloRetryRequest<'a>;
-    type RefSrc = HelloRetryRequestInnerRef<'a>;
-}
-pub const HELLORETRYREQUESTLEGACY_COMPRESSION_METHOD_CONST: u8 = 0;
-type SpecHelloRetryRequestCombinatorAlias1 = (Refined<U8, TagPred<u8>>, SpecHelloRetryExtensionsCombinator);
-type SpecHelloRetryRequestCombinatorAlias2 = (SpecCipherSuiteCombinator, SpecHelloRetryRequestCombinatorAlias1);
-type SpecHelloRetryRequestCombinatorAlias3 = (SpecSessionIdCombinator, SpecHelloRetryRequestCombinatorAlias2);
-pub struct SpecHelloRetryRequestCombinator(pub SpecHelloRetryRequestCombinatorAlias);
+pub struct SpecHostNameCombinator(pub SpecHostNameCombinatorAlias);
 
-impl SpecCombinator for SpecHelloRetryRequestCombinator {
-    type Type = SpecHelloRetryRequest;
+impl SpecCombinator for SpecHostNameCombinator {
+    type Type = SpecHostName;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecHelloRetryRequestCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecHelloRetryRequestCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecHostNameCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHostNameCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecHelloRetryRequestCombinatorAlias = Mapped<SpecHelloRetryRequestCombinatorAlias3, HelloRetryRequestMapper>;
-type HelloRetryRequestCombinatorAlias1 = (Refined<U8, TagPred<u8>>, HelloRetryExtensionsCombinator);
-type HelloRetryRequestCombinatorAlias2 = (CipherSuiteCombinator, HelloRetryRequestCombinator1);
-type HelloRetryRequestCombinatorAlias3 = (SessionIdCombinator, HelloRetryRequestCombinator2);
-pub struct HelloRetryRequestCombinator1(pub HelloRetryRequestCombinatorAlias1);
-impl View for HelloRetryRequestCombinator1 {
-    type V = SpecHelloRetryRequestCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HelloRetryRequestCombinator1, HelloRetryRequestCombinatorAlias1);
-
-pub struct HelloRetryRequestCombinator2(pub HelloRetryRequestCombinatorAlias2);
-impl View for HelloRetryRequestCombinator2 {
-    type V = SpecHelloRetryRequestCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HelloRetryRequestCombinator2, HelloRetryRequestCombinatorAlias2);
-
-pub struct HelloRetryRequestCombinator3(pub HelloRetryRequestCombinatorAlias3);
-impl View for HelloRetryRequestCombinator3 {
-    type V = SpecHelloRetryRequestCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HelloRetryRequestCombinator3, HelloRetryRequestCombinatorAlias3);
+pub type SpecHostNameCombinatorAlias = SpecOpaque1FfffCombinator;
 
-pub struct HelloRetryRequestCombinator(pub HelloRetryRequestCombinatorAlias);
+pub struct HostNameCombinator(pub HostNameCombinatorAlias);
 
-impl View for HelloRetryRequestCombinator {
-    type V = SpecHelloRetryRequestCombinator;
-    open spec fn view(&self) -> Self::V { SpecHelloRetryRequestCombinator(self.0@) }
+impl View for HostNameCombinator {
+    type V = SpecHostNameCombinator;
+    open spec fn view(&self) -> Self::V { SpecHostNameCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HelloRetryRequestCombinator {
-    type Type = HelloRetryRequest<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HostNameCombinator {
+    type Type = HostName<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type HelloRetryRequestCombinatorAlias = Mapped<HelloRetryRequestCombinator3, HelloRetryRequestMapper>;
+}
+pub type HostNameCombinatorAlias = Opaque1FfffCombinator;
 
 
-pub open spec fn spec_hello_retry_request() -> SpecHelloRetryRequestCombinator {
-    SpecHelloRetryRequestCombinator(
-    Mapped {
-        inner: (spec_session_id(), (spec_cipher_suite(), (Refined { inner: U8, predicate: TagPred(HELLORETRYREQUESTLEGACY_COMPRESSION_METHOD_CONST) }, spec_hello_retry_extensions()))),
-        mapper: HelloRetryRequestMapper,
-    })
+pub open spec fn spec_host_name() -> SpecHostNameCombinator {
+    SpecHostNameCombinator(spec_opaque_1_ffff())
 }
 
                 
-pub fn hello_retry_request<'a>() -> (o: HelloRetryRequestCombinator)
-    ensures o@ == spec_hello_retry_request(),
+pub fn host_name<'a>() -> (o: HostNameCombinator)
+    ensures o@ == spec_host_name(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = HelloRetryRequestCombinator(
-    Mapped {
-        inner: HelloRetryRequestCombinator3((session_id(), HelloRetryRequestCombinator2((cipher_suite(), HelloRetryRequestCombinator1((Refined { inner: U8, predicate: TagPred(HELLORETRYREQUESTLEGACY_COMPRESSION_METHOD_CONST) }, hello_retry_extensions())))))),
-        mapper: HelloRetryRequestMapper,
-    });
-    assert({
-        &&& combinator@ == spec_hello_retry_request()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = HostNameCombinator(opaque_1_ffff());
+    // assert({
+    //     &&& combinator@ == spec_host_name()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_hello_retry_request<'a>(input: &'a [u8]) -> (res: PResult<<HelloRetryRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_host_name<'a>(input: &'a [u8]) -> (res: PResult<<HostNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_hello_retry_request().spec_parse(input@) == Some((n as int, v@)),
-        spec_hello_retry_request().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_host_name().spec_parse(input@) == Some((n as int, v@)),
+        spec_host_name().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_hello_retry_request().spec_parse(input@) is None,
-        spec_hello_retry_request().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_host_name().spec_parse(input@) is None,
+        spec_host_name().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = hello_retry_request();
+    let combinator = host_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_hello_retry_request<'a>(v: <HelloRetryRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_host_name<'a>(v: <HostNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_hello_retry_request().wf(v@),
+        spec_host_name().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& 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@))
+            &&& n == spec_host_name().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_host_name().spec_serialize(v@))
         },
 {
-    let combinator = hello_retry_request();
+    let combinator = host_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn hello_retry_request_len<'a>(v: <HelloRetryRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn host_name_len<'a>(v: <HostNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_hello_retry_request().wf(v@),
-        spec_hello_retry_request().spec_serialize(v@).len() <= usize::MAX,
+        spec_host_name().wf(v@),
+        spec_host_name().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_hello_retry_request().spec_serialize(v@).len(),
+        serialize_len == spec_host_name().spec_serialize(v@).len(),
 {
-    let combinator = hello_retry_request();
+    let combinator = host_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
+pub type SpecUnknownName = SpecOpaque1Ffff;
+pub type UnknownName<'a> = Opaque1Ffff<'a>;
+pub type UnknownNameRef<'a> = &'a Opaque1Ffff<'a>;
 
-pub struct SpecPreSharedKeyServerExtension {
-    pub selected_identity: u16,
-}
-
-pub type SpecPreSharedKeyServerExtensionInner = u16;
 
+pub struct SpecUnknownNameCombinator(pub SpecUnknownNameCombinatorAlias);
 
-impl SpecFrom<SpecPreSharedKeyServerExtension> for SpecPreSharedKeyServerExtensionInner {
-    open spec fn spec_from(m: SpecPreSharedKeyServerExtension) -> SpecPreSharedKeyServerExtensionInner {
-        m.selected_identity
-    }
+impl SpecCombinator for SpecUnknownNameCombinator {
+    type Type = SpecUnknownName;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
 }
-
-impl SpecFrom<SpecPreSharedKeyServerExtensionInner> for SpecPreSharedKeyServerExtension {
-    open spec fn spec_from(m: SpecPreSharedKeyServerExtensionInner) -> SpecPreSharedKeyServerExtension {
-        let selected_identity = m;
-        SpecPreSharedKeyServerExtension { selected_identity }
-    }
+impl SecureSpecCombinator for SpecUnknownNameCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecUnknownNameCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+pub type SpecUnknownNameCombinatorAlias = SpecOpaque1FfffCombinator;
 
-pub struct PreSharedKeyServerExtension {
-    pub selected_identity: u16,
+pub struct UnknownNameCombinator(pub UnknownNameCombinatorAlias);
+
+impl View for UnknownNameCombinator {
+    type V = SpecUnknownNameCombinator;
+    open spec fn view(&self) -> Self::V { SpecUnknownNameCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for UnknownNameCombinator {
+    type Type = UnknownName<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+pub type UnknownNameCombinatorAlias = Opaque1FfffCombinator;
 
-impl View for PreSharedKeyServerExtension {
-    type V = SpecPreSharedKeyServerExtension;
 
-    open spec fn view(&self) -> Self::V {
-        SpecPreSharedKeyServerExtension {
-            selected_identity: self.selected_identity@,
-        }
-    }
-}
-pub type PreSharedKeyServerExtensionInner = u16;
-
-pub type PreSharedKeyServerExtensionInnerRef<'a> = &'a u16;
-impl<'a> From<&'a PreSharedKeyServerExtension> for PreSharedKeyServerExtensionInnerRef<'a> {
-    fn ex_from(m: &'a PreSharedKeyServerExtension) -> PreSharedKeyServerExtensionInnerRef<'a> {
-        &m.selected_identity
-    }
-}
-
-impl From<PreSharedKeyServerExtensionInner> for PreSharedKeyServerExtension {
-    fn ex_from(m: PreSharedKeyServerExtensionInner) -> PreSharedKeyServerExtension {
-        let selected_identity = m;
-        PreSharedKeyServerExtension { selected_identity }
-    }
-}
-
-pub struct PreSharedKeyServerExtensionMapper;
-impl View for PreSharedKeyServerExtensionMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for PreSharedKeyServerExtensionMapper {
-    type Src = SpecPreSharedKeyServerExtensionInner;
-    type Dst = SpecPreSharedKeyServerExtension;
-}
-impl SpecIsoProof for PreSharedKeyServerExtensionMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for PreSharedKeyServerExtensionMapper {
-    type Src = PreSharedKeyServerExtensionInner;
-    type Dst = PreSharedKeyServerExtension;
-    type RefSrc = PreSharedKeyServerExtensionInnerRef<'a>;
-}
-
-pub struct SpecPreSharedKeyServerExtensionCombinator(pub SpecPreSharedKeyServerExtensionCombinatorAlias);
-
-impl SpecCombinator for SpecPreSharedKeyServerExtensionCombinator {
-    type Type = SpecPreSharedKeyServerExtension;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecPreSharedKeyServerExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecPreSharedKeyServerExtensionCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
-}
-pub type SpecPreSharedKeyServerExtensionCombinatorAlias = Mapped<U16Be, PreSharedKeyServerExtensionMapper>;
-
-pub struct PreSharedKeyServerExtensionCombinator(pub PreSharedKeyServerExtensionCombinatorAlias);
-
-impl View for PreSharedKeyServerExtensionCombinator {
-    type V = SpecPreSharedKeyServerExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecPreSharedKeyServerExtensionCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PreSharedKeyServerExtensionCombinator {
-    type Type = PreSharedKeyServerExtension;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type PreSharedKeyServerExtensionCombinatorAlias = Mapped<U16Be, PreSharedKeyServerExtensionMapper>;
-
-
-pub open spec fn spec_pre_shared_key_server_extension() -> SpecPreSharedKeyServerExtensionCombinator {
-    SpecPreSharedKeyServerExtensionCombinator(
-    Mapped {
-        inner: U16Be,
-        mapper: PreSharedKeyServerExtensionMapper,
-    })
+pub open spec fn spec_unknown_name() -> SpecUnknownNameCombinator {
+    SpecUnknownNameCombinator(spec_opaque_1_ffff())
 }
 
                 
-pub fn pre_shared_key_server_extension<'a>() -> (o: PreSharedKeyServerExtensionCombinator)
-    ensures o@ == spec_pre_shared_key_server_extension(),
+pub fn unknown_name<'a>() -> (o: UnknownNameCombinator)
+    ensures o@ == spec_unknown_name(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = PreSharedKeyServerExtensionCombinator(
-    Mapped {
-        inner: U16Be,
-        mapper: PreSharedKeyServerExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_pre_shared_key_server_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = UnknownNameCombinator(opaque_1_ffff());
+    // assert({
+    //     &&& combinator@ == spec_unknown_name()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_pre_shared_key_server_extension<'a>(input: &'a [u8]) -> (res: PResult<<PreSharedKeyServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_unknown_name<'a>(input: &'a [u8]) -> (res: PResult<<UnknownNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_pre_shared_key_server_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_pre_shared_key_server_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_unknown_name().spec_parse(input@) == Some((n as int, v@)),
+        spec_unknown_name().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_pre_shared_key_server_extension().spec_parse(input@) is None,
-        spec_pre_shared_key_server_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_unknown_name().spec_parse(input@) is None,
+        spec_unknown_name().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = pre_shared_key_server_extension();
+    let combinator = unknown_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_pre_shared_key_server_extension<'a>(v: <PreSharedKeyServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_unknown_name<'a>(v: <UnknownNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_pre_shared_key_server_extension().wf(v@),
+        spec_unknown_name().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_pre_shared_key_server_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_pre_shared_key_server_extension().spec_serialize(v@))
+            &&& n == spec_unknown_name().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_unknown_name().spec_serialize(v@))
         },
 {
-    let combinator = pre_shared_key_server_extension();
+    let combinator = unknown_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn pre_shared_key_server_extension_len<'a>(v: <PreSharedKeyServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn unknown_name_len<'a>(v: <UnknownNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_pre_shared_key_server_extension().wf(v@),
-        spec_pre_shared_key_server_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_unknown_name().wf(v@),
+        spec_unknown_name().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_pre_shared_key_server_extension().spec_serialize(v@).len(),
+        serialize_len == spec_unknown_name().spec_serialize(v@).len(),
 {
-    let combinator = pre_shared_key_server_extension();
+    let combinator = unknown_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecKeyShareEntry {
-    pub group: u16,
-    pub l: u16,
-    pub key_exchange: Seq<u8>,
+pub enum SpecServerNameName {
+    HostName(SpecHostName),
+    Unrecognized(SpecUnknownName),
 }
 
-pub type SpecKeyShareEntryInner = ((u16, u16), Seq<u8>);
-
+pub type SpecServerNameNameInner = Either<SpecHostName, SpecUnknownName>;
 
-impl SpecFrom<SpecKeyShareEntry> for SpecKeyShareEntryInner {
-    open spec fn spec_from(m: SpecKeyShareEntry) -> SpecKeyShareEntryInner {
-        ((m.group, m.l), m.key_exchange)
+impl SpecFrom<SpecServerNameName> for SpecServerNameNameInner {
+    open spec fn spec_from(m: SpecServerNameName) -> SpecServerNameNameInner {
+        match m {
+            SpecServerNameName::HostName(m) => Either::Left(m),
+            SpecServerNameName::Unrecognized(m) => Either::Right(m),
+        }
     }
+
 }
 
-impl SpecFrom<SpecKeyShareEntryInner> for SpecKeyShareEntry {
-    open spec fn spec_from(m: SpecKeyShareEntryInner) -> SpecKeyShareEntry {
-        let ((group, l), key_exchange) = m;
-        SpecKeyShareEntry { group, l, key_exchange }
+                
+impl SpecFrom<SpecServerNameNameInner> for SpecServerNameName {
+    open spec fn spec_from(m: SpecServerNameNameInner) -> SpecServerNameName {
+        match m {
+            Either::Left(m) => SpecServerNameName::HostName(m),
+            Either::Right(m) => SpecServerNameName::Unrecognized(m),
+        }
     }
+
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct KeyShareEntry<'a> {
-    pub group: u16,
-    pub l: u16,
-    pub key_exchange: &'a [u8],
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ServerNameName<'a> {
+    HostName(HostName<'a>),
+    Unrecognized(UnknownName<'a>),
 }
 
-impl View for KeyShareEntry<'_> {
-    type V = SpecKeyShareEntry;
+pub type ServerNameNameInner<'a> = Either<HostName<'a>, UnknownName<'a>>;
+
+pub type ServerNameNameInnerRef<'a> = Either<&'a HostName<'a>, &'a UnknownName<'a>>;
+
 
+impl<'a> View for ServerNameName<'a> {
+    type V = SpecServerNameName;
     open spec fn view(&self) -> Self::V {
-        SpecKeyShareEntry {
-            group: self.group@,
-            l: self.l@,
-            key_exchange: self.key_exchange@,
+        match self {
+            ServerNameName::HostName(m) => SpecServerNameName::HostName(m@),
+            ServerNameName::Unrecognized(m) => SpecServerNameName::Unrecognized(m@),
         }
     }
 }
-pub type KeyShareEntryInner<'a> = ((u16, u16), &'a [u8]);
 
-pub type KeyShareEntryInnerRef<'a> = ((&'a u16, &'a u16), &'a &'a [u8]);
-impl<'a> From<&'a KeyShareEntry<'a>> for KeyShareEntryInnerRef<'a> {
-    fn ex_from(m: &'a KeyShareEntry) -> KeyShareEntryInnerRef<'a> {
-        ((&m.group, &m.l), &m.key_exchange)
+
+impl<'a> From<&'a ServerNameName<'a>> for ServerNameNameInnerRef<'a> {
+    fn ex_from(m: &'a ServerNameName<'a>) -> ServerNameNameInnerRef<'a> {
+        match m {
+            ServerNameName::HostName(m) => Either::Left(m),
+            ServerNameName::Unrecognized(m) => Either::Right(m),
+        }
     }
+
 }
 
-impl<'a> From<KeyShareEntryInner<'a>> for KeyShareEntry<'a> {
-    fn ex_from(m: KeyShareEntryInner) -> KeyShareEntry {
-        let ((group, l), key_exchange) = m;
-        KeyShareEntry { group, l, key_exchange }
+impl<'a> From<ServerNameNameInner<'a>> for ServerNameName<'a> {
+    fn ex_from(m: ServerNameNameInner<'a>) -> ServerNameName<'a> {
+        match m {
+            Either::Left(m) => ServerNameName::HostName(m),
+            Either::Right(m) => ServerNameName::Unrecognized(m),
+        }
     }
+    
 }
 
-pub struct KeyShareEntryMapper;
-impl View for KeyShareEntryMapper {
+
+pub struct ServerNameNameMapper;
+impl View for ServerNameNameMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for KeyShareEntryMapper {
-    type Src = SpecKeyShareEntryInner;
-    type Dst = SpecKeyShareEntry;
+impl SpecIso for ServerNameNameMapper {
+    type Src = SpecServerNameNameInner;
+    type Dst = SpecServerNameName;
 }
-impl SpecIsoProof for KeyShareEntryMapper {
+impl SpecIsoProof for ServerNameNameMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -10165,317 +9434,206 @@ impl SpecIsoProof for KeyShareEntryMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for KeyShareEntryMapper {
-    type Src = KeyShareEntryInner<'a>;
-    type Dst = KeyShareEntry<'a>;
-    type RefSrc = KeyShareEntryInnerRef<'a>;
+impl<'a> Iso<'a> for ServerNameNameMapper {
+    type Src = ServerNameNameInner<'a>;
+    type Dst = ServerNameName<'a>;
+    type RefSrc = ServerNameNameInnerRef<'a>;
 }
 
-pub struct SpecKeyShareEntryCombinator(pub SpecKeyShareEntryCombinatorAlias);
+type SpecServerNameNameCombinatorAlias1 = Choice<Cond<SpecHostNameCombinator>, Cond<SpecUnknownNameCombinator>>;
+pub struct SpecServerNameNameCombinator(pub SpecServerNameNameCombinatorAlias);
 
-impl SpecCombinator for SpecKeyShareEntryCombinator {
-    type Type = SpecKeyShareEntry;
+impl SpecCombinator for SpecServerNameNameCombinator {
+    type Type = SpecServerNameName;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecKeyShareEntryCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecKeyShareEntryCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecServerNameNameCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecServerNameNameCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecKeyShareEntryCombinatorAlias = Mapped<SpecPair<SpecPair<SpecNamedGroupCombinator, Refined<U16Be, Predicate16977634203518580913>>, bytes::Variable>, KeyShareEntryMapper>;
+pub type SpecServerNameNameCombinatorAlias = Mapped<SpecServerNameNameCombinatorAlias1, ServerNameNameMapper>;
+type ServerNameNameCombinatorAlias1 = Choice<Cond<HostNameCombinator>, Cond<UnknownNameCombinator>>;
+pub struct ServerNameNameCombinator1(pub ServerNameNameCombinatorAlias1);
+impl View for ServerNameNameCombinator1 {
+    type V = SpecServerNameNameCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ServerNameNameCombinator1, ServerNameNameCombinatorAlias1);
 
-pub struct KeyShareEntryCombinator(pub KeyShareEntryCombinatorAlias);
+pub struct ServerNameNameCombinator(pub ServerNameNameCombinatorAlias);
 
-impl View for KeyShareEntryCombinator {
-    type V = SpecKeyShareEntryCombinator;
-    open spec fn view(&self) -> Self::V { SpecKeyShareEntryCombinator(self.0@) }
+impl View for ServerNameNameCombinator {
+    type V = SpecServerNameNameCombinator;
+    open spec fn view(&self) -> Self::V { SpecServerNameNameCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for KeyShareEntryCombinator {
-    type Type = KeyShareEntry<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerNameNameCombinator {
+    type Type = ServerNameName<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type KeyShareEntryCombinatorAlias = Mapped<Pair<Pair<NamedGroupCombinator, Refined<U16Be, Predicate16977634203518580913>, KeyShareEntryCont1>, bytes::Variable, KeyShareEntryCont0>, KeyShareEntryMapper>;
-
-
-pub open spec fn spec_key_share_entry() -> SpecKeyShareEntryCombinator {
-    SpecKeyShareEntryCombinator(
-    Mapped {
-        inner: Pair::spec_new(Pair::spec_new(spec_named_group(), |deps| spec_key_share_entry_cont1(deps)), |deps| spec_key_share_entry_cont0(deps)),
-        mapper: KeyShareEntryMapper,
-    })
-}
-
-pub open spec fn spec_key_share_entry_cont1(deps: u16) -> Refined<U16Be, Predicate16977634203518580913> {
-    let group = deps;
-    Refined { inner: U16Be, predicate: Predicate16977634203518580913 }
 }
+pub type ServerNameNameCombinatorAlias = Mapped<ServerNameNameCombinator1, ServerNameNameMapper>;
 
-impl View for KeyShareEntryCont1 {
-    type V = spec_fn(u16) -> Refined<U16Be, Predicate16977634203518580913>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_key_share_entry_cont1(deps)
-        }
-    }
-}
 
-pub open spec fn spec_key_share_entry_cont0(deps: (u16, u16)) -> bytes::Variable {
-    let (group, l) = deps;
-    bytes::Variable(l.spec_into())
+pub open spec fn spec_server_name_name(name_type: u8) -> SpecServerNameNameCombinator {
+    SpecServerNameNameCombinator(Mapped { inner: Choice(Cond { cond: name_type == NameType::SPEC_HostName, inner: spec_host_name() }, Cond { cond: !(name_type == NameType::SPEC_HostName), inner: spec_unknown_name() }), mapper: ServerNameNameMapper })
 }
 
-impl View for KeyShareEntryCont0 {
-    type V = spec_fn((u16, u16)) -> bytes::Variable;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: (u16, u16)| {
-            spec_key_share_entry_cont0(deps)
-        }
-    }
-}
+pub fn server_name_name<'a>(name_type: u8) -> (o: ServerNameNameCombinator)
+    requires
+        spec_name_type().wf(name_type@),
 
-                
-pub fn key_share_entry<'a>() -> (o: KeyShareEntryCombinator)
-    ensures o@ == spec_key_share_entry(),
+    ensures o@ == spec_server_name_name(name_type@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = KeyShareEntryCombinator(
-    Mapped {
-        inner: Pair::new(Pair::new(named_group(), KeyShareEntryCont1), KeyShareEntryCont0),
-        mapper: KeyShareEntryMapper,
-    });
-    assert({
-        &&& combinator@ == spec_key_share_entry()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ServerNameNameCombinator(Mapped { inner: ServerNameNameCombinator1(Choice::new(Cond { cond: name_type == NameType::HostName, inner: host_name() }, Cond { cond: !(name_type == NameType::HostName), inner: unknown_name() })), mapper: ServerNameNameMapper });
+    // assert({
+    //     &&& combinator@ == spec_server_name_name(name_type@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_key_share_entry<'a>(input: &'a [u8]) -> (res: PResult<<KeyShareEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_server_name_name<'a>(input: &'a [u8], name_type: u8) -> (res: PResult<<ServerNameNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_name_type().wf(name_type@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_key_share_entry().spec_parse(input@) == Some((n as int, v@)),
-        spec_key_share_entry().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_server_name_name(name_type@).spec_parse(input@) == Some((n as int, v@)),
+        spec_server_name_name(name_type@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_key_share_entry().spec_parse(input@) is None,
-        spec_key_share_entry().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_server_name_name(name_type@).spec_parse(input@) is None,
+        spec_server_name_name(name_type@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = key_share_entry();
+    let combinator = server_name_name( name_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_key_share_entry<'a>(v: <KeyShareEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_server_name_name<'a>(v: <ServerNameNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, name_type: u8) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_key_share_entry().wf(v@),
+        spec_server_name_name(name_type@).wf(v@),
+        spec_name_type().wf(name_type@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_key_share_entry().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_key_share_entry().spec_serialize(v@))
+            &&& n == spec_server_name_name(name_type@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_server_name_name(name_type@).spec_serialize(v@))
         },
 {
-    let combinator = key_share_entry();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = server_name_name( name_type );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn key_share_entry_len<'a>(v: <KeyShareEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn server_name_name_len<'a>(v: <ServerNameNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, name_type: u8) -> (serialize_len: usize)
     requires
-        spec_key_share_entry().wf(v@),
-        spec_key_share_entry().spec_serialize(v@).len() <= usize::MAX,
+        spec_server_name_name(name_type@).wf(v@),
+        spec_server_name_name(name_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_name_type().wf(name_type@),
+
     ensures
-        serialize_len == spec_key_share_entry().spec_serialize(v@).len(),
+        serialize_len == spec_server_name_name(name_type@).spec_serialize(v@).len(),
 {
-    let combinator = key_share_entry();
+    let combinator = server_name_name( name_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct KeyShareEntryCont1;
-type KeyShareEntryCont1Type<'a, 'b> = &'b u16;
-type KeyShareEntryCont1SType<'a, 'x> = &'x u16;
-type KeyShareEntryCont1Input<'a, 'b, 'x> = POrSType<KeyShareEntryCont1Type<'a, 'b>, KeyShareEntryCont1SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<KeyShareEntryCont1Input<'a, 'b, 'x>> for KeyShareEntryCont1 {
-    type Output = Refined<U16Be, Predicate16977634203518580913>;
-
-    open spec fn requires(&self, deps: KeyShareEntryCont1Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: KeyShareEntryCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_key_share_entry_cont1(deps@)
-    }
-
-    fn apply(&self, deps: KeyShareEntryCont1Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let group = *deps;
-                Refined { inner: U16Be, predicate: Predicate16977634203518580913 }
-            }
-            POrSType::S(deps) => {
-                let group = deps;
-                let group = *group;
-                Refined { inner: U16Be, predicate: Predicate16977634203518580913 }
-            }
-        }
-    }
-}
-pub struct KeyShareEntryCont0;
-type KeyShareEntryCont0Type<'a, 'b> = &'b (u16, u16);
-type KeyShareEntryCont0SType<'a, 'x> = (&'x u16, &'x u16);
-type KeyShareEntryCont0Input<'a, 'b, 'x> = POrSType<KeyShareEntryCont0Type<'a, 'b>, KeyShareEntryCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<KeyShareEntryCont0Input<'a, 'b, 'x>> for KeyShareEntryCont0 {
-    type Output = bytes::Variable;
-
-    open spec fn requires(&self, deps: KeyShareEntryCont0Input<'a, 'b, 'x>) -> bool { true }
 
-    open spec fn ensures(&self, deps: KeyShareEntryCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_key_share_entry_cont0(deps@)
-    }
-
-    fn apply(&self, deps: KeyShareEntryCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let (group, l) = *deps;
-                bytes::Variable(l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let (group, l) = deps;
-                let (group, l) = (*group, *l);
-                bytes::Variable(l.ex_into())
-            }
-        }
-    }
+pub struct SpecServerName {
+    pub name_type: u8,
+    pub name: SpecServerNameName,
 }
-                
 
-pub enum SpecSeverHelloExtensionExtensionData {
-    PreSharedKey(SpecPreSharedKeyServerExtension),
-    SupportedVersions(u16),
-    KeyShare(SpecKeyShareEntry),
-    Unrecognized(Seq<u8>),
-}
+pub type SpecServerNameInner = (u8, SpecServerNameName);
 
-pub type SpecSeverHelloExtensionExtensionDataInner = Either<SpecPreSharedKeyServerExtension, Either<u16, Either<SpecKeyShareEntry, Seq<u8>>>>;
 
-impl SpecFrom<SpecSeverHelloExtensionExtensionData> for SpecSeverHelloExtensionExtensionDataInner {
-    open spec fn spec_from(m: SpecSeverHelloExtensionExtensionData) -> SpecSeverHelloExtensionExtensionDataInner {
-        match m {
-            SpecSeverHelloExtensionExtensionData::PreSharedKey(m) => Either::Left(m),
-            SpecSeverHelloExtensionExtensionData::SupportedVersions(m) => Either::Right(Either::Left(m)),
-            SpecSeverHelloExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecSeverHelloExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(m))),
-        }
+impl SpecFrom<SpecServerName> for SpecServerNameInner {
+    open spec fn spec_from(m: SpecServerName) -> SpecServerNameInner {
+        (m.name_type, m.name)
     }
-
 }
 
-                
-impl SpecFrom<SpecSeverHelloExtensionExtensionDataInner> for SpecSeverHelloExtensionExtensionData {
-    open spec fn spec_from(m: SpecSeverHelloExtensionExtensionDataInner) -> SpecSeverHelloExtensionExtensionData {
-        match m {
-            Either::Left(m) => SpecSeverHelloExtensionExtensionData::PreSharedKey(m),
-            Either::Right(Either::Left(m)) => SpecSeverHelloExtensionExtensionData::SupportedVersions(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecSeverHelloExtensionExtensionData::KeyShare(m),
-            Either::Right(Either::Right(Either::Right(m))) => SpecSeverHelloExtensionExtensionData::Unrecognized(m),
-        }
+impl SpecFrom<SpecServerNameInner> for SpecServerName {
+    open spec fn spec_from(m: SpecServerNameInner) -> SpecServerName {
+        let (name_type, name) = m;
+        SpecServerName { name_type, name }
     }
-
 }
-
-
-
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum SeverHelloExtensionExtensionData<'a> {
-    PreSharedKey(PreSharedKeyServerExtension),
-    SupportedVersions(u16),
-    KeyShare(KeyShareEntry<'a>),
-    Unrecognized(&'a [u8]),
-}
-
-pub type SeverHelloExtensionExtensionDataInner<'a> = Either<PreSharedKeyServerExtension, Either<u16, Either<KeyShareEntry<'a>, &'a [u8]>>>;
 
-pub type SeverHelloExtensionExtensionDataInnerRef<'a> = Either<&'a PreSharedKeyServerExtension, Either<&'a u16, Either<&'a KeyShareEntry<'a>, &'a &'a [u8]>>>;
+pub struct ServerName<'a> {
+    pub name_type: u8,
+    pub name: ServerNameName<'a>,
+}
 
+impl View for ServerName<'_> {
+    type V = SpecServerName;
 
-impl<'a> View for SeverHelloExtensionExtensionData<'a> {
-    type V = SpecSeverHelloExtensionExtensionData;
     open spec fn view(&self) -> Self::V {
-        match self {
-            SeverHelloExtensionExtensionData::PreSharedKey(m) => SpecSeverHelloExtensionExtensionData::PreSharedKey(m@),
-            SeverHelloExtensionExtensionData::SupportedVersions(m) => SpecSeverHelloExtensionExtensionData::SupportedVersions(m@),
-            SeverHelloExtensionExtensionData::KeyShare(m) => SpecSeverHelloExtensionExtensionData::KeyShare(m@),
-            SeverHelloExtensionExtensionData::Unrecognized(m) => SpecSeverHelloExtensionExtensionData::Unrecognized(m@),
+        SpecServerName {
+            name_type: self.name_type@,
+            name: self.name@,
         }
     }
 }
+pub type ServerNameInner<'a> = (u8, ServerNameName<'a>);
 
-
-impl<'a> From<&'a SeverHelloExtensionExtensionData<'a>> for SeverHelloExtensionExtensionDataInnerRef<'a> {
-    fn ex_from(m: &'a SeverHelloExtensionExtensionData<'a>) -> SeverHelloExtensionExtensionDataInnerRef<'a> {
-        match m {
-            SeverHelloExtensionExtensionData::PreSharedKey(m) => Either::Left(m),
-            SeverHelloExtensionExtensionData::SupportedVersions(m) => Either::Right(Either::Left(m)),
-            SeverHelloExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Left(m))),
-            SeverHelloExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(m))),
-        }
+pub type ServerNameInnerRef<'a> = (&'a u8, &'a ServerNameName<'a>);
+impl<'a> From<&'a ServerName<'a>> for ServerNameInnerRef<'a> {
+    fn ex_from(m: &'a ServerName) -> ServerNameInnerRef<'a> {
+        (&m.name_type, &m.name)
     }
-
 }
 
-impl<'a> From<SeverHelloExtensionExtensionDataInner<'a>> for SeverHelloExtensionExtensionData<'a> {
-    fn ex_from(m: SeverHelloExtensionExtensionDataInner<'a>) -> SeverHelloExtensionExtensionData<'a> {
-        match m {
-            Either::Left(m) => SeverHelloExtensionExtensionData::PreSharedKey(m),
-            Either::Right(Either::Left(m)) => SeverHelloExtensionExtensionData::SupportedVersions(m),
-            Either::Right(Either::Right(Either::Left(m))) => SeverHelloExtensionExtensionData::KeyShare(m),
-            Either::Right(Either::Right(Either::Right(m))) => SeverHelloExtensionExtensionData::Unrecognized(m),
-        }
+impl<'a> From<ServerNameInner<'a>> for ServerName<'a> {
+    fn ex_from(m: ServerNameInner) -> ServerName {
+        let (name_type, name) = m;
+        ServerName { name_type, name }
     }
-    
 }
 
-
-pub struct SeverHelloExtensionExtensionDataMapper;
-impl View for SeverHelloExtensionExtensionDataMapper {
+pub struct ServerNameMapper;
+impl View for ServerNameMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for SeverHelloExtensionExtensionDataMapper {
-    type Src = SpecSeverHelloExtensionExtensionDataInner;
-    type Dst = SpecSeverHelloExtensionExtensionData;
+impl SpecIso for ServerNameMapper {
+    type Src = SpecServerNameInner;
+    type Dst = SpecServerName;
 }
-impl SpecIsoProof for SeverHelloExtensionExtensionDataMapper {
+impl SpecIsoProof for ServerNameMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -10483,218 +9641,245 @@ impl SpecIsoProof for SeverHelloExtensionExtensionDataMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for SeverHelloExtensionExtensionDataMapper {
-    type Src = SeverHelloExtensionExtensionDataInner<'a>;
-    type Dst = SeverHelloExtensionExtensionData<'a>;
-    type RefSrc = SeverHelloExtensionExtensionDataInnerRef<'a>;
+impl<'a> Iso<'a> for ServerNameMapper {
+    type Src = ServerNameInner<'a>;
+    type Dst = ServerName<'a>;
+    type RefSrc = ServerNameInnerRef<'a>;
 }
 
-type SpecSeverHelloExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecKeyShareEntryCombinator>, Cond<bytes::Variable>>;
-type SpecSeverHelloExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecSupportedVersionsServerCombinator>, SpecSeverHelloExtensionExtensionDataCombinatorAlias1>;
-type SpecSeverHelloExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SpecPreSharedKeyServerExtensionCombinator>, SpecSeverHelloExtensionExtensionDataCombinatorAlias2>;
-pub struct SpecSeverHelloExtensionExtensionDataCombinator(pub SpecSeverHelloExtensionExtensionDataCombinatorAlias);
+pub struct SpecServerNameCombinator(pub SpecServerNameCombinatorAlias);
 
-impl SpecCombinator for SpecSeverHelloExtensionExtensionDataCombinator {
-    type Type = SpecSeverHelloExtensionExtensionData;
+impl SpecCombinator for SpecServerNameCombinator {
+    type Type = SpecServerName;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecSeverHelloExtensionExtensionDataCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSeverHelloExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecServerNameCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecServerNameCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecSeverHelloExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecSeverHelloExtensionExtensionDataCombinatorAlias3, SeverHelloExtensionExtensionDataMapper>>;
-type SeverHelloExtensionExtensionDataCombinatorAlias1 = Choice<Cond<KeyShareEntryCombinator>, Cond<bytes::Variable>>;
-type SeverHelloExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SupportedVersionsServerCombinator>, SeverHelloExtensionExtensionDataCombinator1>;
-type SeverHelloExtensionExtensionDataCombinatorAlias3 = Choice<Cond<PreSharedKeyServerExtensionCombinator>, SeverHelloExtensionExtensionDataCombinator2>;
-pub struct SeverHelloExtensionExtensionDataCombinator1(pub SeverHelloExtensionExtensionDataCombinatorAlias1);
-impl View for SeverHelloExtensionExtensionDataCombinator1 {
-    type V = SpecSeverHelloExtensionExtensionDataCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(SeverHelloExtensionExtensionDataCombinator1, SeverHelloExtensionExtensionDataCombinatorAlias1);
-
-pub struct SeverHelloExtensionExtensionDataCombinator2(pub SeverHelloExtensionExtensionDataCombinatorAlias2);
-impl View for SeverHelloExtensionExtensionDataCombinator2 {
-    type V = SpecSeverHelloExtensionExtensionDataCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(SeverHelloExtensionExtensionDataCombinator2, SeverHelloExtensionExtensionDataCombinatorAlias2);
-
-pub struct SeverHelloExtensionExtensionDataCombinator3(pub SeverHelloExtensionExtensionDataCombinatorAlias3);
-impl View for SeverHelloExtensionExtensionDataCombinator3 {
-    type V = SpecSeverHelloExtensionExtensionDataCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(SeverHelloExtensionExtensionDataCombinator3, SeverHelloExtensionExtensionDataCombinatorAlias3);
+pub type SpecServerNameCombinatorAlias = Mapped<SpecPair<SpecNameTypeCombinator, SpecServerNameNameCombinator>, ServerNameMapper>;
 
-pub struct SeverHelloExtensionExtensionDataCombinator(pub SeverHelloExtensionExtensionDataCombinatorAlias);
+pub struct ServerNameCombinator(pub ServerNameCombinatorAlias);
 
-impl View for SeverHelloExtensionExtensionDataCombinator {
-    type V = SpecSeverHelloExtensionExtensionDataCombinator;
-    open spec fn view(&self) -> Self::V { SpecSeverHelloExtensionExtensionDataCombinator(self.0@) }
+impl View for ServerNameCombinator {
+    type V = SpecServerNameCombinator;
+    open spec fn view(&self) -> Self::V { SpecServerNameCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SeverHelloExtensionExtensionDataCombinator {
-    type Type = SeverHelloExtensionExtensionData<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerNameCombinator {
+    type Type = ServerName<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SeverHelloExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SeverHelloExtensionExtensionDataCombinator3, SeverHelloExtensionExtensionDataMapper>>;
+}
+pub type ServerNameCombinatorAlias = Mapped<Pair<NameTypeCombinator, ServerNameNameCombinator, ServerNameCont0>, ServerNameMapper>;
+
+
+pub open spec fn spec_server_name() -> SpecServerNameCombinator {
+    SpecServerNameCombinator(
+    Mapped {
+        inner: Pair::spec_new(spec_name_type(), |deps| spec_server_name_cont0(deps)),
+        mapper: ServerNameMapper,
+    })
+}
+
+pub open spec fn spec_server_name_cont0(deps: u8) -> SpecServerNameNameCombinator {
+    let name_type = deps;
+    spec_server_name_name(name_type)
+}
 
+impl View for ServerNameCont0 {
+    type V = spec_fn(u8) -> SpecServerNameNameCombinator;
 
-pub open spec fn spec_sever_hello_extension_extension_data(extension_type: u16, ext_len: u16) -> SpecSeverHelloExtensionExtensionDataCombinator {
-    SpecSeverHelloExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.spec_into()), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_PreSharedKey, inner: spec_pre_shared_key_server_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SupportedVersions, inner: spec_supported_versions_server() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_KeyShare, inner: spec_key_share_entry() }, Cond { cond: !(extension_type == ExtensionType::SPEC_PreSharedKey || extension_type == ExtensionType::SPEC_SupportedVersions || extension_type == ExtensionType::SPEC_KeyShare), inner: bytes::Variable(ext_len.spec_into()) }))), mapper: SeverHelloExtensionExtensionDataMapper }))
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_server_name_cont0(deps)
+        }
+    }
 }
 
-pub fn sever_hello_extension_extension_data<'a>(extension_type: u16, ext_len: u16) -> (o: SeverHelloExtensionExtensionDataCombinator)
-    ensures o@ == spec_sever_hello_extension_extension_data(extension_type@, ext_len@),
+                
+pub fn server_name<'a>() -> (o: ServerNameCombinator)
+    ensures o@ == spec_server_name(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = SeverHelloExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.ex_into()), Mapped { inner: SeverHelloExtensionExtensionDataCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::PreSharedKey, inner: pre_shared_key_server_extension() }, SeverHelloExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::SupportedVersions, inner: supported_versions_server() }, SeverHelloExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::KeyShare, inner: key_share_entry() }, Cond { cond: !(extension_type == ExtensionType::PreSharedKey || extension_type == ExtensionType::SupportedVersions || extension_type == ExtensionType::KeyShare), inner: bytes::Variable(ext_len.ex_into()) })))))), mapper: SeverHelloExtensionExtensionDataMapper }));
-    assert({
-        &&& combinator@ == spec_sever_hello_extension_extension_data(extension_type@, ext_len@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ServerNameCombinator(
+    Mapped {
+        inner: Pair::new(name_type(), ServerNameCont0),
+        mapper: ServerNameMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_server_name()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_sever_hello_extension_extension_data<'a>(input: &'a [u8], extension_type: u16, ext_len: u16) -> (res: PResult<<SeverHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_server_name<'a>(input: &'a [u8]) -> (res: PResult<<ServerNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_sever_hello_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) == Some((n as int, v@)),
-        spec_sever_hello_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_server_name().spec_parse(input@) == Some((n as int, v@)),
+        spec_server_name().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_sever_hello_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None,
-        spec_sever_hello_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_server_name().spec_parse(input@) is None,
+        spec_server_name().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = sever_hello_extension_extension_data( extension_type, ext_len );
+    let combinator = server_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_sever_hello_extension_extension_data<'a>(v: <SeverHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, extension_type: u16, ext_len: u16) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_server_name<'a>(v: <ServerNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_sever_hello_extension_extension_data(extension_type@, ext_len@).wf(v@),
+        spec_server_name().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_sever_hello_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_sever_hello_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@))
+            &&& n == spec_server_name().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_server_name().spec_serialize(v@))
         },
 {
-    let combinator = sever_hello_extension_extension_data( extension_type, ext_len );
-    combinator.serialize(v, data, pos)
+    let combinator = server_name();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn sever_hello_extension_extension_data_len<'a>(v: <SeverHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, extension_type: u16, ext_len: u16) -> (serialize_len: usize)
+pub fn server_name_len<'a>(v: <ServerNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_sever_hello_extension_extension_data(extension_type@, ext_len@).wf(v@),
-        spec_sever_hello_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len() <= usize::MAX,
+        spec_server_name().wf(v@),
+        spec_server_name().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_sever_hello_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len(),
+        serialize_len == spec_server_name().spec_serialize(v@).len(),
 {
-    let combinator = sever_hello_extension_extension_data( extension_type, ext_len );
+    let combinator = server_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct ServerNameCont0;
+type ServerNameCont0Type<'a, 'b> = &'b u8;
+type ServerNameCont0SType<'a, 'x> = &'x u8;
+type ServerNameCont0Input<'a, 'b, 'x> = POrSType<ServerNameCont0Type<'a, 'b>, ServerNameCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ServerNameCont0Input<'a, 'b, 'x>> for ServerNameCont0 {
+    type Output = ServerNameNameCombinator;
+
+    open spec fn requires(&self, deps: ServerNameCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_name_type()).wf(deps@)
+        }
 
-pub struct SpecSeverHelloExtension {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: SpecSeverHelloExtensionExtensionData,
+    open spec fn ensures(&self, deps: ServerNameCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_server_name_cont0(deps@)
+    }
+
+    fn apply(&self, deps: ServerNameCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let name_type = deps;
+                let name_type = *name_type;
+                server_name_name(name_type)
+            }
+            POrSType::S(deps) => {
+                let name_type = deps;
+                let name_type = *name_type;
+                server_name_name(name_type)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecServerNameList {
+    pub l: u16,
+    pub list: Seq<SpecServerName>,
 }
 
-pub type SpecSeverHelloExtensionInner = ((u16, u16), SpecSeverHelloExtensionExtensionData);
+pub type SpecServerNameListInner = (u16, Seq<SpecServerName>);
 
 
-impl SpecFrom<SpecSeverHelloExtension> for SpecSeverHelloExtensionInner {
-    open spec fn spec_from(m: SpecSeverHelloExtension) -> SpecSeverHelloExtensionInner {
-        ((m.extension_type, m.ext_len), m.extension_data)
+impl SpecFrom<SpecServerNameList> for SpecServerNameListInner {
+    open spec fn spec_from(m: SpecServerNameList) -> SpecServerNameListInner {
+        (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecSeverHelloExtensionInner> for SpecSeverHelloExtension {
-    open spec fn spec_from(m: SpecSeverHelloExtensionInner) -> SpecSeverHelloExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        SpecSeverHelloExtension { extension_type, ext_len, extension_data }
+impl SpecFrom<SpecServerNameListInner> for SpecServerNameList {
+    open spec fn spec_from(m: SpecServerNameListInner) -> SpecServerNameList {
+        let (l, list) = m;
+        SpecServerNameList { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct SeverHelloExtension<'a> {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: SeverHelloExtensionExtensionData<'a>,
+pub struct ServerNameList<'a> {
+    pub l: u16,
+    pub list: RepeatResult<ServerName<'a>>,
 }
 
-impl View for SeverHelloExtension<'_> {
-    type V = SpecSeverHelloExtension;
+impl View for ServerNameList<'_> {
+    type V = SpecServerNameList;
 
     open spec fn view(&self) -> Self::V {
-        SpecSeverHelloExtension {
-            extension_type: self.extension_type@,
-            ext_len: self.ext_len@,
-            extension_data: self.extension_data@,
+        SpecServerNameList {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
-pub type SeverHelloExtensionInner<'a> = ((u16, u16), SeverHelloExtensionExtensionData<'a>);
+pub type ServerNameListInner<'a> = (u16, RepeatResult<ServerName<'a>>);
 
-pub type SeverHelloExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a SeverHelloExtensionExtensionData<'a>);
-impl<'a> From<&'a SeverHelloExtension<'a>> for SeverHelloExtensionInnerRef<'a> {
-    fn ex_from(m: &'a SeverHelloExtension) -> SeverHelloExtensionInnerRef<'a> {
-        ((&m.extension_type, &m.ext_len), &m.extension_data)
+pub type ServerNameListInnerRef<'a> = (&'a u16, &'a RepeatResult<ServerName<'a>>);
+impl<'a> From<&'a ServerNameList<'a>> for ServerNameListInnerRef<'a> {
+    fn ex_from(m: &'a ServerNameList) -> ServerNameListInnerRef<'a> {
+        (&m.l, &m.list)
     }
 }
 
-impl<'a> From<SeverHelloExtensionInner<'a>> for SeverHelloExtension<'a> {
-    fn ex_from(m: SeverHelloExtensionInner) -> SeverHelloExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        SeverHelloExtension { extension_type, ext_len, extension_data }
+impl<'a> From<ServerNameListInner<'a>> for ServerNameList<'a> {
+    fn ex_from(m: ServerNameListInner) -> ServerNameList {
+        let (l, list) = m;
+        ServerNameList { l, list }
     }
 }
 
-pub struct SeverHelloExtensionMapper;
-impl View for SeverHelloExtensionMapper {
+pub struct ServerNameListMapper;
+impl View for ServerNameListMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for SeverHelloExtensionMapper {
-    type Src = SpecSeverHelloExtensionInner;
-    type Dst = SpecSeverHelloExtension;
+impl SpecIso for ServerNameListMapper {
+    type Src = SpecServerNameListInner;
+    type Dst = SpecServerNameList;
 }
-impl SpecIsoProof for SeverHelloExtensionMapper {
+impl SpecIsoProof for ServerNameListMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -10702,283 +9887,245 @@ impl SpecIsoProof for SeverHelloExtensionMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for SeverHelloExtensionMapper {
-    type Src = SeverHelloExtensionInner<'a>;
-    type Dst = SeverHelloExtension<'a>;
-    type RefSrc = SeverHelloExtensionInnerRef<'a>;
+impl<'a> Iso<'a> for ServerNameListMapper {
+    type Src = ServerNameListInner<'a>;
+    type Dst = ServerNameList<'a>;
+    type RefSrc = ServerNameListInnerRef<'a>;
 }
 
-pub struct SpecSeverHelloExtensionCombinator(pub SpecSeverHelloExtensionCombinatorAlias);
+pub struct SpecServerNameListCombinator(pub SpecServerNameListCombinatorAlias);
 
-impl SpecCombinator for SpecSeverHelloExtensionCombinator {
-    type Type = SpecSeverHelloExtension;
+impl SpecCombinator for SpecServerNameListCombinator {
+    type Type = SpecServerNameList;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecSeverHelloExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSeverHelloExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecServerNameListCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecServerNameListCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecSeverHelloExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecSeverHelloExtensionExtensionDataCombinator>, SeverHelloExtensionMapper>;
+pub type SpecServerNameListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate16977634203518580913>, AndThen<bytes::Variable, Repeat<SpecServerNameCombinator>>>, ServerNameListMapper>;
 
-pub struct SeverHelloExtensionCombinator(pub SeverHelloExtensionCombinatorAlias);
+pub struct ServerNameListCombinator(pub ServerNameListCombinatorAlias);
 
-impl View for SeverHelloExtensionCombinator {
-    type V = SpecSeverHelloExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecSeverHelloExtensionCombinator(self.0@) }
+impl View for ServerNameListCombinator {
+    type V = SpecServerNameListCombinator;
+    open spec fn view(&self) -> Self::V { SpecServerNameListCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SeverHelloExtensionCombinator {
-    type Type = SeverHelloExtension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerNameListCombinator {
+    type Type = ServerNameList<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SeverHelloExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, SeverHelloExtensionCont1>, SeverHelloExtensionExtensionDataCombinator, SeverHelloExtensionCont0>, SeverHelloExtensionMapper>;
+}
+pub type ServerNameListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate16977634203518580913>, AndThen<bytes::Variable, Repeat<ServerNameCombinator>>, ServerNameListCont0>, ServerNameListMapper>;
 
 
-pub open spec fn spec_sever_hello_extension() -> SpecSeverHelloExtensionCombinator {
-    SpecSeverHelloExtensionCombinator(
+pub open spec fn spec_server_name_list() -> SpecServerNameListCombinator {
+    SpecServerNameListCombinator(
     Mapped {
-        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_sever_hello_extension_cont1(deps)), |deps| spec_sever_hello_extension_cont0(deps)),
-        mapper: SeverHelloExtensionMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate16977634203518580913 }, |deps| spec_server_name_list_cont0(deps)),
+        mapper: ServerNameListMapper,
     })
 }
 
-pub open spec fn spec_sever_hello_extension_cont1(deps: u16) -> U16Be {
-    let extension_type = deps;
-    U16Be
+pub open spec fn spec_server_name_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecServerNameCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_server_name()))
 }
 
-impl View for SeverHelloExtensionCont1 {
-    type V = spec_fn(u16) -> U16Be;
+impl View for ServerNameListCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecServerNameCombinator>>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u16| {
-            spec_sever_hello_extension_cont1(deps)
-        }
-    }
-}
-
-pub open spec fn spec_sever_hello_extension_cont0(deps: (u16, u16)) -> SpecSeverHelloExtensionExtensionDataCombinator {
-    let (extension_type, ext_len) = deps;
-    spec_sever_hello_extension_extension_data(extension_type, ext_len)
-}
-
-impl View for SeverHelloExtensionCont0 {
-    type V = spec_fn((u16, u16)) -> SpecSeverHelloExtensionExtensionDataCombinator;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: (u16, u16)| {
-            spec_sever_hello_extension_cont0(deps)
+            spec_server_name_list_cont0(deps)
         }
     }
 }
 
                 
-pub fn sever_hello_extension<'a>() -> (o: SeverHelloExtensionCombinator)
-    ensures o@ == spec_sever_hello_extension(),
+pub fn server_name_list<'a>() -> (o: ServerNameListCombinator)
+    ensures o@ == spec_server_name_list(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = SeverHelloExtensionCombinator(
+    let combinator = ServerNameListCombinator(
     Mapped {
-        inner: Pair::new(Pair::new(extension_type(), SeverHelloExtensionCont1), SeverHelloExtensionCont0),
-        mapper: SeverHelloExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_sever_hello_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate16977634203518580913 }, ServerNameListCont0),
+        mapper: ServerNameListMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_server_name_list()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_sever_hello_extension<'a>(input: &'a [u8]) -> (res: PResult<<SeverHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_server_name_list<'a>(input: &'a [u8]) -> (res: PResult<<ServerNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_sever_hello_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_sever_hello_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_server_name_list().spec_parse(input@) == Some((n as int, v@)),
+        spec_server_name_list().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_sever_hello_extension().spec_parse(input@) is None,
-        spec_sever_hello_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_server_name_list().spec_parse(input@) is None,
+        spec_server_name_list().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = sever_hello_extension();
+    let combinator = server_name_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_sever_hello_extension<'a>(v: <SeverHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_server_name_list<'a>(v: <ServerNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_sever_hello_extension().wf(v@),
+        spec_server_name_list().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_sever_hello_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_sever_hello_extension().spec_serialize(v@))
+            &&& n == spec_server_name_list().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_server_name_list().spec_serialize(v@))
         },
 {
-    let combinator = sever_hello_extension();
+    let combinator = server_name_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn sever_hello_extension_len<'a>(v: <SeverHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn server_name_list_len<'a>(v: <ServerNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_sever_hello_extension().wf(v@),
-        spec_sever_hello_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_server_name_list().wf(v@),
+        spec_server_name_list().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_sever_hello_extension().spec_serialize(v@).len(),
+        serialize_len == spec_server_name_list().spec_serialize(v@).len(),
 {
-    let combinator = sever_hello_extension();
+    let combinator = server_name_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct SeverHelloExtensionCont1;
-type SeverHelloExtensionCont1Type<'a, 'b> = &'b u16;
-type SeverHelloExtensionCont1SType<'a, 'x> = &'x u16;
-type SeverHelloExtensionCont1Input<'a, 'b, 'x> = POrSType<SeverHelloExtensionCont1Type<'a, 'b>, SeverHelloExtensionCont1SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<SeverHelloExtensionCont1Input<'a, 'b, 'x>> for SeverHelloExtensionCont1 {
-    type Output = U16Be;
-
-    open spec fn requires(&self, deps: SeverHelloExtensionCont1Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: SeverHelloExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_sever_hello_extension_cont1(deps@)
-    }
+pub struct ServerNameListCont0;
+type ServerNameListCont0Type<'a, 'b> = &'b u16;
+type ServerNameListCont0SType<'a, 'x> = &'x u16;
+type ServerNameListCont0Input<'a, 'b, 'x> = POrSType<ServerNameListCont0Type<'a, 'b>, ServerNameListCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ServerNameListCont0Input<'a, 'b, 'x>> for ServerNameListCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<ServerNameCombinator>>;
 
-    fn apply(&self, deps: SeverHelloExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let extension_type = *deps;
-                U16Be
-            }
-            POrSType::S(deps) => {
-                let extension_type = deps;
-                let extension_type = *extension_type;
-                U16Be
-            }
+    open spec fn requires(&self, deps: ServerNameListCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate16977634203518580913 }).wf(deps@)
         }
-    }
-}
-pub struct SeverHelloExtensionCont0;
-type SeverHelloExtensionCont0Type<'a, 'b> = &'b (u16, u16);
-type SeverHelloExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
-type SeverHelloExtensionCont0Input<'a, 'b, 'x> = POrSType<SeverHelloExtensionCont0Type<'a, 'b>, SeverHelloExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<SeverHelloExtensionCont0Input<'a, 'b, 'x>> for SeverHelloExtensionCont0 {
-    type Output = SeverHelloExtensionExtensionDataCombinator;
 
-    open spec fn requires(&self, deps: SeverHelloExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: SeverHelloExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_sever_hello_extension_cont0(deps@)
+    open spec fn ensures(&self, deps: ServerNameListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_server_name_list_cont0(deps@)
     }
 
-    fn apply(&self, deps: SeverHelloExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: ServerNameListCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let (extension_type, ext_len) = *deps;
-                sever_hello_extension_extension_data(extension_type, ext_len)
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(server_name()))
             }
             POrSType::S(deps) => {
-                let (extension_type, ext_len) = deps;
-                let (extension_type, ext_len) = (*extension_type, *ext_len);
-                sever_hello_extension_extension_data(extension_type, ext_len)
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(server_name()))
             }
         }
     }
 }
                 
 
-pub struct SpecServerExtensions {
+pub struct SpecNamedGroupList {
     pub l: u16,
-    pub list: Seq<SpecSeverHelloExtension>,
+    pub list: Seq<u16>,
 }
 
-pub type SpecServerExtensionsInner = (u16, Seq<SpecSeverHelloExtension>);
+pub type SpecNamedGroupListInner = (u16, Seq<u16>);
 
 
-impl SpecFrom<SpecServerExtensions> for SpecServerExtensionsInner {
-    open spec fn spec_from(m: SpecServerExtensions) -> SpecServerExtensionsInner {
+impl SpecFrom<SpecNamedGroupList> for SpecNamedGroupListInner {
+    open spec fn spec_from(m: SpecNamedGroupList) -> SpecNamedGroupListInner {
         (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecServerExtensionsInner> for SpecServerExtensions {
-    open spec fn spec_from(m: SpecServerExtensionsInner) -> SpecServerExtensions {
+impl SpecFrom<SpecNamedGroupListInner> for SpecNamedGroupList {
+    open spec fn spec_from(m: SpecNamedGroupListInner) -> SpecNamedGroupList {
         let (l, list) = m;
-        SpecServerExtensions { l, list }
+        SpecNamedGroupList { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ServerExtensions<'a> {
+pub struct NamedGroupList {
     pub l: u16,
-    pub list: RepeatResult<SeverHelloExtension<'a>>,
+    pub list: RepeatResult<u16>,
 }
 
-impl View for ServerExtensions<'_> {
-    type V = SpecServerExtensions;
+impl View for NamedGroupList {
+    type V = SpecNamedGroupList;
 
     open spec fn view(&self) -> Self::V {
-        SpecServerExtensions {
+        SpecNamedGroupList {
             l: self.l@,
             list: self.list@,
         }
     }
 }
-pub type ServerExtensionsInner<'a> = (u16, RepeatResult<SeverHelloExtension<'a>>);
+pub type NamedGroupListInner = (u16, RepeatResult<u16>);
 
-pub type ServerExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<SeverHelloExtension<'a>>);
-impl<'a> From<&'a ServerExtensions<'a>> for ServerExtensionsInnerRef<'a> {
-    fn ex_from(m: &'a ServerExtensions) -> ServerExtensionsInnerRef<'a> {
+pub type NamedGroupListInnerRef<'a> = (&'a u16, &'a RepeatResult<u16>);
+impl<'a> From<&'a NamedGroupList> for NamedGroupListInnerRef<'a> {
+    fn ex_from(m: &'a NamedGroupList) -> NamedGroupListInnerRef<'a> {
         (&m.l, &m.list)
     }
 }
 
-impl<'a> From<ServerExtensionsInner<'a>> for ServerExtensions<'a> {
-    fn ex_from(m: ServerExtensionsInner) -> ServerExtensions {
+impl From<NamedGroupListInner> for NamedGroupList {
+    fn ex_from(m: NamedGroupListInner) -> NamedGroupList {
         let (l, list) = m;
-        ServerExtensions { l, list }
+        NamedGroupList { l, list }
     }
 }
 
-pub struct ServerExtensionsMapper;
-impl View for ServerExtensionsMapper {
+pub struct NamedGroupListMapper;
+impl View for NamedGroupListMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ServerExtensionsMapper {
-    type Src = SpecServerExtensionsInner;
-    type Dst = SpecServerExtensions;
+impl SpecIso for NamedGroupListMapper {
+    type Src = SpecNamedGroupListInner;
+    type Dst = SpecNamedGroupList;
 }
-impl SpecIsoProof for ServerExtensionsMapper {
+impl SpecIsoProof for NamedGroupListMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -10986,493 +10133,383 @@ impl SpecIsoProof for ServerExtensionsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ServerExtensionsMapper {
-    type Src = ServerExtensionsInner<'a>;
-    type Dst = ServerExtensions<'a>;
-    type RefSrc = ServerExtensionsInnerRef<'a>;
+impl<'a> Iso<'a> for NamedGroupListMapper {
+    type Src = NamedGroupListInner;
+    type Dst = NamedGroupList;
+    type RefSrc = NamedGroupListInnerRef<'a>;
 }
 
-pub struct SpecServerExtensionsCombinator(pub SpecServerExtensionsCombinatorAlias);
+pub struct SpecNamedGroupListCombinator(pub SpecNamedGroupListCombinatorAlias);
 
-impl SpecCombinator for SpecServerExtensionsCombinator {
-    type Type = SpecServerExtensions;
+impl SpecCombinator for SpecNamedGroupListCombinator {
+    type Type = SpecNamedGroupList;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecServerExtensionsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecServerExtensionsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecNamedGroupListCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNamedGroupListCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecServerExtensionsCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate14496530480760116989>, AndThen<bytes::Variable, Repeat<SpecSeverHelloExtensionCombinator>>>, ServerExtensionsMapper>;
+pub type SpecNamedGroupListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<SpecNamedGroupCombinator>>>, NamedGroupListMapper>;
+pub struct Predicate8195707947578446211;
+impl View for Predicate8195707947578446211 {
+    type V = Self;
 
-pub struct ServerExtensionsCombinator(pub ServerExtensionsCombinatorAlias);
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate8195707947578446211 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 2 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate8195707947578446211 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 2 && i <= 65535)
+    }
+}
 
-impl View for ServerExtensionsCombinator {
-    type V = SpecServerExtensionsCombinator;
-    open spec fn view(&self) -> Self::V { SpecServerExtensionsCombinator(self.0@) }
+pub struct NamedGroupListCombinator(pub NamedGroupListCombinatorAlias);
+
+impl View for NamedGroupListCombinator {
+    type V = SpecNamedGroupListCombinator;
+    open spec fn view(&self) -> Self::V { SpecNamedGroupListCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerExtensionsCombinator {
-    type Type = ServerExtensions<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NamedGroupListCombinator {
+    type Type = NamedGroupList;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ServerExtensionsCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate14496530480760116989>, AndThen<bytes::Variable, Repeat<SeverHelloExtensionCombinator>>, ServerExtensionsCont0>, ServerExtensionsMapper>;
+}
+pub type NamedGroupListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<NamedGroupCombinator>>, NamedGroupListCont0>, NamedGroupListMapper>;
 
 
-pub open spec fn spec_server_extensions() -> SpecServerExtensionsCombinator {
-    SpecServerExtensionsCombinator(
+pub open spec fn spec_named_group_list() -> SpecNamedGroupListCombinator {
+    SpecNamedGroupListCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate14496530480760116989 }, |deps| spec_server_extensions_cont0(deps)),
-        mapper: ServerExtensionsMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, |deps| spec_named_group_list_cont0(deps)),
+        mapper: NamedGroupListMapper,
     })
 }
 
-pub open spec fn spec_server_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecSeverHelloExtensionCombinator>> {
+pub open spec fn spec_named_group_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecNamedGroupCombinator>> {
     let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_sever_hello_extension()))
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_named_group()))
 }
 
-impl View for ServerExtensionsCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecSeverHelloExtensionCombinator>>;
+impl View for NamedGroupListCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecNamedGroupCombinator>>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u16| {
-            spec_server_extensions_cont0(deps)
+            spec_named_group_list_cont0(deps)
         }
     }
 }
 
                 
-pub fn server_extensions<'a>() -> (o: ServerExtensionsCombinator)
-    ensures o@ == spec_server_extensions(),
+pub fn named_group_list<'a>() -> (o: NamedGroupListCombinator)
+    ensures o@ == spec_named_group_list(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ServerExtensionsCombinator(
+    let combinator = NamedGroupListCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate14496530480760116989 }, ServerExtensionsCont0),
-        mapper: ServerExtensionsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_server_extensions()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, NamedGroupListCont0),
+        mapper: NamedGroupListMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_named_group_list()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_server_extensions<'a>(input: &'a [u8]) -> (res: PResult<<ServerExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_named_group_list<'a>(input: &'a [u8]) -> (res: PResult<<NamedGroupListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_server_extensions().spec_parse(input@) == Some((n as int, v@)),
-        spec_server_extensions().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_named_group_list().spec_parse(input@) == Some((n as int, v@)),
+        spec_named_group_list().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_server_extensions().spec_parse(input@) is None,
-        spec_server_extensions().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_named_group_list().spec_parse(input@) is None,
+        spec_named_group_list().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = server_extensions();
+    let combinator = named_group_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_server_extensions<'a>(v: <ServerExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_named_group_list<'a>(v: <NamedGroupListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_server_extensions().wf(v@),
+        spec_named_group_list().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_server_extensions().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_server_extensions().spec_serialize(v@))
+            &&& n == spec_named_group_list().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_named_group_list().spec_serialize(v@))
         },
 {
-    let combinator = server_extensions();
+    let combinator = named_group_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn server_extensions_len<'a>(v: <ServerExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn named_group_list_len<'a>(v: <NamedGroupListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_server_extensions().wf(v@),
-        spec_server_extensions().spec_serialize(v@).len() <= usize::MAX,
+        spec_named_group_list().wf(v@),
+        spec_named_group_list().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_server_extensions().spec_serialize(v@).len(),
+        serialize_len == spec_named_group_list().spec_serialize(v@).len(),
 {
-    let combinator = server_extensions();
+    let combinator = named_group_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ServerExtensionsCont0;
-type ServerExtensionsCont0Type<'a, 'b> = &'b u16;
-type ServerExtensionsCont0SType<'a, 'x> = &'x u16;
-type ServerExtensionsCont0Input<'a, 'b, 'x> = POrSType<ServerExtensionsCont0Type<'a, 'b>, ServerExtensionsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ServerExtensionsCont0Input<'a, 'b, 'x>> for ServerExtensionsCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<SeverHelloExtensionCombinator>>;
+pub struct NamedGroupListCont0;
+type NamedGroupListCont0Type<'a, 'b> = &'b u16;
+type NamedGroupListCont0SType<'a, 'x> = &'x u16;
+type NamedGroupListCont0Input<'a, 'b, 'x> = POrSType<NamedGroupListCont0Type<'a, 'b>, NamedGroupListCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<NamedGroupListCont0Input<'a, 'b, 'x>> for NamedGroupListCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<NamedGroupCombinator>>;
 
-    open spec fn requires(&self, deps: ServerExtensionsCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: NamedGroupListCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate8195707947578446211 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: ServerExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_server_extensions_cont0(deps@)
+    open spec fn ensures(&self, deps: NamedGroupListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_named_group_list_cont0(deps@)
     }
 
-    fn apply(&self, deps: ServerExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: NamedGroupListCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(sever_hello_extension()))
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(named_group()))
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(sever_hello_extension()))
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(named_group()))
             }
         }
     }
 }
                 
+pub type SpecProtocolName = SpecOpaque1Ff;
+pub type ProtocolName<'a> = Opaque1Ff<'a>;
+pub type ProtocolNameRef<'a> = &'a Opaque1Ff<'a>;
 
-pub struct SpecServerHello {
-    pub legacy_session_id_echo: SpecSessionId,
-    pub cipher_suite: u16,
-    pub legacy_compression_method: u8,
-    pub extensions: SpecServerExtensions,
-}
-
-pub type SpecServerHelloInner = (SpecSessionId, (u16, (u8, SpecServerExtensions)));
-
-
-impl SpecFrom<SpecServerHello> for SpecServerHelloInner {
-    open spec fn spec_from(m: SpecServerHello) -> SpecServerHelloInner {
-        (m.legacy_session_id_echo, (m.cipher_suite, (m.legacy_compression_method, m.extensions)))
-    }
-}
-
-impl SpecFrom<SpecServerHelloInner> for SpecServerHello {
-    open spec fn spec_from(m: SpecServerHelloInner) -> SpecServerHello {
-        let (legacy_session_id_echo, (cipher_suite, (legacy_compression_method, extensions))) = m;
-        SpecServerHello { legacy_session_id_echo, cipher_suite, legacy_compression_method, extensions }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct ServerHello<'a> {
-    pub legacy_session_id_echo: SessionId<'a>,
-    pub cipher_suite: u16,
-    pub legacy_compression_method: u8,
-    pub extensions: ServerExtensions<'a>,
-}
-
-impl View for ServerHello<'_> {
-    type V = SpecServerHello;
-
-    open spec fn view(&self) -> Self::V {
-        SpecServerHello {
-            legacy_session_id_echo: self.legacy_session_id_echo@,
-            cipher_suite: self.cipher_suite@,
-            legacy_compression_method: self.legacy_compression_method@,
-            extensions: self.extensions@,
-        }
-    }
-}
-pub type ServerHelloInner<'a> = (SessionId<'a>, (u16, (u8, ServerExtensions<'a>)));
-
-pub type ServerHelloInnerRef<'a> = (&'a SessionId<'a>, (&'a u16, (&'a u8, &'a ServerExtensions<'a>)));
-impl<'a> From<&'a ServerHello<'a>> for ServerHelloInnerRef<'a> {
-    fn ex_from(m: &'a ServerHello) -> ServerHelloInnerRef<'a> {
-        (&m.legacy_session_id_echo, (&m.cipher_suite, (&m.legacy_compression_method, &m.extensions)))
-    }
-}
-
-impl<'a> From<ServerHelloInner<'a>> for ServerHello<'a> {
-    fn ex_from(m: ServerHelloInner) -> ServerHello {
-        let (legacy_session_id_echo, (cipher_suite, (legacy_compression_method, extensions))) = m;
-        ServerHello { legacy_session_id_echo, cipher_suite, legacy_compression_method, extensions }
-    }
-}
 
-pub struct ServerHelloMapper;
-impl View for ServerHelloMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ServerHelloMapper {
-    type Src = SpecServerHelloInner;
-    type Dst = SpecServerHello;
-}
-impl SpecIsoProof for ServerHelloMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for ServerHelloMapper {
-    type Src = ServerHelloInner<'a>;
-    type Dst = ServerHello<'a>;
-    type RefSrc = ServerHelloInnerRef<'a>;
-}
-pub const SERVERHELLOLEGACY_COMPRESSION_METHOD_CONST: u8 = 0;
-type SpecServerHelloCombinatorAlias1 = (Refined<U8, TagPred<u8>>, SpecServerExtensionsCombinator);
-type SpecServerHelloCombinatorAlias2 = (SpecCipherSuiteCombinator, SpecServerHelloCombinatorAlias1);
-type SpecServerHelloCombinatorAlias3 = (SpecSessionIdCombinator, SpecServerHelloCombinatorAlias2);
-pub struct SpecServerHelloCombinator(pub SpecServerHelloCombinatorAlias);
+pub struct SpecProtocolNameCombinator(pub SpecProtocolNameCombinatorAlias);
 
-impl SpecCombinator for SpecServerHelloCombinator {
-    type Type = SpecServerHello;
+impl SpecCombinator for SpecProtocolNameCombinator {
+    type Type = SpecProtocolName;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecServerHelloCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecServerHelloCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecProtocolNameCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecProtocolNameCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecServerHelloCombinatorAlias = Mapped<SpecServerHelloCombinatorAlias3, ServerHelloMapper>;
-type ServerHelloCombinatorAlias1 = (Refined<U8, TagPred<u8>>, ServerExtensionsCombinator);
-type ServerHelloCombinatorAlias2 = (CipherSuiteCombinator, ServerHelloCombinator1);
-type ServerHelloCombinatorAlias3 = (SessionIdCombinator, ServerHelloCombinator2);
-pub struct ServerHelloCombinator1(pub ServerHelloCombinatorAlias1);
-impl View for ServerHelloCombinator1 {
-    type V = SpecServerHelloCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ServerHelloCombinator1, ServerHelloCombinatorAlias1);
-
-pub struct ServerHelloCombinator2(pub ServerHelloCombinatorAlias2);
-impl View for ServerHelloCombinator2 {
-    type V = SpecServerHelloCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ServerHelloCombinator2, ServerHelloCombinatorAlias2);
-
-pub struct ServerHelloCombinator3(pub ServerHelloCombinatorAlias3);
-impl View for ServerHelloCombinator3 {
-    type V = SpecServerHelloCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ServerHelloCombinator3, ServerHelloCombinatorAlias3);
+pub type SpecProtocolNameCombinatorAlias = SpecOpaque1FfCombinator;
 
-pub struct ServerHelloCombinator(pub ServerHelloCombinatorAlias);
+pub struct ProtocolNameCombinator(pub ProtocolNameCombinatorAlias);
 
-impl View for ServerHelloCombinator {
-    type V = SpecServerHelloCombinator;
-    open spec fn view(&self) -> Self::V { SpecServerHelloCombinator(self.0@) }
+impl View for ProtocolNameCombinator {
+    type V = SpecProtocolNameCombinator;
+    open spec fn view(&self) -> Self::V { SpecProtocolNameCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerHelloCombinator {
-    type Type = ServerHello<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProtocolNameCombinator {
+    type Type = ProtocolName<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ServerHelloCombinatorAlias = Mapped<ServerHelloCombinator3, ServerHelloMapper>;
+}
+pub type ProtocolNameCombinatorAlias = Opaque1FfCombinator;
 
 
-pub open spec fn spec_server_hello() -> SpecServerHelloCombinator {
-    SpecServerHelloCombinator(
-    Mapped {
-        inner: (spec_session_id(), (spec_cipher_suite(), (Refined { inner: U8, predicate: TagPred(SERVERHELLOLEGACY_COMPRESSION_METHOD_CONST) }, spec_server_extensions()))),
-        mapper: ServerHelloMapper,
-    })
+pub open spec fn spec_protocol_name() -> SpecProtocolNameCombinator {
+    SpecProtocolNameCombinator(spec_opaque_1_ff())
 }
 
                 
-pub fn server_hello<'a>() -> (o: ServerHelloCombinator)
-    ensures o@ == spec_server_hello(),
+pub fn protocol_name<'a>() -> (o: ProtocolNameCombinator)
+    ensures o@ == spec_protocol_name(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ServerHelloCombinator(
-    Mapped {
-        inner: ServerHelloCombinator3((session_id(), ServerHelloCombinator2((cipher_suite(), ServerHelloCombinator1((Refined { inner: U8, predicate: TagPred(SERVERHELLOLEGACY_COMPRESSION_METHOD_CONST) }, server_extensions())))))),
-        mapper: ServerHelloMapper,
-    });
-    assert({
-        &&& combinator@ == spec_server_hello()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ProtocolNameCombinator(opaque_1_ff());
+    // assert({
+    //     &&& combinator@ == spec_protocol_name()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_server_hello<'a>(input: &'a [u8]) -> (res: PResult<<ServerHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_protocol_name<'a>(input: &'a [u8]) -> (res: PResult<<ProtocolNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_server_hello().spec_parse(input@) == Some((n as int, v@)),
-        spec_server_hello().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_protocol_name().spec_parse(input@) == Some((n as int, v@)),
+        spec_protocol_name().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_server_hello().spec_parse(input@) is None,
-        spec_server_hello().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_protocol_name().spec_parse(input@) is None,
+        spec_protocol_name().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = server_hello();
+    let combinator = protocol_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_server_hello<'a>(v: <ServerHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_protocol_name<'a>(v: <ProtocolNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_server_hello().wf(v@),
+        spec_protocol_name().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& 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@))
+            &&& n == spec_protocol_name().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_protocol_name().spec_serialize(v@))
         },
 {
-    let combinator = server_hello();
+    let combinator = protocol_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn server_hello_len<'a>(v: <ServerHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn protocol_name_len<'a>(v: <ProtocolNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_server_hello().wf(v@),
-        spec_server_hello().spec_serialize(v@).len() <= usize::MAX,
+        spec_protocol_name().wf(v@),
+        spec_protocol_name().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_server_hello().spec_serialize(v@).len(),
+        serialize_len == spec_protocol_name().spec_serialize(v@).len(),
 {
-    let combinator = server_hello();
+    let combinator = protocol_name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub enum SpecShOrHrrPayload {
-    Variant0(SpecHelloRetryRequest),
-    Variant1(SpecServerHello),
+pub struct SpecProtocolNameList {
+    pub l: u16,
+    pub list: Seq<SpecProtocolName>,
 }
 
-pub type SpecShOrHrrPayloadInner = Either<SpecHelloRetryRequest, SpecServerHello>;
+pub type SpecProtocolNameListInner = (u16, Seq<SpecProtocolName>);
 
-impl SpecFrom<SpecShOrHrrPayload> for SpecShOrHrrPayloadInner {
-    open spec fn spec_from(m: SpecShOrHrrPayload) -> SpecShOrHrrPayloadInner {
-        match m {
-            SpecShOrHrrPayload::Variant0(m) => Either::Left(m),
-            SpecShOrHrrPayload::Variant1(m) => Either::Right(m),
-        }
-    }
 
+impl SpecFrom<SpecProtocolNameList> for SpecProtocolNameListInner {
+    open spec fn spec_from(m: SpecProtocolNameList) -> SpecProtocolNameListInner {
+        (m.l, m.list)
+    }
 }
 
-                
-impl SpecFrom<SpecShOrHrrPayloadInner> for SpecShOrHrrPayload {
-    open spec fn spec_from(m: SpecShOrHrrPayloadInner) -> SpecShOrHrrPayload {
-        match m {
-            Either::Left(m) => SpecShOrHrrPayload::Variant0(m),
-            Either::Right(m) => SpecShOrHrrPayload::Variant1(m),
-        }
+impl SpecFrom<SpecProtocolNameListInner> for SpecProtocolNameList {
+    open spec fn spec_from(m: SpecProtocolNameListInner) -> SpecProtocolNameList {
+        let (l, list) = m;
+        SpecProtocolNameList { l, list }
     }
-
 }
-
-
-
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ShOrHrrPayload<'a> {
-    Variant0(HelloRetryRequest<'a>),
-    Variant1(ServerHello<'a>),
+
+pub struct ProtocolNameList<'a> {
+    pub l: u16,
+    pub list: RepeatResult<ProtocolName<'a>>,
 }
 
-pub type ShOrHrrPayloadInner<'a> = Either<HelloRetryRequest<'a>, ServerHello<'a>>;
-
-pub type ShOrHrrPayloadInnerRef<'a> = Either<&'a HelloRetryRequest<'a>, &'a ServerHello<'a>>;
-
+impl View for ProtocolNameList<'_> {
+    type V = SpecProtocolNameList;
 
-impl<'a> View for ShOrHrrPayload<'a> {
-    type V = SpecShOrHrrPayload;
     open spec fn view(&self) -> Self::V {
-        match self {
-            ShOrHrrPayload::Variant0(m) => SpecShOrHrrPayload::Variant0(m@),
-            ShOrHrrPayload::Variant1(m) => SpecShOrHrrPayload::Variant1(m@),
+        SpecProtocolNameList {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
+pub type ProtocolNameListInner<'a> = (u16, RepeatResult<ProtocolName<'a>>);
 
-
-impl<'a> From<&'a ShOrHrrPayload<'a>> for ShOrHrrPayloadInnerRef<'a> {
-    fn ex_from(m: &'a ShOrHrrPayload<'a>) -> ShOrHrrPayloadInnerRef<'a> {
-        match m {
-            ShOrHrrPayload::Variant0(m) => Either::Left(m),
-            ShOrHrrPayload::Variant1(m) => Either::Right(m),
-        }
+pub type ProtocolNameListInnerRef<'a> = (&'a u16, &'a RepeatResult<ProtocolName<'a>>);
+impl<'a> From<&'a ProtocolNameList<'a>> for ProtocolNameListInnerRef<'a> {
+    fn ex_from(m: &'a ProtocolNameList) -> ProtocolNameListInnerRef<'a> {
+        (&m.l, &m.list)
     }
-
 }
 
-impl<'a> From<ShOrHrrPayloadInner<'a>> for ShOrHrrPayload<'a> {
-    fn ex_from(m: ShOrHrrPayloadInner<'a>) -> ShOrHrrPayload<'a> {
-        match m {
-            Either::Left(m) => ShOrHrrPayload::Variant0(m),
-            Either::Right(m) => ShOrHrrPayload::Variant1(m),
-        }
+impl<'a> From<ProtocolNameListInner<'a>> for ProtocolNameList<'a> {
+    fn ex_from(m: ProtocolNameListInner) -> ProtocolNameList {
+        let (l, list) = m;
+        ProtocolNameList { l, list }
     }
-    
 }
 
-
-pub struct ShOrHrrPayloadMapper;
-impl View for ShOrHrrPayloadMapper {
+pub struct ProtocolNameListMapper;
+impl View for ProtocolNameListMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ShOrHrrPayloadMapper {
-    type Src = SpecShOrHrrPayloadInner;
-    type Dst = SpecShOrHrrPayload;
+impl SpecIso for ProtocolNameListMapper {
+    type Src = SpecProtocolNameListInner;
+    type Dst = SpecProtocolNameList;
 }
-impl SpecIsoProof for ShOrHrrPayloadMapper {
+impl SpecIsoProof for ProtocolNameListMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -11480,245 +10517,245 @@ impl SpecIsoProof for ShOrHrrPayloadMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ShOrHrrPayloadMapper {
-    type Src = ShOrHrrPayloadInner<'a>;
-    type Dst = ShOrHrrPayload<'a>;
-    type RefSrc = ShOrHrrPayloadInnerRef<'a>;
+impl<'a> Iso<'a> for ProtocolNameListMapper {
+    type Src = ProtocolNameListInner<'a>;
+    type Dst = ProtocolNameList<'a>;
+    type RefSrc = ProtocolNameListInnerRef<'a>;
 }
 
-type SpecShOrHrrPayloadCombinatorAlias1 = Choice<Cond<SpecHelloRetryRequestCombinator>, Cond<SpecServerHelloCombinator>>;
-pub struct SpecShOrHrrPayloadCombinator(pub SpecShOrHrrPayloadCombinatorAlias);
+pub struct SpecProtocolNameListCombinator(pub SpecProtocolNameListCombinatorAlias);
 
-impl SpecCombinator for SpecShOrHrrPayloadCombinator {
-    type Type = SpecShOrHrrPayload;
+impl SpecCombinator for SpecProtocolNameListCombinator {
+    type Type = SpecProtocolNameList;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecShOrHrrPayloadCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecShOrHrrPayloadCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecProtocolNameListCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecProtocolNameListCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecShOrHrrPayloadCombinatorAlias = Mapped<SpecShOrHrrPayloadCombinatorAlias1, ShOrHrrPayloadMapper>;
-type ShOrHrrPayloadCombinatorAlias1 = Choice<Cond<HelloRetryRequestCombinator>, Cond<ServerHelloCombinator>>;
-pub struct ShOrHrrPayloadCombinator1(pub ShOrHrrPayloadCombinatorAlias1);
-impl View for ShOrHrrPayloadCombinator1 {
-    type V = SpecShOrHrrPayloadCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ShOrHrrPayloadCombinator1, ShOrHrrPayloadCombinatorAlias1);
+pub type SpecProtocolNameListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<SpecProtocolNameCombinator>>>, ProtocolNameListMapper>;
 
-pub struct ShOrHrrPayloadCombinator(pub ShOrHrrPayloadCombinatorAlias);
+pub struct ProtocolNameListCombinator(pub ProtocolNameListCombinatorAlias);
 
-impl View for ShOrHrrPayloadCombinator {
-    type V = SpecShOrHrrPayloadCombinator;
-    open spec fn view(&self) -> Self::V { SpecShOrHrrPayloadCombinator(self.0@) }
+impl View for ProtocolNameListCombinator {
+    type V = SpecProtocolNameListCombinator;
+    open spec fn view(&self) -> Self::V { SpecProtocolNameListCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ShOrHrrPayloadCombinator {
-    type Type = ShOrHrrPayload<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ProtocolNameListCombinator {
+    type Type = ProtocolNameList<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ShOrHrrPayloadCombinatorAlias = Mapped<ShOrHrrPayloadCombinator1, ShOrHrrPayloadMapper>;
+}
+pub type ProtocolNameListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<ProtocolNameCombinator>>, ProtocolNameListCont0>, ProtocolNameListMapper>;
 
 
-pub open spec fn spec_sh_or_hrr_payload(random: Seq<u8>) -> SpecShOrHrrPayloadCombinator {
-    SpecShOrHrrPayloadCombinator(Mapped { inner: Choice(Cond { cond: random == seq![207u8, 33u8, 173u8, 116u8, 229u8, 154u8, 97u8, 17u8, 190u8, 29u8, 140u8, 2u8, 30u8, 101u8, 184u8, 145u8, 194u8, 162u8, 17u8, 22u8, 122u8, 187u8, 140u8, 94u8, 7u8, 158u8, 9u8, 226u8, 200u8, 168u8, 51u8, 156u8], inner: spec_hello_retry_request() }, Cond { cond: !(random == seq![207u8, 33u8, 173u8, 116u8, 229u8, 154u8, 97u8, 17u8, 190u8, 29u8, 140u8, 2u8, 30u8, 101u8, 184u8, 145u8, 194u8, 162u8, 17u8, 22u8, 122u8, 187u8, 140u8, 94u8, 7u8, 158u8, 9u8, 226u8, 200u8, 168u8, 51u8, 156u8]), inner: spec_server_hello() }), mapper: ShOrHrrPayloadMapper })
+pub open spec fn spec_protocol_name_list() -> SpecProtocolNameListCombinator {
+    SpecProtocolNameListCombinator(
+    Mapped {
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, |deps| spec_protocol_name_list_cont0(deps)),
+        mapper: ProtocolNameListMapper,
+    })
 }
 
-pub fn sh_or_hrr_payload<'a>(random: &'a [u8]) -> (o: ShOrHrrPayloadCombinator)
-    ensures o@ == spec_sh_or_hrr_payload(random@),
+pub open spec fn spec_protocol_name_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecProtocolNameCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_protocol_name()))
+}
+
+impl View for ProtocolNameListCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecProtocolNameCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_protocol_name_list_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn protocol_name_list<'a>() -> (o: ProtocolNameListCombinator)
+    ensures o@ == spec_protocol_name_list(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ShOrHrrPayloadCombinator(Mapped { inner: ShOrHrrPayloadCombinator1(Choice::new(Cond { cond: compare_slice(random, [207, 33, 173, 116, 229, 154, 97, 17, 190, 29, 140, 2, 30, 101, 184, 145, 194, 162, 17, 22, 122, 187, 140, 94, 7, 158, 9, 226, 200, 168, 51, 156].as_slice()), inner: hello_retry_request() }, Cond { cond: !(compare_slice(random, [207, 33, 173, 116, 229, 154, 97, 17, 190, 29, 140, 2, 30, 101, 184, 145, 194, 162, 17, 22, 122, 187, 140, 94, 7, 158, 9, 226, 200, 168, 51, 156].as_slice())), inner: server_hello() })), mapper: ShOrHrrPayloadMapper });
-    assert({
-        &&& combinator@ == spec_sh_or_hrr_payload(random@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ProtocolNameListCombinator(
+    Mapped {
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, ProtocolNameListCont0),
+        mapper: ProtocolNameListMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_protocol_name_list()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_sh_or_hrr_payload<'a>(input: &'a [u8], random: &'a [u8]) -> (res: PResult<<ShOrHrrPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_protocol_name_list<'a>(input: &'a [u8]) -> (res: PResult<<ProtocolNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_sh_or_hrr_payload(random@).spec_parse(input@) == Some((n as int, v@)),
-        spec_sh_or_hrr_payload(random@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_protocol_name_list().spec_parse(input@) == Some((n as int, v@)),
+        spec_protocol_name_list().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_sh_or_hrr_payload(random@).spec_parse(input@) is None,
-        spec_sh_or_hrr_payload(random@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_protocol_name_list().spec_parse(input@) is None,
+        spec_protocol_name_list().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = sh_or_hrr_payload( random );
+    let combinator = protocol_name_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_sh_or_hrr_payload<'a>(v: <ShOrHrrPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, random: &'a [u8]) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_protocol_name_list<'a>(v: <ProtocolNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_sh_or_hrr_payload(random@).wf(v@),
+        spec_protocol_name_list().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_sh_or_hrr_payload(random@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_sh_or_hrr_payload(random@).spec_serialize(v@))
+            &&& n == spec_protocol_name_list().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_protocol_name_list().spec_serialize(v@))
         },
 {
-    let combinator = sh_or_hrr_payload( random );
-    combinator.serialize(v, data, pos)
+    let combinator = protocol_name_list();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn sh_or_hrr_payload_len<'a>(v: <ShOrHrrPayloadCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, random: &'a [u8]) -> (serialize_len: usize)
+pub fn protocol_name_list_len<'a>(v: <ProtocolNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_sh_or_hrr_payload(random@).wf(v@),
-        spec_sh_or_hrr_payload(random@).spec_serialize(v@).len() <= usize::MAX,
+        spec_protocol_name_list().wf(v@),
+        spec_protocol_name_list().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_sh_or_hrr_payload(random@).spec_serialize(v@).len(),
+        serialize_len == spec_protocol_name_list().spec_serialize(v@).len(),
 {
-    let combinator = sh_or_hrr_payload( random );
+    let combinator = protocol_name_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct ProtocolNameListCont0;
+type ProtocolNameListCont0Type<'a, 'b> = &'b u16;
+type ProtocolNameListCont0SType<'a, 'x> = &'x u16;
+type ProtocolNameListCont0Input<'a, 'b, 'x> = POrSType<ProtocolNameListCont0Type<'a, 'b>, ProtocolNameListCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ProtocolNameListCont0Input<'a, 'b, 'x>> for ProtocolNameListCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<ProtocolNameCombinator>>;
 
-pub enum SpecFinished {
-    Hash12(Seq<u8>),
-    Hash20(Seq<u8>),
-    Sha256(Seq<u8>),
-    Sha384(Seq<u8>),
-    Sha512(Seq<u8>),
-    Unrecognized(Seq<u8>),
-}
+    open spec fn requires(&self, deps: ProtocolNameListCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate8195707947578446211 }).wf(deps@)
+        }
 
-pub type SpecFinishedInner = Either<Seq<u8>, Either<Seq<u8>, Either<Seq<u8>, Either<Seq<u8>, Either<Seq<u8>, Seq<u8>>>>>>;
+    open spec fn ensures(&self, deps: ProtocolNameListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_protocol_name_list_cont0(deps@)
+    }
 
-impl SpecFrom<SpecFinished> for SpecFinishedInner {
-    open spec fn spec_from(m: SpecFinished) -> SpecFinishedInner {
-        match m {
-            SpecFinished::Hash12(m) => Either::Left(m),
-            SpecFinished::Hash20(m) => Either::Right(Either::Left(m)),
-            SpecFinished::Sha256(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecFinished::Sha384(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            SpecFinished::Sha512(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            SpecFinished::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))),
+    fn apply(&self, deps: ProtocolNameListCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(protocol_name()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(protocol_name()))
+            }
         }
     }
-
 }
-
                 
-impl SpecFrom<SpecFinishedInner> for SpecFinished {
-    open spec fn spec_from(m: SpecFinishedInner) -> SpecFinished {
-        match m {
-            Either::Left(m) => SpecFinished::Hash12(m),
-            Either::Right(Either::Left(m)) => SpecFinished::Hash20(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecFinished::Sha256(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecFinished::Sha384(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecFinished::Sha512(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))) => SpecFinished::Unrecognized(m),
-        }
-    }
 
+pub struct SpecSupportedVersionsClient {
+    pub l: u8,
+    pub list: Seq<u16>,
 }
 
+pub type SpecSupportedVersionsClientInner = (u8, Seq<u16>);
 
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Finished<'a> {
-    Hash12(&'a [u8]),
-    Hash20(&'a [u8]),
-    Sha256(&'a [u8]),
-    Sha384(&'a [u8]),
-    Sha512(&'a [u8]),
-    Unrecognized(&'a [u8]),
+impl SpecFrom<SpecSupportedVersionsClient> for SpecSupportedVersionsClientInner {
+    open spec fn spec_from(m: SpecSupportedVersionsClient) -> SpecSupportedVersionsClientInner {
+        (m.l, m.list)
+    }
 }
 
-pub type FinishedInner<'a> = Either<&'a [u8], Either<&'a [u8], Either<&'a [u8], Either<&'a [u8], Either<&'a [u8], &'a [u8]>>>>>;
+impl SpecFrom<SpecSupportedVersionsClientInner> for SpecSupportedVersionsClient {
+    open spec fn spec_from(m: SpecSupportedVersionsClientInner) -> SpecSupportedVersionsClient {
+        let (l, list) = m;
+        SpecSupportedVersionsClient { l, list }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub type FinishedInnerRef<'a> = Either<&'a &'a [u8], Either<&'a &'a [u8], Either<&'a &'a [u8], Either<&'a &'a [u8], Either<&'a &'a [u8], &'a &'a [u8]>>>>>;
+pub struct SupportedVersionsClient {
+    pub l: u8,
+    pub list: RepeatResult<u16>,
+}
 
+impl View for SupportedVersionsClient {
+    type V = SpecSupportedVersionsClient;
 
-impl<'a> View for Finished<'a> {
-    type V = SpecFinished;
     open spec fn view(&self) -> Self::V {
-        match self {
-            Finished::Hash12(m) => SpecFinished::Hash12(m@),
-            Finished::Hash20(m) => SpecFinished::Hash20(m@),
-            Finished::Sha256(m) => SpecFinished::Sha256(m@),
-            Finished::Sha384(m) => SpecFinished::Sha384(m@),
-            Finished::Sha512(m) => SpecFinished::Sha512(m@),
-            Finished::Unrecognized(m) => SpecFinished::Unrecognized(m@),
+        SpecSupportedVersionsClient {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
+pub type SupportedVersionsClientInner = (u8, RepeatResult<u16>);
 
-
-impl<'a> From<&'a Finished<'a>> for FinishedInnerRef<'a> {
-    fn ex_from(m: &'a Finished<'a>) -> FinishedInnerRef<'a> {
-        match m {
-            Finished::Hash12(m) => Either::Left(m),
-            Finished::Hash20(m) => Either::Right(Either::Left(m)),
-            Finished::Sha256(m) => Either::Right(Either::Right(Either::Left(m))),
-            Finished::Sha384(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            Finished::Sha512(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            Finished::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))),
-        }
+pub type SupportedVersionsClientInnerRef<'a> = (&'a u8, &'a RepeatResult<u16>);
+impl<'a> From<&'a SupportedVersionsClient> for SupportedVersionsClientInnerRef<'a> {
+    fn ex_from(m: &'a SupportedVersionsClient) -> SupportedVersionsClientInnerRef<'a> {
+        (&m.l, &m.list)
     }
-
 }
 
-impl<'a> From<FinishedInner<'a>> for Finished<'a> {
-    fn ex_from(m: FinishedInner<'a>) -> Finished<'a> {
-        match m {
-            Either::Left(m) => Finished::Hash12(m),
-            Either::Right(Either::Left(m)) => Finished::Hash20(m),
-            Either::Right(Either::Right(Either::Left(m))) => Finished::Sha256(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => Finished::Sha384(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => Finished::Sha512(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))) => Finished::Unrecognized(m),
-        }
+impl From<SupportedVersionsClientInner> for SupportedVersionsClient {
+    fn ex_from(m: SupportedVersionsClientInner) -> SupportedVersionsClient {
+        let (l, list) = m;
+        SupportedVersionsClient { l, list }
     }
-    
 }
 
-
-pub struct FinishedMapper;
-impl View for FinishedMapper {
+pub struct SupportedVersionsClientMapper;
+impl View for SupportedVersionsClientMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for FinishedMapper {
-    type Src = SpecFinishedInner;
-    type Dst = SpecFinished;
+impl SpecIso for SupportedVersionsClientMapper {
+    type Src = SpecSupportedVersionsClientInner;
+    type Dst = SpecSupportedVersionsClient;
 }
-impl SpecIsoProof for FinishedMapper {
+impl SpecIsoProof for SupportedVersionsClientMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -11726,253 +10763,265 @@ impl SpecIsoProof for FinishedMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for FinishedMapper {
-    type Src = FinishedInner<'a>;
-    type Dst = Finished<'a>;
-    type RefSrc = FinishedInnerRef<'a>;
+impl<'a> Iso<'a> for SupportedVersionsClientMapper {
+    type Src = SupportedVersionsClientInner;
+    type Dst = SupportedVersionsClient;
+    type RefSrc = SupportedVersionsClientInnerRef<'a>;
 }
 
-type SpecFinishedCombinatorAlias1 = Choice<Cond<bytes::Fixed<64>>, Cond<bytes::Variable>>;
-type SpecFinishedCombinatorAlias2 = Choice<Cond<bytes::Fixed<48>>, SpecFinishedCombinatorAlias1>;
-type SpecFinishedCombinatorAlias3 = Choice<Cond<bytes::Fixed<32>>, SpecFinishedCombinatorAlias2>;
-type SpecFinishedCombinatorAlias4 = Choice<Cond<bytes::Fixed<20>>, SpecFinishedCombinatorAlias3>;
-type SpecFinishedCombinatorAlias5 = Choice<Cond<bytes::Fixed<12>>, SpecFinishedCombinatorAlias4>;
-pub struct SpecFinishedCombinator(pub SpecFinishedCombinatorAlias);
+pub struct SpecSupportedVersionsClientCombinator(pub SpecSupportedVersionsClientCombinatorAlias);
 
-impl SpecCombinator for SpecFinishedCombinator {
-    type Type = SpecFinished;
+impl SpecCombinator for SpecSupportedVersionsClientCombinator {
+    type Type = SpecSupportedVersionsClient;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecFinishedCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecFinishedCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSupportedVersionsClientCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSupportedVersionsClientCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecFinishedCombinatorAlias = Mapped<SpecFinishedCombinatorAlias5, FinishedMapper>;
-type FinishedCombinatorAlias1 = Choice<Cond<bytes::Fixed<64>>, Cond<bytes::Variable>>;
-type FinishedCombinatorAlias2 = Choice<Cond<bytes::Fixed<48>>, FinishedCombinator1>;
-type FinishedCombinatorAlias3 = Choice<Cond<bytes::Fixed<32>>, FinishedCombinator2>;
-type FinishedCombinatorAlias4 = Choice<Cond<bytes::Fixed<20>>, FinishedCombinator3>;
-type FinishedCombinatorAlias5 = Choice<Cond<bytes::Fixed<12>>, FinishedCombinator4>;
-pub struct FinishedCombinator1(pub FinishedCombinatorAlias1);
-impl View for FinishedCombinator1 {
-    type V = SpecFinishedCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(FinishedCombinator1, FinishedCombinatorAlias1);
-
-pub struct FinishedCombinator2(pub FinishedCombinatorAlias2);
-impl View for FinishedCombinator2 {
-    type V = SpecFinishedCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(FinishedCombinator2, FinishedCombinatorAlias2);
+pub type SpecSupportedVersionsClientCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate7470776374180795781>, AndThen<bytes::Variable, Repeat<SpecProtocolVersionCombinator>>>, SupportedVersionsClientMapper>;
+pub struct Predicate7470776374180795781;
+impl View for Predicate7470776374180795781 {
+    type V = Self;
 
-pub struct FinishedCombinator3(pub FinishedCombinatorAlias3);
-impl View for FinishedCombinator3 {
-    type V = SpecFinishedCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
 }
-impl_wrapper_combinator!(FinishedCombinator3, FinishedCombinatorAlias3);
-
-pub struct FinishedCombinator4(pub FinishedCombinatorAlias4);
-impl View for FinishedCombinator4 {
-    type V = SpecFinishedCombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
+impl Pred<u8> for Predicate7470776374180795781 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 2 && i <= 254)
+    }
 }
-impl_wrapper_combinator!(FinishedCombinator4, FinishedCombinatorAlias4);
-
-pub struct FinishedCombinator5(pub FinishedCombinatorAlias5);
-impl View for FinishedCombinator5 {
-    type V = SpecFinishedCombinatorAlias5;
-    open spec fn view(&self) -> Self::V { self.0@ }
+impl SpecPred<u8> for Predicate7470776374180795781 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 2 && i <= 254)
+    }
 }
-impl_wrapper_combinator!(FinishedCombinator5, FinishedCombinatorAlias5);
 
-pub struct FinishedCombinator(pub FinishedCombinatorAlias);
+pub struct SupportedVersionsClientCombinator(pub SupportedVersionsClientCombinatorAlias);
 
-impl View for FinishedCombinator {
-    type V = SpecFinishedCombinator;
-    open spec fn view(&self) -> Self::V { SpecFinishedCombinator(self.0@) }
+impl View for SupportedVersionsClientCombinator {
+    type V = SpecSupportedVersionsClientCombinator;
+    open spec fn view(&self) -> Self::V { SpecSupportedVersionsClientCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FinishedCombinator {
-    type Type = Finished<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SupportedVersionsClientCombinator {
+    type Type = SupportedVersionsClient;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type FinishedCombinatorAlias = Mapped<FinishedCombinator5, FinishedMapper>;
+}
+pub type SupportedVersionsClientCombinatorAlias = Mapped<Pair<Refined<U8, Predicate7470776374180795781>, AndThen<bytes::Variable, Repeat<ProtocolVersionCombinator>>, SupportedVersionsClientCont0>, SupportedVersionsClientMapper>;
 
 
-pub open spec fn spec_finished(size: u24) -> SpecFinishedCombinator {
-    SpecFinishedCombinator(Mapped { inner: Choice(Cond { cond: size.spec_as_u32() == DigestSize::SPEC_Hash12, inner: bytes::Fixed::<12> }, Choice(Cond { cond: size.spec_as_u32() == DigestSize::SPEC_Hash20, inner: bytes::Fixed::<20> }, Choice(Cond { cond: size.spec_as_u32() == DigestSize::SPEC_Sha256, inner: bytes::Fixed::<32> }, Choice(Cond { cond: size.spec_as_u32() == DigestSize::SPEC_Sha384, inner: bytes::Fixed::<48> }, Choice(Cond { cond: size.spec_as_u32() == DigestSize::SPEC_Sha512, inner: bytes::Fixed::<64> }, Cond { cond: !(size.spec_as_u32() == DigestSize::SPEC_Hash12 || size.spec_as_u32() == DigestSize::SPEC_Hash20 || size.spec_as_u32() == DigestSize::SPEC_Sha256 || size.spec_as_u32() == DigestSize::SPEC_Sha384 || size.spec_as_u32() == DigestSize::SPEC_Sha512), inner: bytes::Variable(size.spec_into()) }))))), mapper: FinishedMapper })
+pub open spec fn spec_supported_versions_client() -> SpecSupportedVersionsClientCombinator {
+    SpecSupportedVersionsClientCombinator(
+    Mapped {
+        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate7470776374180795781 }, |deps| spec_supported_versions_client_cont0(deps)),
+        mapper: SupportedVersionsClientMapper,
+    })
 }
 
-pub fn finished<'a>(size: u24) -> (o: FinishedCombinator)
-    ensures o@ == spec_finished(size@),
+pub open spec fn spec_supported_versions_client_cont0(deps: u8) -> AndThen<bytes::Variable, Repeat<SpecProtocolVersionCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_protocol_version()))
+}
+
+impl View for SupportedVersionsClientCont0 {
+    type V = spec_fn(u8) -> AndThen<bytes::Variable, Repeat<SpecProtocolVersionCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_supported_versions_client_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn supported_versions_client<'a>() -> (o: SupportedVersionsClientCombinator)
+    ensures o@ == spec_supported_versions_client(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = FinishedCombinator(Mapped { inner: FinishedCombinator5(Choice::new(Cond { cond: size.as_u32() == DigestSize::Hash12, inner: bytes::Fixed::<12> }, FinishedCombinator4(Choice::new(Cond { cond: size.as_u32() == DigestSize::Hash20, inner: bytes::Fixed::<20> }, FinishedCombinator3(Choice::new(Cond { cond: size.as_u32() == DigestSize::Sha256, inner: bytes::Fixed::<32> }, FinishedCombinator2(Choice::new(Cond { cond: size.as_u32() == DigestSize::Sha384, inner: bytes::Fixed::<48> }, FinishedCombinator1(Choice::new(Cond { cond: size.as_u32() == DigestSize::Sha512, inner: bytes::Fixed::<64> }, Cond { cond: !(size.as_u32() == DigestSize::Hash12 || size.as_u32() == DigestSize::Hash20 || size.as_u32() == DigestSize::Sha256 || size.as_u32() == DigestSize::Sha384 || size.as_u32() == DigestSize::Sha512), inner: bytes::Variable(size.ex_into()) })))))))))), mapper: FinishedMapper });
-    assert({
-        &&& combinator@ == spec_finished(size@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = SupportedVersionsClientCombinator(
+    Mapped {
+        inner: Pair::new(Refined { inner: U8, predicate: Predicate7470776374180795781 }, SupportedVersionsClientCont0),
+        mapper: SupportedVersionsClientMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_supported_versions_client()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_finished<'a>(input: &'a [u8], size: u24) -> (res: PResult<<FinishedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_supported_versions_client<'a>(input: &'a [u8]) -> (res: PResult<<SupportedVersionsClientCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_finished(size@).spec_parse(input@) == Some((n as int, v@)),
-        spec_finished(size@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_supported_versions_client().spec_parse(input@) == Some((n as int, v@)),
+        spec_supported_versions_client().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_finished(size@).spec_parse(input@) is None,
-        spec_finished(size@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_supported_versions_client().spec_parse(input@) is None,
+        spec_supported_versions_client().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = finished( size );
+    let combinator = supported_versions_client();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_finished<'a>(v: <FinishedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, size: u24) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_supported_versions_client<'a>(v: <SupportedVersionsClientCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_finished(size@).wf(v@),
+        spec_supported_versions_client().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_finished(size@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_finished(size@).spec_serialize(v@))
+            &&& n == spec_supported_versions_client().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_supported_versions_client().spec_serialize(v@))
         },
 {
-    let combinator = finished( size );
-    combinator.serialize(v, data, pos)
+    let combinator = supported_versions_client();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn finished_len<'a>(v: <FinishedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, size: u24) -> (serialize_len: usize)
+pub fn supported_versions_client_len<'a>(v: <SupportedVersionsClientCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_finished(size@).wf(v@),
-        spec_finished(size@).spec_serialize(v@).len() <= usize::MAX,
+        spec_supported_versions_client().wf(v@),
+        spec_supported_versions_client().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_finished(size@).spec_serialize(v@).len(),
+        serialize_len == spec_supported_versions_client().spec_serialize(v@).len(),
 {
-    let combinator = finished( size );
+    let combinator = supported_versions_client();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct SupportedVersionsClientCont0;
+type SupportedVersionsClientCont0Type<'a, 'b> = &'b u8;
+type SupportedVersionsClientCont0SType<'a, 'x> = &'x u8;
+type SupportedVersionsClientCont0Input<'a, 'b, 'x> = POrSType<SupportedVersionsClientCont0Type<'a, 'b>, SupportedVersionsClientCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<SupportedVersionsClientCont0Input<'a, 'b, 'x>> for SupportedVersionsClientCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<ProtocolVersionCombinator>>;
 
-pub enum SpecNewSessionTicketExtensionExtensionData {
-    EarlyData(SpecEarlyDataIndicationNewSessionTicket),
-    Unrecognized(Seq<u8>),
-}
+    open spec fn requires(&self, deps: SupportedVersionsClientCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U8, predicate: Predicate7470776374180795781 }).wf(deps@)
+        }
 
-pub type SpecNewSessionTicketExtensionExtensionDataInner = Either<SpecEarlyDataIndicationNewSessionTicket, Seq<u8>>;
+    open spec fn ensures(&self, deps: SupportedVersionsClientCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_supported_versions_client_cont0(deps@)
+    }
 
-impl SpecFrom<SpecNewSessionTicketExtensionExtensionData> for SpecNewSessionTicketExtensionExtensionDataInner {
-    open spec fn spec_from(m: SpecNewSessionTicketExtensionExtensionData) -> SpecNewSessionTicketExtensionExtensionDataInner {
-        match m {
-            SpecNewSessionTicketExtensionExtensionData::EarlyData(m) => Either::Left(m),
-            SpecNewSessionTicketExtensionExtensionData::Unrecognized(m) => Either::Right(m),
+    fn apply(&self, deps: SupportedVersionsClientCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(protocol_version()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(protocol_version()))
+            }
         }
     }
-
 }
-
                 
-impl SpecFrom<SpecNewSessionTicketExtensionExtensionDataInner> for SpecNewSessionTicketExtensionExtensionData {
-    open spec fn spec_from(m: SpecNewSessionTicketExtensionExtensionDataInner) -> SpecNewSessionTicketExtensionExtensionData {
-        match m {
-            Either::Left(m) => SpecNewSessionTicketExtensionExtensionData::EarlyData(m),
-            Either::Right(m) => SpecNewSessionTicketExtensionExtensionData::Unrecognized(m),
-        }
-    }
 
+pub struct SpecKeyShareClientHello {
+    pub l: u16,
+    pub list: Seq<SpecKeyShareEntry>,
 }
 
+pub type SpecKeyShareClientHelloInner = (u16, Seq<SpecKeyShareEntry>);
 
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum NewSessionTicketExtensionExtensionData<'a> {
-    EarlyData(EarlyDataIndicationNewSessionTicket),
-    Unrecognized(&'a [u8]),
+impl SpecFrom<SpecKeyShareClientHello> for SpecKeyShareClientHelloInner {
+    open spec fn spec_from(m: SpecKeyShareClientHello) -> SpecKeyShareClientHelloInner {
+        (m.l, m.list)
+    }
 }
 
-pub type NewSessionTicketExtensionExtensionDataInner<'a> = Either<EarlyDataIndicationNewSessionTicket, &'a [u8]>;
-
-pub type NewSessionTicketExtensionExtensionDataInnerRef<'a> = Either<&'a EarlyDataIndicationNewSessionTicket, &'a &'a [u8]>;
+impl SpecFrom<SpecKeyShareClientHelloInner> for SpecKeyShareClientHello {
+    open spec fn spec_from(m: SpecKeyShareClientHelloInner) -> SpecKeyShareClientHello {
+        let (l, list) = m;
+        SpecKeyShareClientHello { l, list }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
 
+pub struct KeyShareClientHello<'a> {
+    pub l: u16,
+    pub list: RepeatResult<KeyShareEntry<'a>>,
+}
+
+impl View for KeyShareClientHello<'_> {
+    type V = SpecKeyShareClientHello;
 
-impl<'a> View for NewSessionTicketExtensionExtensionData<'a> {
-    type V = SpecNewSessionTicketExtensionExtensionData;
     open spec fn view(&self) -> Self::V {
-        match self {
-            NewSessionTicketExtensionExtensionData::EarlyData(m) => SpecNewSessionTicketExtensionExtensionData::EarlyData(m@),
-            NewSessionTicketExtensionExtensionData::Unrecognized(m) => SpecNewSessionTicketExtensionExtensionData::Unrecognized(m@),
+        SpecKeyShareClientHello {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
+pub type KeyShareClientHelloInner<'a> = (u16, RepeatResult<KeyShareEntry<'a>>);
 
-
-impl<'a> From<&'a NewSessionTicketExtensionExtensionData<'a>> for NewSessionTicketExtensionExtensionDataInnerRef<'a> {
-    fn ex_from(m: &'a NewSessionTicketExtensionExtensionData<'a>) -> NewSessionTicketExtensionExtensionDataInnerRef<'a> {
-        match m {
-            NewSessionTicketExtensionExtensionData::EarlyData(m) => Either::Left(m),
-            NewSessionTicketExtensionExtensionData::Unrecognized(m) => Either::Right(m),
-        }
+pub type KeyShareClientHelloInnerRef<'a> = (&'a u16, &'a RepeatResult<KeyShareEntry<'a>>);
+impl<'a> From<&'a KeyShareClientHello<'a>> for KeyShareClientHelloInnerRef<'a> {
+    fn ex_from(m: &'a KeyShareClientHello) -> KeyShareClientHelloInnerRef<'a> {
+        (&m.l, &m.list)
     }
-
 }
 
-impl<'a> From<NewSessionTicketExtensionExtensionDataInner<'a>> for NewSessionTicketExtensionExtensionData<'a> {
-    fn ex_from(m: NewSessionTicketExtensionExtensionDataInner<'a>) -> NewSessionTicketExtensionExtensionData<'a> {
-        match m {
-            Either::Left(m) => NewSessionTicketExtensionExtensionData::EarlyData(m),
-            Either::Right(m) => NewSessionTicketExtensionExtensionData::Unrecognized(m),
-        }
+impl<'a> From<KeyShareClientHelloInner<'a>> for KeyShareClientHello<'a> {
+    fn ex_from(m: KeyShareClientHelloInner) -> KeyShareClientHello {
+        let (l, list) = m;
+        KeyShareClientHello { l, list }
     }
-    
 }
 
-
-pub struct NewSessionTicketExtensionExtensionDataMapper;
-impl View for NewSessionTicketExtensionExtensionDataMapper {
+pub struct KeyShareClientHelloMapper;
+impl View for KeyShareClientHelloMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for NewSessionTicketExtensionExtensionDataMapper {
-    type Src = SpecNewSessionTicketExtensionExtensionDataInner;
-    type Dst = SpecNewSessionTicketExtensionExtensionData;
+impl SpecIso for KeyShareClientHelloMapper {
+    type Src = SpecKeyShareClientHelloInner;
+    type Dst = SpecKeyShareClientHello;
 }
-impl SpecIsoProof for NewSessionTicketExtensionExtensionDataMapper {
+impl SpecIsoProof for KeyShareClientHelloMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -11980,484 +11029,367 @@ impl SpecIsoProof for NewSessionTicketExtensionExtensionDataMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for NewSessionTicketExtensionExtensionDataMapper {
-    type Src = NewSessionTicketExtensionExtensionDataInner<'a>;
-    type Dst = NewSessionTicketExtensionExtensionData<'a>;
-    type RefSrc = NewSessionTicketExtensionExtensionDataInnerRef<'a>;
+impl<'a> Iso<'a> for KeyShareClientHelloMapper {
+    type Src = KeyShareClientHelloInner<'a>;
+    type Dst = KeyShareClientHello<'a>;
+    type RefSrc = KeyShareClientHelloInnerRef<'a>;
 }
 
-type SpecNewSessionTicketExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecEarlyDataIndicationNewSessionTicketCombinator>, Cond<bytes::Variable>>;
-pub struct SpecNewSessionTicketExtensionExtensionDataCombinator(pub SpecNewSessionTicketExtensionExtensionDataCombinatorAlias);
+pub struct SpecKeyShareClientHelloCombinator(pub SpecKeyShareClientHelloCombinatorAlias);
 
-impl SpecCombinator for SpecNewSessionTicketExtensionExtensionDataCombinator {
-    type Type = SpecNewSessionTicketExtensionExtensionData;
+impl SpecCombinator for SpecKeyShareClientHelloCombinator {
+    type Type = SpecKeyShareClientHello;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecNewSessionTicketExtensionExtensionDataCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecNewSessionTicketExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecKeyShareClientHelloCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecKeyShareClientHelloCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecNewSessionTicketExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecNewSessionTicketExtensionExtensionDataCombinatorAlias1, NewSessionTicketExtensionExtensionDataMapper>>;
-type NewSessionTicketExtensionExtensionDataCombinatorAlias1 = Choice<Cond<EarlyDataIndicationNewSessionTicketCombinator>, Cond<bytes::Variable>>;
-pub struct NewSessionTicketExtensionExtensionDataCombinator1(pub NewSessionTicketExtensionExtensionDataCombinatorAlias1);
-impl View for NewSessionTicketExtensionExtensionDataCombinator1 {
-    type V = SpecNewSessionTicketExtensionExtensionDataCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(NewSessionTicketExtensionExtensionDataCombinator1, NewSessionTicketExtensionExtensionDataCombinatorAlias1);
+pub type SpecKeyShareClientHelloCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecKeyShareEntryCombinator>>>, KeyShareClientHelloMapper>;
 
-pub struct NewSessionTicketExtensionExtensionDataCombinator(pub NewSessionTicketExtensionExtensionDataCombinatorAlias);
+pub struct KeyShareClientHelloCombinator(pub KeyShareClientHelloCombinatorAlias);
 
-impl View for NewSessionTicketExtensionExtensionDataCombinator {
-    type V = SpecNewSessionTicketExtensionExtensionDataCombinator;
-    open spec fn view(&self) -> Self::V { SpecNewSessionTicketExtensionExtensionDataCombinator(self.0@) }
+impl View for KeyShareClientHelloCombinator {
+    type V = SpecKeyShareClientHelloCombinator;
+    open spec fn view(&self) -> Self::V { SpecKeyShareClientHelloCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NewSessionTicketExtensionExtensionDataCombinator {
-    type Type = NewSessionTicketExtensionExtensionData<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for KeyShareClientHelloCombinator {
+    type Type = KeyShareClientHello<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type NewSessionTicketExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<NewSessionTicketExtensionExtensionDataCombinator1, NewSessionTicketExtensionExtensionDataMapper>>;
+}
+pub type KeyShareClientHelloCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<KeyShareEntryCombinator>>, KeyShareClientHelloCont0>, KeyShareClientHelloMapper>;
 
 
-pub open spec fn spec_new_session_ticket_extension_extension_data(extension_type: u16, ext_len: u16) -> SpecNewSessionTicketExtensionExtensionDataCombinator {
-    SpecNewSessionTicketExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.spec_into()), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_EarlyData, inner: spec_early_data_indication_new_session_ticket() }, Cond { cond: !(extension_type == ExtensionType::SPEC_EarlyData), inner: bytes::Variable(ext_len.spec_into()) }), mapper: NewSessionTicketExtensionExtensionDataMapper }))
+pub open spec fn spec_key_share_client_hello() -> SpecKeyShareClientHelloCombinator {
+    SpecKeyShareClientHelloCombinator(
+    Mapped {
+        inner: Pair::spec_new(U16Be, |deps| spec_key_share_client_hello_cont0(deps)),
+        mapper: KeyShareClientHelloMapper,
+    })
 }
 
-pub fn new_session_ticket_extension_extension_data<'a>(extension_type: u16, ext_len: u16) -> (o: NewSessionTicketExtensionExtensionDataCombinator)
-    ensures o@ == spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@),
+pub open spec fn spec_key_share_client_hello_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecKeyShareEntryCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_key_share_entry()))
+}
+
+impl View for KeyShareClientHelloCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecKeyShareEntryCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_key_share_client_hello_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn key_share_client_hello<'a>() -> (o: KeyShareClientHelloCombinator)
+    ensures o@ == spec_key_share_client_hello(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = NewSessionTicketExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.ex_into()), Mapped { inner: NewSessionTicketExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::EarlyData, inner: early_data_indication_new_session_ticket() }, Cond { cond: !(extension_type == ExtensionType::EarlyData), inner: bytes::Variable(ext_len.ex_into()) })), mapper: NewSessionTicketExtensionExtensionDataMapper }));
-    assert({
-        &&& combinator@ == spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = KeyShareClientHelloCombinator(
+    Mapped {
+        inner: Pair::new(U16Be, KeyShareClientHelloCont0),
+        mapper: KeyShareClientHelloMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_key_share_client_hello()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_new_session_ticket_extension_extension_data<'a>(input: &'a [u8], extension_type: u16, ext_len: u16) -> (res: PResult<<NewSessionTicketExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_key_share_client_hello<'a>(input: &'a [u8]) -> (res: PResult<<KeyShareClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) == Some((n as int, v@)),
-        spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_key_share_client_hello().spec_parse(input@) == Some((n as int, v@)),
+        spec_key_share_client_hello().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None,
-        spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_key_share_client_hello().spec_parse(input@) is None,
+        spec_key_share_client_hello().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = new_session_ticket_extension_extension_data( extension_type, ext_len );
+    let combinator = key_share_client_hello();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_new_session_ticket_extension_extension_data<'a>(v: <NewSessionTicketExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, extension_type: u16, ext_len: u16) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_key_share_client_hello<'a>(v: <KeyShareClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).wf(v@),
+        spec_key_share_client_hello().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@))
+            &&& n == spec_key_share_client_hello().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_key_share_client_hello().spec_serialize(v@))
         },
 {
-    let combinator = new_session_ticket_extension_extension_data( extension_type, ext_len );
-    combinator.serialize(v, data, pos)
+    let combinator = key_share_client_hello();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn new_session_ticket_extension_extension_data_len<'a>(v: <NewSessionTicketExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, extension_type: u16, ext_len: u16) -> (serialize_len: usize)
+pub fn key_share_client_hello_len<'a>(v: <KeyShareClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).wf(v@),
-        spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len() <= usize::MAX,
+        spec_key_share_client_hello().wf(v@),
+        spec_key_share_client_hello().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len(),
+        serialize_len == spec_key_share_client_hello().spec_serialize(v@).len(),
 {
-    let combinator = new_session_ticket_extension_extension_data( extension_type, ext_len );
+    let combinator = key_share_client_hello();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct KeyShareClientHelloCont0;
+type KeyShareClientHelloCont0Type<'a, 'b> = &'b u16;
+type KeyShareClientHelloCont0SType<'a, 'x> = &'x u16;
+type KeyShareClientHelloCont0Input<'a, 'b, 'x> = POrSType<KeyShareClientHelloCont0Type<'a, 'b>, KeyShareClientHelloCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<KeyShareClientHelloCont0Input<'a, 'b, 'x>> for KeyShareClientHelloCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<KeyShareEntryCombinator>>;
 
-pub struct SpecNewSessionTicketExtension {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: SpecNewSessionTicketExtensionExtensionData,
-}
-
-pub type SpecNewSessionTicketExtensionInner = ((u16, u16), SpecNewSessionTicketExtensionExtensionData);
-
+    open spec fn requires(&self, deps: KeyShareClientHelloCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U16Be).wf(deps@)
+        }
 
-impl SpecFrom<SpecNewSessionTicketExtension> for SpecNewSessionTicketExtensionInner {
-    open spec fn spec_from(m: SpecNewSessionTicketExtension) -> SpecNewSessionTicketExtensionInner {
-        ((m.extension_type, m.ext_len), m.extension_data)
+    open spec fn ensures(&self, deps: KeyShareClientHelloCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_key_share_client_hello_cont0(deps@)
     }
-}
 
-impl SpecFrom<SpecNewSessionTicketExtensionInner> for SpecNewSessionTicketExtension {
-    open spec fn spec_from(m: SpecNewSessionTicketExtensionInner) -> SpecNewSessionTicketExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        SpecNewSessionTicketExtension { extension_type, ext_len, extension_data }
+    fn apply(&self, deps: KeyShareClientHelloCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(key_share_entry()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(key_share_entry()))
+            }
+        }
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct NewSessionTicketExtension<'a> {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: NewSessionTicketExtensionExtensionData<'a>,
+                
+pub mod PskKeyExchangeMode {
+    use super::*;
+    pub spec const SPEC_PSK_KE: u8 = 0;
+    pub spec const SPEC_PSK_DHE_KE: u8 = 1;
+    pub exec const PSK_KE: u8 ensures PSK_KE == SPEC_PSK_KE { 0 }
+    pub exec const PSK_DHE_KE: u8 ensures PSK_DHE_KE == SPEC_PSK_DHE_KE { 1 }
 }
 
-impl View for NewSessionTicketExtension<'_> {
-    type V = SpecNewSessionTicketExtension;
 
-    open spec fn view(&self) -> Self::V {
-        SpecNewSessionTicketExtension {
-            extension_type: self.extension_type@,
-            ext_len: self.ext_len@,
-            extension_data: self.extension_data@,
-        }
-    }
-}
-pub type NewSessionTicketExtensionInner<'a> = ((u16, u16), NewSessionTicketExtensionExtensionData<'a>);
+pub struct SpecPskKeyExchangeModeCombinator(pub SpecPskKeyExchangeModeCombinatorAlias);
 
-pub type NewSessionTicketExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a NewSessionTicketExtensionExtensionData<'a>);
-impl<'a> From<&'a NewSessionTicketExtension<'a>> for NewSessionTicketExtensionInnerRef<'a> {
-    fn ex_from(m: &'a NewSessionTicketExtension) -> NewSessionTicketExtensionInnerRef<'a> {
-        ((&m.extension_type, &m.ext_len), &m.extension_data)
-    }
+impl SpecCombinator for SpecPskKeyExchangeModeCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
 }
-
-impl<'a> From<NewSessionTicketExtensionInner<'a>> for NewSessionTicketExtension<'a> {
-    fn ex_from(m: NewSessionTicketExtensionInner) -> NewSessionTicketExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        NewSessionTicketExtension { extension_type, ext_len, extension_data }
-    }
+impl SecureSpecCombinator for SpecPskKeyExchangeModeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPskKeyExchangeModeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
 }
+pub type SpecPskKeyExchangeModeCombinatorAlias = U8;
 
-pub struct NewSessionTicketExtensionMapper;
-impl View for NewSessionTicketExtensionMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for NewSessionTicketExtensionMapper {
-    type Src = SpecNewSessionTicketExtensionInner;
-    type Dst = SpecNewSessionTicketExtension;
-}
-impl SpecIsoProof for NewSessionTicketExtensionMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for NewSessionTicketExtensionMapper {
-    type Src = NewSessionTicketExtensionInner<'a>;
-    type Dst = NewSessionTicketExtension<'a>;
-    type RefSrc = NewSessionTicketExtensionInnerRef<'a>;
-}
-
-pub struct SpecNewSessionTicketExtensionCombinator(pub SpecNewSessionTicketExtensionCombinatorAlias);
-
-impl SpecCombinator for SpecNewSessionTicketExtensionCombinator {
-    type Type = SpecNewSessionTicketExtension;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecNewSessionTicketExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecNewSessionTicketExtensionCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
-}
-pub type SpecNewSessionTicketExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecNewSessionTicketExtensionExtensionDataCombinator>, NewSessionTicketExtensionMapper>;
-
-pub struct NewSessionTicketExtensionCombinator(pub NewSessionTicketExtensionCombinatorAlias);
+pub struct PskKeyExchangeModeCombinator(pub PskKeyExchangeModeCombinatorAlias);
 
-impl View for NewSessionTicketExtensionCombinator {
-    type V = SpecNewSessionTicketExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecNewSessionTicketExtensionCombinator(self.0@) }
+impl View for PskKeyExchangeModeCombinator {
+    type V = SpecPskKeyExchangeModeCombinator;
+    open spec fn view(&self) -> Self::V { SpecPskKeyExchangeModeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NewSessionTicketExtensionCombinator {
-    type Type = NewSessionTicketExtension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskKeyExchangeModeCombinator {
+    type Type = u8;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type NewSessionTicketExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, NewSessionTicketExtensionCont1>, NewSessionTicketExtensionExtensionDataCombinator, NewSessionTicketExtensionCont0>, NewSessionTicketExtensionMapper>;
-
-
-pub open spec fn spec_new_session_ticket_extension() -> SpecNewSessionTicketExtensionCombinator {
-    SpecNewSessionTicketExtensionCombinator(
-    Mapped {
-        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_new_session_ticket_extension_cont1(deps)), |deps| spec_new_session_ticket_extension_cont0(deps)),
-        mapper: NewSessionTicketExtensionMapper,
-    })
-}
-
-pub open spec fn spec_new_session_ticket_extension_cont1(deps: u16) -> U16Be {
-    let extension_type = deps;
-    U16Be
-}
-
-impl View for NewSessionTicketExtensionCont1 {
-    type V = spec_fn(u16) -> U16Be;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_new_session_ticket_extension_cont1(deps)
-        }
-    }
-}
-
-pub open spec fn spec_new_session_ticket_extension_cont0(deps: (u16, u16)) -> SpecNewSessionTicketExtensionExtensionDataCombinator {
-    let (extension_type, ext_len) = deps;
-    spec_new_session_ticket_extension_extension_data(extension_type, ext_len)
 }
+pub type PskKeyExchangeModeCombinatorAlias = U8;
 
-impl View for NewSessionTicketExtensionCont0 {
-    type V = spec_fn((u16, u16)) -> SpecNewSessionTicketExtensionExtensionDataCombinator;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: (u16, u16)| {
-            spec_new_session_ticket_extension_cont0(deps)
-        }
-    }
+pub open spec fn spec_psk_key_exchange_mode() -> SpecPskKeyExchangeModeCombinator {
+    SpecPskKeyExchangeModeCombinator(U8)
 }
 
                 
-pub fn new_session_ticket_extension<'a>() -> (o: NewSessionTicketExtensionCombinator)
-    ensures o@ == spec_new_session_ticket_extension(),
+pub fn psk_key_exchange_mode<'a>() -> (o: PskKeyExchangeModeCombinator)
+    ensures o@ == spec_psk_key_exchange_mode(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = NewSessionTicketExtensionCombinator(
-    Mapped {
-        inner: Pair::new(Pair::new(extension_type(), NewSessionTicketExtensionCont1), NewSessionTicketExtensionCont0),
-        mapper: NewSessionTicketExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_new_session_ticket_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = PskKeyExchangeModeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_psk_key_exchange_mode()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_new_session_ticket_extension<'a>(input: &'a [u8]) -> (res: PResult<<NewSessionTicketExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_psk_key_exchange_mode<'a>(input: &'a [u8]) -> (res: PResult<<PskKeyExchangeModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_new_session_ticket_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_new_session_ticket_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_psk_key_exchange_mode().spec_parse(input@) == Some((n as int, v@)),
+        spec_psk_key_exchange_mode().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_new_session_ticket_extension().spec_parse(input@) is None,
-        spec_new_session_ticket_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_psk_key_exchange_mode().spec_parse(input@) is None,
+        spec_psk_key_exchange_mode().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = new_session_ticket_extension();
+    let combinator = psk_key_exchange_mode();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_new_session_ticket_extension<'a>(v: <NewSessionTicketExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_psk_key_exchange_mode<'a>(v: <PskKeyExchangeModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_new_session_ticket_extension().wf(v@),
+        spec_psk_key_exchange_mode().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_new_session_ticket_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_new_session_ticket_extension().spec_serialize(v@))
+            &&& n == spec_psk_key_exchange_mode().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_psk_key_exchange_mode().spec_serialize(v@))
         },
 {
-    let combinator = new_session_ticket_extension();
+    let combinator = psk_key_exchange_mode();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn new_session_ticket_extension_len<'a>(v: <NewSessionTicketExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn psk_key_exchange_mode_len<'a>(v: <PskKeyExchangeModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_new_session_ticket_extension().wf(v@),
-        spec_new_session_ticket_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_psk_key_exchange_mode().wf(v@),
+        spec_psk_key_exchange_mode().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_new_session_ticket_extension().spec_serialize(v@).len(),
+        serialize_len == spec_psk_key_exchange_mode().spec_serialize(v@).len(),
 {
-    let combinator = new_session_ticket_extension();
+    let combinator = psk_key_exchange_mode();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct NewSessionTicketExtensionCont1;
-type NewSessionTicketExtensionCont1Type<'a, 'b> = &'b u16;
-type NewSessionTicketExtensionCont1SType<'a, 'x> = &'x u16;
-type NewSessionTicketExtensionCont1Input<'a, 'b, 'x> = POrSType<NewSessionTicketExtensionCont1Type<'a, 'b>, NewSessionTicketExtensionCont1SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<NewSessionTicketExtensionCont1Input<'a, 'b, 'x>> for NewSessionTicketExtensionCont1 {
-    type Output = U16Be;
-
-    open spec fn requires(&self, deps: NewSessionTicketExtensionCont1Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: NewSessionTicketExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_new_session_ticket_extension_cont1(deps@)
-    }
-
-    fn apply(&self, deps: NewSessionTicketExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let extension_type = *deps;
-                U16Be
-            }
-            POrSType::S(deps) => {
-                let extension_type = deps;
-                let extension_type = *extension_type;
-                U16Be
-            }
-        }
-    }
-}
-pub struct NewSessionTicketExtensionCont0;
-type NewSessionTicketExtensionCont0Type<'a, 'b> = &'b (u16, u16);
-type NewSessionTicketExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
-type NewSessionTicketExtensionCont0Input<'a, 'b, 'x> = POrSType<NewSessionTicketExtensionCont0Type<'a, 'b>, NewSessionTicketExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<NewSessionTicketExtensionCont0Input<'a, 'b, 'x>> for NewSessionTicketExtensionCont0 {
-    type Output = NewSessionTicketExtensionExtensionDataCombinator;
-
-    open spec fn requires(&self, deps: NewSessionTicketExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: NewSessionTicketExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_new_session_ticket_extension_cont0(deps@)
-    }
-
-    fn apply(&self, deps: NewSessionTicketExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let (extension_type, ext_len) = *deps;
-                new_session_ticket_extension_extension_data(extension_type, ext_len)
-            }
-            POrSType::S(deps) => {
-                let (extension_type, ext_len) = deps;
-                let (extension_type, ext_len) = (*extension_type, *ext_len);
-                new_session_ticket_extension_extension_data(extension_type, ext_len)
-            }
-        }
-    }
-}
                 
 
-pub struct SpecCipherSuiteList {
-    pub l: u16,
-    pub list: Seq<u16>,
+pub struct SpecPskKeyExchangeModes {
+    pub l: u8,
+    pub list: Seq<u8>,
 }
 
-pub type SpecCipherSuiteListInner = (u16, Seq<u16>);
+pub type SpecPskKeyExchangeModesInner = (u8, Seq<u8>);
 
 
-impl SpecFrom<SpecCipherSuiteList> for SpecCipherSuiteListInner {
-    open spec fn spec_from(m: SpecCipherSuiteList) -> SpecCipherSuiteListInner {
+impl SpecFrom<SpecPskKeyExchangeModes> for SpecPskKeyExchangeModesInner {
+    open spec fn spec_from(m: SpecPskKeyExchangeModes) -> SpecPskKeyExchangeModesInner {
         (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecCipherSuiteListInner> for SpecCipherSuiteList {
-    open spec fn spec_from(m: SpecCipherSuiteListInner) -> SpecCipherSuiteList {
+impl SpecFrom<SpecPskKeyExchangeModesInner> for SpecPskKeyExchangeModes {
+    open spec fn spec_from(m: SpecPskKeyExchangeModesInner) -> SpecPskKeyExchangeModes {
         let (l, list) = m;
-        SpecCipherSuiteList { l, list }
+        SpecPskKeyExchangeModes { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CipherSuiteList {
-    pub l: u16,
-    pub list: RepeatResult<u16>,
+pub struct PskKeyExchangeModes {
+    pub l: u8,
+    pub list: RepeatResult<u8>,
 }
 
-impl View for CipherSuiteList {
-    type V = SpecCipherSuiteList;
+impl View for PskKeyExchangeModes {
+    type V = SpecPskKeyExchangeModes;
 
     open spec fn view(&self) -> Self::V {
-        SpecCipherSuiteList {
+        SpecPskKeyExchangeModes {
             l: self.l@,
             list: self.list@,
         }
     }
 }
-pub type CipherSuiteListInner = (u16, RepeatResult<u16>);
+pub type PskKeyExchangeModesInner = (u8, RepeatResult<u8>);
 
-pub type CipherSuiteListInnerRef<'a> = (&'a u16, &'a RepeatResult<u16>);
-impl<'a> From<&'a CipherSuiteList> for CipherSuiteListInnerRef<'a> {
-    fn ex_from(m: &'a CipherSuiteList) -> CipherSuiteListInnerRef<'a> {
+pub type PskKeyExchangeModesInnerRef<'a> = (&'a u8, &'a RepeatResult<u8>);
+impl<'a> From<&'a PskKeyExchangeModes> for PskKeyExchangeModesInnerRef<'a> {
+    fn ex_from(m: &'a PskKeyExchangeModes) -> PskKeyExchangeModesInnerRef<'a> {
         (&m.l, &m.list)
     }
 }
 
-impl From<CipherSuiteListInner> for CipherSuiteList {
-    fn ex_from(m: CipherSuiteListInner) -> CipherSuiteList {
+impl From<PskKeyExchangeModesInner> for PskKeyExchangeModes {
+    fn ex_from(m: PskKeyExchangeModesInner) -> PskKeyExchangeModes {
         let (l, list) = m;
-        CipherSuiteList { l, list }
+        PskKeyExchangeModes { l, list }
     }
 }
 
-pub struct CipherSuiteListMapper;
-impl View for CipherSuiteListMapper {
+pub struct PskKeyExchangeModesMapper;
+impl View for PskKeyExchangeModesMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CipherSuiteListMapper {
-    type Src = SpecCipherSuiteListInner;
-    type Dst = SpecCipherSuiteList;
+impl SpecIso for PskKeyExchangeModesMapper {
+    type Src = SpecPskKeyExchangeModesInner;
+    type Dst = SpecPskKeyExchangeModes;
 }
-impl SpecIsoProof for CipherSuiteListMapper {
+impl SpecIsoProof for PskKeyExchangeModesMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -12465,517 +11397,738 @@ impl SpecIsoProof for CipherSuiteListMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CipherSuiteListMapper {
-    type Src = CipherSuiteListInner;
-    type Dst = CipherSuiteList;
-    type RefSrc = CipherSuiteListInnerRef<'a>;
+impl<'a> Iso<'a> for PskKeyExchangeModesMapper {
+    type Src = PskKeyExchangeModesInner;
+    type Dst = PskKeyExchangeModes;
+    type RefSrc = PskKeyExchangeModesInnerRef<'a>;
 }
 
-pub struct SpecCipherSuiteListCombinator(pub SpecCipherSuiteListCombinatorAlias);
+pub struct SpecPskKeyExchangeModesCombinator(pub SpecPskKeyExchangeModesCombinatorAlias);
 
-impl SpecCombinator for SpecCipherSuiteListCombinator {
-    type Type = SpecCipherSuiteList;
+impl SpecCombinator for SpecPskKeyExchangeModesCombinator {
+    type Type = SpecPskKeyExchangeModes;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCipherSuiteListCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCipherSuiteListCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecPskKeyExchangeModesCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPskKeyExchangeModesCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCipherSuiteListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate15206902916018849611>, AndThen<bytes::Variable, Repeat<SpecCipherSuiteCombinator>>>, CipherSuiteListMapper>;
-pub struct Predicate15206902916018849611;
-impl View for Predicate15206902916018849611 {
+pub type SpecPskKeyExchangeModesCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<SpecPskKeyExchangeModeCombinator>>>, PskKeyExchangeModesMapper>;
+pub struct Predicate13984338198318635021;
+impl View for Predicate13984338198318635021 {
     type V = Self;
 
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl Pred<u16> for Predicate15206902916018849611 {
-    fn apply(&self, i: &u16) -> bool {
+impl Pred<u8> for Predicate13984338198318635021 {
+    fn apply(&self, i: &u8) -> bool {
         let i = (*i);
-        (i >= 2 && i <= 65534)
+        (i >= 1 && i <= 255)
     }
 }
-impl SpecPred<u16> for Predicate15206902916018849611 {
-    open spec fn spec_apply(&self, i: &u16) -> bool {
+impl SpecPred<u8> for Predicate13984338198318635021 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
         let i = (*i);
-        (i >= 2 && i <= 65534)
+        (i >= 1 && i <= 255)
     }
 }
 
-pub struct CipherSuiteListCombinator(pub CipherSuiteListCombinatorAlias);
+pub struct PskKeyExchangeModesCombinator(pub PskKeyExchangeModesCombinatorAlias);
 
-impl View for CipherSuiteListCombinator {
-    type V = SpecCipherSuiteListCombinator;
-    open spec fn view(&self) -> Self::V { SpecCipherSuiteListCombinator(self.0@) }
+impl View for PskKeyExchangeModesCombinator {
+    type V = SpecPskKeyExchangeModesCombinator;
+    open spec fn view(&self) -> Self::V { SpecPskKeyExchangeModesCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CipherSuiteListCombinator {
-    type Type = CipherSuiteList;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskKeyExchangeModesCombinator {
+    type Type = PskKeyExchangeModes;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CipherSuiteListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate15206902916018849611>, AndThen<bytes::Variable, Repeat<CipherSuiteCombinator>>, CipherSuiteListCont0>, CipherSuiteListMapper>;
+}
+pub type PskKeyExchangeModesCombinatorAlias = Mapped<Pair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<PskKeyExchangeModeCombinator>>, PskKeyExchangeModesCont0>, PskKeyExchangeModesMapper>;
 
 
-pub open spec fn spec_cipher_suite_list() -> SpecCipherSuiteListCombinator {
-    SpecCipherSuiteListCombinator(
+pub open spec fn spec_psk_key_exchange_modes() -> SpecPskKeyExchangeModesCombinator {
+    SpecPskKeyExchangeModesCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate15206902916018849611 }, |deps| spec_cipher_suite_list_cont0(deps)),
-        mapper: CipherSuiteListMapper,
+        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, |deps| spec_psk_key_exchange_modes_cont0(deps)),
+        mapper: PskKeyExchangeModesMapper,
     })
 }
 
-pub open spec fn spec_cipher_suite_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecCipherSuiteCombinator>> {
+pub open spec fn spec_psk_key_exchange_modes_cont0(deps: u8) -> AndThen<bytes::Variable, Repeat<SpecPskKeyExchangeModeCombinator>> {
     let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_cipher_suite()))
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_psk_key_exchange_mode()))
 }
 
-impl View for CipherSuiteListCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecCipherSuiteCombinator>>;
+impl View for PskKeyExchangeModesCont0 {
+    type V = spec_fn(u8) -> AndThen<bytes::Variable, Repeat<SpecPskKeyExchangeModeCombinator>>;
 
     open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_cipher_suite_list_cont0(deps)
+        |deps: u8| {
+            spec_psk_key_exchange_modes_cont0(deps)
         }
     }
 }
 
                 
-pub fn cipher_suite_list<'a>() -> (o: CipherSuiteListCombinator)
-    ensures o@ == spec_cipher_suite_list(),
+pub fn psk_key_exchange_modes<'a>() -> (o: PskKeyExchangeModesCombinator)
+    ensures o@ == spec_psk_key_exchange_modes(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CipherSuiteListCombinator(
+    let combinator = PskKeyExchangeModesCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate15206902916018849611 }, CipherSuiteListCont0),
-        mapper: CipherSuiteListMapper,
-    });
-    assert({
-        &&& combinator@ == spec_cipher_suite_list()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, PskKeyExchangeModesCont0),
+        mapper: PskKeyExchangeModesMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_psk_key_exchange_modes()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_cipher_suite_list<'a>(input: &'a [u8]) -> (res: PResult<<CipherSuiteListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_psk_key_exchange_modes<'a>(input: &'a [u8]) -> (res: PResult<<PskKeyExchangeModesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_cipher_suite_list().spec_parse(input@) == Some((n as int, v@)),
-        spec_cipher_suite_list().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_psk_key_exchange_modes().spec_parse(input@) == Some((n as int, v@)),
+        spec_psk_key_exchange_modes().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_cipher_suite_list().spec_parse(input@) is None,
-        spec_cipher_suite_list().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_psk_key_exchange_modes().spec_parse(input@) is None,
+        spec_psk_key_exchange_modes().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = cipher_suite_list();
+    let combinator = psk_key_exchange_modes();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_cipher_suite_list<'a>(v: <CipherSuiteListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_psk_key_exchange_modes<'a>(v: <PskKeyExchangeModesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_cipher_suite_list().wf(v@),
+        spec_psk_key_exchange_modes().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_cipher_suite_list().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_cipher_suite_list().spec_serialize(v@))
+            &&& n == spec_psk_key_exchange_modes().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_psk_key_exchange_modes().spec_serialize(v@))
         },
 {
-    let combinator = cipher_suite_list();
+    let combinator = psk_key_exchange_modes();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn cipher_suite_list_len<'a>(v: <CipherSuiteListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn psk_key_exchange_modes_len<'a>(v: <PskKeyExchangeModesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_cipher_suite_list().wf(v@),
-        spec_cipher_suite_list().spec_serialize(v@).len() <= usize::MAX,
+        spec_psk_key_exchange_modes().wf(v@),
+        spec_psk_key_exchange_modes().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_cipher_suite_list().spec_serialize(v@).len(),
+        serialize_len == spec_psk_key_exchange_modes().spec_serialize(v@).len(),
 {
-    let combinator = cipher_suite_list();
+    let combinator = psk_key_exchange_modes();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct CipherSuiteListCont0;
-type CipherSuiteListCont0Type<'a, 'b> = &'b u16;
-type CipherSuiteListCont0SType<'a, 'x> = &'x u16;
-type CipherSuiteListCont0Input<'a, 'b, 'x> = POrSType<CipherSuiteListCont0Type<'a, 'b>, CipherSuiteListCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CipherSuiteListCont0Input<'a, 'b, 'x>> for CipherSuiteListCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<CipherSuiteCombinator>>;
+pub struct PskKeyExchangeModesCont0;
+type PskKeyExchangeModesCont0Type<'a, 'b> = &'b u8;
+type PskKeyExchangeModesCont0SType<'a, 'x> = &'x u8;
+type PskKeyExchangeModesCont0Input<'a, 'b, 'x> = POrSType<PskKeyExchangeModesCont0Type<'a, 'b>, PskKeyExchangeModesCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<PskKeyExchangeModesCont0Input<'a, 'b, 'x>> for PskKeyExchangeModesCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<PskKeyExchangeModeCombinator>>;
 
-    open spec fn requires(&self, deps: CipherSuiteListCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: PskKeyExchangeModesCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U8, predicate: Predicate13984338198318635021 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: CipherSuiteListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_cipher_suite_list_cont0(deps@)
+    open spec fn ensures(&self, deps: PskKeyExchangeModesCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_psk_key_exchange_modes_cont0(deps@)
     }
 
-    fn apply(&self, deps: CipherSuiteListCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: PskKeyExchangeModesCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(cipher_suite()))
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(psk_key_exchange_mode()))
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(cipher_suite()))
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(psk_key_exchange_mode()))
             }
         }
     }
 }
                 
-pub type SpecHostName = SpecOpaque1Ffff;
-pub type HostName<'a> = Opaque1Ffff<'a>;
-pub type HostNameRef<'a> = &'a Opaque1Ffff<'a>;
 
+pub struct SpecPskIdentity {
+    pub identity: SpecOpaque1Ffff,
+    pub obfuscated_ticket_age: u32,
+}
+
+pub type SpecPskIdentityInner = (SpecOpaque1Ffff, u32);
 
-pub struct SpecHostNameCombinator(pub SpecHostNameCombinatorAlias);
 
-impl SpecCombinator for SpecHostNameCombinator {
-    type Type = SpecHostName;
+impl SpecFrom<SpecPskIdentity> for SpecPskIdentityInner {
+    open spec fn spec_from(m: SpecPskIdentity) -> SpecPskIdentityInner {
+        (m.identity, m.obfuscated_ticket_age)
+    }
+}
+
+impl SpecFrom<SpecPskIdentityInner> for SpecPskIdentity {
+    open spec fn spec_from(m: SpecPskIdentityInner) -> SpecPskIdentity {
+        let (identity, obfuscated_ticket_age) = m;
+        SpecPskIdentity { identity, obfuscated_ticket_age }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct PskIdentity<'a> {
+    pub identity: Opaque1Ffff<'a>,
+    pub obfuscated_ticket_age: u32,
+}
+
+impl View for PskIdentity<'_> {
+    type V = SpecPskIdentity;
+
+    open spec fn view(&self) -> Self::V {
+        SpecPskIdentity {
+            identity: self.identity@,
+            obfuscated_ticket_age: self.obfuscated_ticket_age@,
+        }
+    }
+}
+pub type PskIdentityInner<'a> = (Opaque1Ffff<'a>, u32);
+
+pub type PskIdentityInnerRef<'a> = (&'a Opaque1Ffff<'a>, &'a u32);
+impl<'a> From<&'a PskIdentity<'a>> for PskIdentityInnerRef<'a> {
+    fn ex_from(m: &'a PskIdentity) -> PskIdentityInnerRef<'a> {
+        (&m.identity, &m.obfuscated_ticket_age)
+    }
+}
+
+impl<'a> From<PskIdentityInner<'a>> for PskIdentity<'a> {
+    fn ex_from(m: PskIdentityInner) -> PskIdentity {
+        let (identity, obfuscated_ticket_age) = m;
+        PskIdentity { identity, obfuscated_ticket_age }
+    }
+}
+
+pub struct PskIdentityMapper;
+impl View for PskIdentityMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for PskIdentityMapper {
+    type Src = SpecPskIdentityInner;
+    type Dst = SpecPskIdentity;
+}
+impl SpecIsoProof for PskIdentityMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for PskIdentityMapper {
+    type Src = PskIdentityInner<'a>;
+    type Dst = PskIdentity<'a>;
+    type RefSrc = PskIdentityInnerRef<'a>;
+}
+type SpecPskIdentityCombinatorAlias1 = (SpecOpaque1FfffCombinator, U32Be);
+pub struct SpecPskIdentityCombinator(pub SpecPskIdentityCombinatorAlias);
+
+impl SpecCombinator for SpecPskIdentityCombinator {
+    type Type = SpecPskIdentity;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecHostNameCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecHostNameCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecPskIdentityCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPskIdentityCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecHostNameCombinatorAlias = SpecOpaque1FfffCombinator;
+pub type SpecPskIdentityCombinatorAlias = Mapped<SpecPskIdentityCombinatorAlias1, PskIdentityMapper>;
+type PskIdentityCombinatorAlias1 = (Opaque1FfffCombinator, U32Be);
+pub struct PskIdentityCombinator1(pub PskIdentityCombinatorAlias1);
+impl View for PskIdentityCombinator1 {
+    type V = SpecPskIdentityCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(PskIdentityCombinator1, PskIdentityCombinatorAlias1);
 
-pub struct HostNameCombinator(pub HostNameCombinatorAlias);
+pub struct PskIdentityCombinator(pub PskIdentityCombinatorAlias);
 
-impl View for HostNameCombinator {
-    type V = SpecHostNameCombinator;
-    open spec fn view(&self) -> Self::V { SpecHostNameCombinator(self.0@) }
+impl View for PskIdentityCombinator {
+    type V = SpecPskIdentityCombinator;
+    open spec fn view(&self) -> Self::V { SpecPskIdentityCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HostNameCombinator {
-    type Type = HostName<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskIdentityCombinator {
+    type Type = PskIdentity<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type HostNameCombinatorAlias = Opaque1FfffCombinator;
+}
+pub type PskIdentityCombinatorAlias = Mapped<PskIdentityCombinator1, PskIdentityMapper>;
 
 
-pub open spec fn spec_host_name() -> SpecHostNameCombinator {
-    SpecHostNameCombinator(spec_opaque_1_ffff())
+pub open spec fn spec_psk_identity() -> SpecPskIdentityCombinator {
+    SpecPskIdentityCombinator(
+    Mapped {
+        inner: (spec_opaque_1_ffff(), U32Be),
+        mapper: PskIdentityMapper,
+    })
 }
 
                 
-pub fn host_name<'a>() -> (o: HostNameCombinator)
-    ensures o@ == spec_host_name(),
+pub fn psk_identity<'a>() -> (o: PskIdentityCombinator)
+    ensures o@ == spec_psk_identity(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = HostNameCombinator(opaque_1_ffff());
-    assert({
-        &&& combinator@ == spec_host_name()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = PskIdentityCombinator(
+    Mapped {
+        inner: PskIdentityCombinator1((opaque_1_ffff(), U32Be)),
+        mapper: PskIdentityMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_psk_identity()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_host_name<'a>(input: &'a [u8]) -> (res: PResult<<HostNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_psk_identity<'a>(input: &'a [u8]) -> (res: PResult<<PskIdentityCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_host_name().spec_parse(input@) == Some((n as int, v@)),
-        spec_host_name().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_psk_identity().spec_parse(input@) == Some((n as int, v@)),
+        spec_psk_identity().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_host_name().spec_parse(input@) is None,
-        spec_host_name().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = host_name();
+        res is Err ==> spec_psk_identity().spec_parse(input@) is None,
+        spec_psk_identity().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = psk_identity();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_host_name<'a>(v: <HostNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_psk_identity<'a>(v: <PskIdentityCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_host_name().wf(v@),
+        spec_psk_identity().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_host_name().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_host_name().spec_serialize(v@))
+            &&& n == spec_psk_identity().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_psk_identity().spec_serialize(v@))
         },
 {
-    let combinator = host_name();
+    let combinator = psk_identity();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn host_name_len<'a>(v: <HostNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn psk_identity_len<'a>(v: <PskIdentityCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_host_name().wf(v@),
-        spec_host_name().spec_serialize(v@).len() <= usize::MAX,
+        spec_psk_identity().wf(v@),
+        spec_psk_identity().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_host_name().spec_serialize(v@).len(),
+        serialize_len == spec_psk_identity().spec_serialize(v@).len(),
 {
-    let combinator = host_name();
+    let combinator = psk_identity();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub type SpecUnknownName = SpecOpaque1Ffff;
-pub type UnknownName<'a> = Opaque1Ffff<'a>;
-pub type UnknownNameRef<'a> = &'a Opaque1Ffff<'a>;
 
+pub struct SpecPskIdentities {
+    pub l: u16,
+    pub list: Seq<SpecPskIdentity>,
+}
+
+pub type SpecPskIdentitiesInner = (u16, Seq<SpecPskIdentity>);
 
-pub struct SpecUnknownNameCombinator(pub SpecUnknownNameCombinatorAlias);
 
-impl SpecCombinator for SpecUnknownNameCombinator {
-    type Type = SpecUnknownName;
+impl SpecFrom<SpecPskIdentities> for SpecPskIdentitiesInner {
+    open spec fn spec_from(m: SpecPskIdentities) -> SpecPskIdentitiesInner {
+        (m.l, m.list)
+    }
+}
+
+impl SpecFrom<SpecPskIdentitiesInner> for SpecPskIdentities {
+    open spec fn spec_from(m: SpecPskIdentitiesInner) -> SpecPskIdentities {
+        let (l, list) = m;
+        SpecPskIdentities { l, list }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct PskIdentities<'a> {
+    pub l: u16,
+    pub list: RepeatResult<PskIdentity<'a>>,
+}
+
+impl View for PskIdentities<'_> {
+    type V = SpecPskIdentities;
+
+    open spec fn view(&self) -> Self::V {
+        SpecPskIdentities {
+            l: self.l@,
+            list: self.list@,
+        }
+    }
+}
+pub type PskIdentitiesInner<'a> = (u16, RepeatResult<PskIdentity<'a>>);
+
+pub type PskIdentitiesInnerRef<'a> = (&'a u16, &'a RepeatResult<PskIdentity<'a>>);
+impl<'a> From<&'a PskIdentities<'a>> for PskIdentitiesInnerRef<'a> {
+    fn ex_from(m: &'a PskIdentities) -> PskIdentitiesInnerRef<'a> {
+        (&m.l, &m.list)
+    }
+}
+
+impl<'a> From<PskIdentitiesInner<'a>> for PskIdentities<'a> {
+    fn ex_from(m: PskIdentitiesInner) -> PskIdentities {
+        let (l, list) = m;
+        PskIdentities { l, list }
+    }
+}
+
+pub struct PskIdentitiesMapper;
+impl View for PskIdentitiesMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for PskIdentitiesMapper {
+    type Src = SpecPskIdentitiesInner;
+    type Dst = SpecPskIdentities;
+}
+impl SpecIsoProof for PskIdentitiesMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for PskIdentitiesMapper {
+    type Src = PskIdentitiesInner<'a>;
+    type Dst = PskIdentities<'a>;
+    type RefSrc = PskIdentitiesInnerRef<'a>;
+}
+
+pub struct SpecPskIdentitiesCombinator(pub SpecPskIdentitiesCombinatorAlias);
+
+impl SpecCombinator for SpecPskIdentitiesCombinator {
+    type Type = SpecPskIdentities;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecUnknownNameCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecUnknownNameCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecPskIdentitiesCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPskIdentitiesCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecUnknownNameCombinatorAlias = SpecOpaque1FfffCombinator;
+pub type SpecPskIdentitiesCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate22012019403780218>, AndThen<bytes::Variable, Repeat<SpecPskIdentityCombinator>>>, PskIdentitiesMapper>;
+pub struct Predicate22012019403780218;
+impl View for Predicate22012019403780218 {
+    type V = Self;
 
-pub struct UnknownNameCombinator(pub UnknownNameCombinatorAlias);
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate22012019403780218 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 7 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate22012019403780218 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 7 && i <= 65535)
+    }
+}
 
-impl View for UnknownNameCombinator {
-    type V = SpecUnknownNameCombinator;
-    open spec fn view(&self) -> Self::V { SpecUnknownNameCombinator(self.0@) }
+pub struct PskIdentitiesCombinator(pub PskIdentitiesCombinatorAlias);
+
+impl View for PskIdentitiesCombinator {
+    type V = SpecPskIdentitiesCombinator;
+    open spec fn view(&self) -> Self::V { SpecPskIdentitiesCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for UnknownNameCombinator {
-    type Type = UnknownName<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskIdentitiesCombinator {
+    type Type = PskIdentities<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type UnknownNameCombinatorAlias = Opaque1FfffCombinator;
+}
+pub type PskIdentitiesCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate22012019403780218>, AndThen<bytes::Variable, Repeat<PskIdentityCombinator>>, PskIdentitiesCont0>, PskIdentitiesMapper>;
 
 
-pub open spec fn spec_unknown_name() -> SpecUnknownNameCombinator {
-    SpecUnknownNameCombinator(spec_opaque_1_ffff())
+pub open spec fn spec_psk_identities() -> SpecPskIdentitiesCombinator {
+    SpecPskIdentitiesCombinator(
+    Mapped {
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate22012019403780218 }, |deps| spec_psk_identities_cont0(deps)),
+        mapper: PskIdentitiesMapper,
+    })
+}
+
+pub open spec fn spec_psk_identities_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecPskIdentityCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_psk_identity()))
+}
+
+impl View for PskIdentitiesCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecPskIdentityCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_psk_identities_cont0(deps)
+        }
+    }
 }
 
                 
-pub fn unknown_name<'a>() -> (o: UnknownNameCombinator)
-    ensures o@ == spec_unknown_name(),
+pub fn psk_identities<'a>() -> (o: PskIdentitiesCombinator)
+    ensures o@ == spec_psk_identities(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = UnknownNameCombinator(opaque_1_ffff());
-    assert({
-        &&& combinator@ == spec_unknown_name()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = PskIdentitiesCombinator(
+    Mapped {
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate22012019403780218 }, PskIdentitiesCont0),
+        mapper: PskIdentitiesMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_psk_identities()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_unknown_name<'a>(input: &'a [u8]) -> (res: PResult<<UnknownNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_psk_identities<'a>(input: &'a [u8]) -> (res: PResult<<PskIdentitiesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_unknown_name().spec_parse(input@) == Some((n as int, v@)),
-        spec_unknown_name().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_psk_identities().spec_parse(input@) == Some((n as int, v@)),
+        spec_psk_identities().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_unknown_name().spec_parse(input@) is None,
-        spec_unknown_name().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_psk_identities().spec_parse(input@) is None,
+        spec_psk_identities().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = unknown_name();
+    let combinator = psk_identities();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_unknown_name<'a>(v: <UnknownNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_psk_identities<'a>(v: <PskIdentitiesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_unknown_name().wf(v@),
+        spec_psk_identities().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_unknown_name().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_unknown_name().spec_serialize(v@))
+            &&& n == spec_psk_identities().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_psk_identities().spec_serialize(v@))
         },
 {
-    let combinator = unknown_name();
+    let combinator = psk_identities();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn unknown_name_len<'a>(v: <UnknownNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn psk_identities_len<'a>(v: <PskIdentitiesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_unknown_name().wf(v@),
-        spec_unknown_name().spec_serialize(v@).len() <= usize::MAX,
+        spec_psk_identities().wf(v@),
+        spec_psk_identities().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_unknown_name().spec_serialize(v@).len(),
+        serialize_len == spec_psk_identities().spec_serialize(v@).len(),
 {
-    let combinator = unknown_name();
+    let combinator = psk_identities();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
-
-pub enum SpecServerNameName {
-    HostName(SpecHostName),
-    Unrecognized(SpecUnknownName),
-}
-
-pub type SpecServerNameNameInner = Either<SpecHostName, SpecUnknownName>;
+pub struct PskIdentitiesCont0;
+type PskIdentitiesCont0Type<'a, 'b> = &'b u16;
+type PskIdentitiesCont0SType<'a, 'x> = &'x u16;
+type PskIdentitiesCont0Input<'a, 'b, 'x> = POrSType<PskIdentitiesCont0Type<'a, 'b>, PskIdentitiesCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<PskIdentitiesCont0Input<'a, 'b, 'x>> for PskIdentitiesCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<PskIdentityCombinator>>;
 
-impl SpecFrom<SpecServerNameName> for SpecServerNameNameInner {
-    open spec fn spec_from(m: SpecServerNameName) -> SpecServerNameNameInner {
-        match m {
-            SpecServerNameName::HostName(m) => Either::Left(m),
-            SpecServerNameName::Unrecognized(m) => Either::Right(m),
+    open spec fn requires(&self, deps: PskIdentitiesCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate22012019403780218 }).wf(deps@)
         }
-    }
 
-}
+    open spec fn ensures(&self, deps: PskIdentitiesCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_psk_identities_cont0(deps@)
+    }
 
-                
-impl SpecFrom<SpecServerNameNameInner> for SpecServerNameName {
-    open spec fn spec_from(m: SpecServerNameNameInner) -> SpecServerNameName {
-        match m {
-            Either::Left(m) => SpecServerNameName::HostName(m),
-            Either::Right(m) => SpecServerNameName::Unrecognized(m),
+    fn apply(&self, deps: PskIdentitiesCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(psk_identity()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(psk_identity()))
+            }
         }
     }
-
 }
+                
 
+pub struct SpecPskBinderEntry {
+    pub l: u8,
+    pub entries: Seq<u8>,
+}
 
+pub type SpecPskBinderEntryInner = (u8, Seq<u8>);
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ServerNameName<'a> {
-    HostName(HostName<'a>),
-    Unrecognized(UnknownName<'a>),
+
+impl SpecFrom<SpecPskBinderEntry> for SpecPskBinderEntryInner {
+    open spec fn spec_from(m: SpecPskBinderEntry) -> SpecPskBinderEntryInner {
+        (m.l, m.entries)
+    }
 }
 
-pub type ServerNameNameInner<'a> = Either<HostName<'a>, UnknownName<'a>>;
+impl SpecFrom<SpecPskBinderEntryInner> for SpecPskBinderEntry {
+    open spec fn spec_from(m: SpecPskBinderEntryInner) -> SpecPskBinderEntry {
+        let (l, entries) = m;
+        SpecPskBinderEntry { l, entries }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub type ServerNameNameInnerRef<'a> = Either<&'a HostName<'a>, &'a UnknownName<'a>>;
+pub struct PskBinderEntry<'a> {
+    pub l: u8,
+    pub entries: &'a [u8],
+}
 
+impl View for PskBinderEntry<'_> {
+    type V = SpecPskBinderEntry;
 
-impl<'a> View for ServerNameName<'a> {
-    type V = SpecServerNameName;
     open spec fn view(&self) -> Self::V {
-        match self {
-            ServerNameName::HostName(m) => SpecServerNameName::HostName(m@),
-            ServerNameName::Unrecognized(m) => SpecServerNameName::Unrecognized(m@),
+        SpecPskBinderEntry {
+            l: self.l@,
+            entries: self.entries@,
         }
     }
 }
+pub type PskBinderEntryInner<'a> = (u8, &'a [u8]);
 
-
-impl<'a> From<&'a ServerNameName<'a>> for ServerNameNameInnerRef<'a> {
-    fn ex_from(m: &'a ServerNameName<'a>) -> ServerNameNameInnerRef<'a> {
-        match m {
-            ServerNameName::HostName(m) => Either::Left(m),
-            ServerNameName::Unrecognized(m) => Either::Right(m),
-        }
+pub type PskBinderEntryInnerRef<'a> = (&'a u8, &'a &'a [u8]);
+impl<'a> From<&'a PskBinderEntry<'a>> for PskBinderEntryInnerRef<'a> {
+    fn ex_from(m: &'a PskBinderEntry) -> PskBinderEntryInnerRef<'a> {
+        (&m.l, &m.entries)
     }
-
 }
 
-impl<'a> From<ServerNameNameInner<'a>> for ServerNameName<'a> {
-    fn ex_from(m: ServerNameNameInner<'a>) -> ServerNameName<'a> {
-        match m {
-            Either::Left(m) => ServerNameName::HostName(m),
-            Either::Right(m) => ServerNameName::Unrecognized(m),
-        }
+impl<'a> From<PskBinderEntryInner<'a>> for PskBinderEntry<'a> {
+    fn ex_from(m: PskBinderEntryInner) -> PskBinderEntry {
+        let (l, entries) = m;
+        PskBinderEntry { l, entries }
     }
-    
 }
 
-
-pub struct ServerNameNameMapper;
-impl View for ServerNameNameMapper {
+pub struct PskBinderEntryMapper;
+impl View for PskBinderEntryMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ServerNameNameMapper {
-    type Src = SpecServerNameNameInner;
-    type Dst = SpecServerNameName;
+impl SpecIso for PskBinderEntryMapper {
+    type Src = SpecPskBinderEntryInner;
+    type Dst = SpecPskBinderEntry;
 }
-impl SpecIsoProof for ServerNameNameMapper {
+impl SpecIsoProof for PskBinderEntryMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -12983,197 +12136,265 @@ impl SpecIsoProof for ServerNameNameMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ServerNameNameMapper {
-    type Src = ServerNameNameInner<'a>;
-    type Dst = ServerNameName<'a>;
-    type RefSrc = ServerNameNameInnerRef<'a>;
+impl<'a> Iso<'a> for PskBinderEntryMapper {
+    type Src = PskBinderEntryInner<'a>;
+    type Dst = PskBinderEntry<'a>;
+    type RefSrc = PskBinderEntryInnerRef<'a>;
 }
 
-type SpecServerNameNameCombinatorAlias1 = Choice<Cond<SpecHostNameCombinator>, Cond<SpecUnknownNameCombinator>>;
-pub struct SpecServerNameNameCombinator(pub SpecServerNameNameCombinatorAlias);
+pub struct SpecPskBinderEntryCombinator(pub SpecPskBinderEntryCombinatorAlias);
 
-impl SpecCombinator for SpecServerNameNameCombinator {
-    type Type = SpecServerNameName;
+impl SpecCombinator for SpecPskBinderEntryCombinator {
+    type Type = SpecPskBinderEntry;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecServerNameNameCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecServerNameNameCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecPskBinderEntryCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPskBinderEntryCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecServerNameNameCombinatorAlias = Mapped<SpecServerNameNameCombinatorAlias1, ServerNameNameMapper>;
-type ServerNameNameCombinatorAlias1 = Choice<Cond<HostNameCombinator>, Cond<UnknownNameCombinator>>;
-pub struct ServerNameNameCombinator1(pub ServerNameNameCombinatorAlias1);
-impl View for ServerNameNameCombinator1 {
-    type V = SpecServerNameNameCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
+pub type SpecPskBinderEntryCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate12415296748708102903>, bytes::Variable>, PskBinderEntryMapper>;
+pub struct Predicate12415296748708102903;
+impl View for Predicate12415296748708102903 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate12415296748708102903 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 32 && i <= 255)
+    }
+}
+impl SpecPred<u8> for Predicate12415296748708102903 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i >= 32 && i <= 255)
+    }
 }
-impl_wrapper_combinator!(ServerNameNameCombinator1, ServerNameNameCombinatorAlias1);
 
-pub struct ServerNameNameCombinator(pub ServerNameNameCombinatorAlias);
+pub struct PskBinderEntryCombinator(pub PskBinderEntryCombinatorAlias);
 
-impl View for ServerNameNameCombinator {
-    type V = SpecServerNameNameCombinator;
-    open spec fn view(&self) -> Self::V { SpecServerNameNameCombinator(self.0@) }
+impl View for PskBinderEntryCombinator {
+    type V = SpecPskBinderEntryCombinator;
+    open spec fn view(&self) -> Self::V { SpecPskBinderEntryCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerNameNameCombinator {
-    type Type = ServerNameName<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskBinderEntryCombinator {
+    type Type = PskBinderEntry<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ServerNameNameCombinatorAlias = Mapped<ServerNameNameCombinator1, ServerNameNameMapper>;
+}
+pub type PskBinderEntryCombinatorAlias = Mapped<Pair<Refined<U8, Predicate12415296748708102903>, bytes::Variable, PskBinderEntryCont0>, PskBinderEntryMapper>;
 
 
-pub open spec fn spec_server_name_name(name_type: u8) -> SpecServerNameNameCombinator {
-    SpecServerNameNameCombinator(Mapped { inner: Choice(Cond { cond: name_type == NameType::SPEC_HostName, inner: spec_host_name() }, Cond { cond: !(name_type == NameType::SPEC_HostName), inner: spec_unknown_name() }), mapper: ServerNameNameMapper })
+pub open spec fn spec_psk_binder_entry() -> SpecPskBinderEntryCombinator {
+    SpecPskBinderEntryCombinator(
+    Mapped {
+        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate12415296748708102903 }, |deps| spec_psk_binder_entry_cont0(deps)),
+        mapper: PskBinderEntryMapper,
+    })
 }
 
-pub fn server_name_name<'a>(name_type: u8) -> (o: ServerNameNameCombinator)
-    ensures o@ == spec_server_name_name(name_type@),
+pub open spec fn spec_psk_binder_entry_cont0(deps: u8) -> bytes::Variable {
+    let l = deps;
+    bytes::Variable((usize::spec_from(l)) as usize)
+}
+
+impl View for PskBinderEntryCont0 {
+    type V = spec_fn(u8) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_psk_binder_entry_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn psk_binder_entry<'a>() -> (o: PskBinderEntryCombinator)
+    ensures o@ == spec_psk_binder_entry(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ServerNameNameCombinator(Mapped { inner: ServerNameNameCombinator1(Choice::new(Cond { cond: name_type == NameType::HostName, inner: host_name() }, Cond { cond: !(name_type == NameType::HostName), inner: unknown_name() })), mapper: ServerNameNameMapper });
-    assert({
-        &&& combinator@ == spec_server_name_name(name_type@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = PskBinderEntryCombinator(
+    Mapped {
+        inner: Pair::new(Refined { inner: U8, predicate: Predicate12415296748708102903 }, PskBinderEntryCont0),
+        mapper: PskBinderEntryMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_psk_binder_entry()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_server_name_name<'a>(input: &'a [u8], name_type: u8) -> (res: PResult<<ServerNameNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_psk_binder_entry<'a>(input: &'a [u8]) -> (res: PResult<<PskBinderEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_server_name_name(name_type@).spec_parse(input@) == Some((n as int, v@)),
-        spec_server_name_name(name_type@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_psk_binder_entry().spec_parse(input@) == Some((n as int, v@)),
+        spec_psk_binder_entry().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_server_name_name(name_type@).spec_parse(input@) is None,
-        spec_server_name_name(name_type@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_psk_binder_entry().spec_parse(input@) is None,
+        spec_psk_binder_entry().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = server_name_name( name_type );
+    let combinator = psk_binder_entry();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_server_name_name<'a>(v: <ServerNameNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, name_type: u8) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_psk_binder_entry<'a>(v: <PskBinderEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_server_name_name(name_type@).wf(v@),
+        spec_psk_binder_entry().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_server_name_name(name_type@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_server_name_name(name_type@).spec_serialize(v@))
+            &&& n == spec_psk_binder_entry().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_psk_binder_entry().spec_serialize(v@))
         },
 {
-    let combinator = server_name_name( name_type );
-    combinator.serialize(v, data, pos)
+    let combinator = psk_binder_entry();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn server_name_name_len<'a>(v: <ServerNameNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, name_type: u8) -> (serialize_len: usize)
+pub fn psk_binder_entry_len<'a>(v: <PskBinderEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_server_name_name(name_type@).wf(v@),
-        spec_server_name_name(name_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_psk_binder_entry().wf(v@),
+        spec_psk_binder_entry().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_server_name_name(name_type@).spec_serialize(v@).len(),
+        serialize_len == spec_psk_binder_entry().spec_serialize(v@).len(),
 {
-    let combinator = server_name_name( name_type );
+    let combinator = psk_binder_entry();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct PskBinderEntryCont0;
+type PskBinderEntryCont0Type<'a, 'b> = &'b u8;
+type PskBinderEntryCont0SType<'a, 'x> = &'x u8;
+type PskBinderEntryCont0Input<'a, 'b, 'x> = POrSType<PskBinderEntryCont0Type<'a, 'b>, PskBinderEntryCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<PskBinderEntryCont0Input<'a, 'b, 'x>> for PskBinderEntryCont0 {
+    type Output = bytes::Variable;
 
-pub struct SpecServerName {
-    pub name_type: u8,
-    pub name: SpecServerNameName,
+    open spec fn requires(&self, deps: PskBinderEntryCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U8, predicate: Predicate12415296748708102903 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: PskBinderEntryCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_psk_binder_entry_cont0(deps@)
+    }
+
+    fn apply(&self, deps: PskBinderEntryCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
+            }
+        }
+    }
 }
+                
 
-pub type SpecServerNameInner = (u8, SpecServerNameName);
+pub struct SpecPskBinderEntries {
+    pub l: u16,
+    pub list: Seq<SpecPskBinderEntry>,
+}
 
+pub type SpecPskBinderEntriesInner = (u16, Seq<SpecPskBinderEntry>);
 
-impl SpecFrom<SpecServerName> for SpecServerNameInner {
-    open spec fn spec_from(m: SpecServerName) -> SpecServerNameInner {
-        (m.name_type, m.name)
+
+impl SpecFrom<SpecPskBinderEntries> for SpecPskBinderEntriesInner {
+    open spec fn spec_from(m: SpecPskBinderEntries) -> SpecPskBinderEntriesInner {
+        (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecServerNameInner> for SpecServerName {
-    open spec fn spec_from(m: SpecServerNameInner) -> SpecServerName {
-        let (name_type, name) = m;
-        SpecServerName { name_type, name }
+impl SpecFrom<SpecPskBinderEntriesInner> for SpecPskBinderEntries {
+    open spec fn spec_from(m: SpecPskBinderEntriesInner) -> SpecPskBinderEntries {
+        let (l, list) = m;
+        SpecPskBinderEntries { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ServerName<'a> {
-    pub name_type: u8,
-    pub name: ServerNameName<'a>,
+pub struct PskBinderEntries<'a> {
+    pub l: u16,
+    pub list: RepeatResult<PskBinderEntry<'a>>,
 }
 
-impl View for ServerName<'_> {
-    type V = SpecServerName;
+impl View for PskBinderEntries<'_> {
+    type V = SpecPskBinderEntries;
 
     open spec fn view(&self) -> Self::V {
-        SpecServerName {
-            name_type: self.name_type@,
-            name: self.name@,
+        SpecPskBinderEntries {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
-pub type ServerNameInner<'a> = (u8, ServerNameName<'a>);
+pub type PskBinderEntriesInner<'a> = (u16, RepeatResult<PskBinderEntry<'a>>);
 
-pub type ServerNameInnerRef<'a> = (&'a u8, &'a ServerNameName<'a>);
-impl<'a> From<&'a ServerName<'a>> for ServerNameInnerRef<'a> {
-    fn ex_from(m: &'a ServerName) -> ServerNameInnerRef<'a> {
-        (&m.name_type, &m.name)
+pub type PskBinderEntriesInnerRef<'a> = (&'a u16, &'a RepeatResult<PskBinderEntry<'a>>);
+impl<'a> From<&'a PskBinderEntries<'a>> for PskBinderEntriesInnerRef<'a> {
+    fn ex_from(m: &'a PskBinderEntries) -> PskBinderEntriesInnerRef<'a> {
+        (&m.l, &m.list)
     }
 }
 
-impl<'a> From<ServerNameInner<'a>> for ServerName<'a> {
-    fn ex_from(m: ServerNameInner) -> ServerName {
-        let (name_type, name) = m;
-        ServerName { name_type, name }
+impl<'a> From<PskBinderEntriesInner<'a>> for PskBinderEntries<'a> {
+    fn ex_from(m: PskBinderEntriesInner) -> PskBinderEntries {
+        let (l, list) = m;
+        PskBinderEntries { l, list }
     }
 }
 
-pub struct ServerNameMapper;
-impl View for ServerNameMapper {
+pub struct PskBinderEntriesMapper;
+impl View for PskBinderEntriesMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ServerNameMapper {
-    type Src = SpecServerNameInner;
-    type Dst = SpecServerName;
+impl SpecIso for PskBinderEntriesMapper {
+    type Src = SpecPskBinderEntriesInner;
+    type Dst = SpecPskBinderEntries;
 }
-impl SpecIsoProof for ServerNameMapper {
+impl SpecIsoProof for PskBinderEntriesMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -13181,241 +12402,265 @@ impl SpecIsoProof for ServerNameMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ServerNameMapper {
-    type Src = ServerNameInner<'a>;
-    type Dst = ServerName<'a>;
-    type RefSrc = ServerNameInnerRef<'a>;
+impl<'a> Iso<'a> for PskBinderEntriesMapper {
+    type Src = PskBinderEntriesInner<'a>;
+    type Dst = PskBinderEntries<'a>;
+    type RefSrc = PskBinderEntriesInnerRef<'a>;
 }
 
-pub struct SpecServerNameCombinator(pub SpecServerNameCombinatorAlias);
+pub struct SpecPskBinderEntriesCombinator(pub SpecPskBinderEntriesCombinatorAlias);
 
-impl SpecCombinator for SpecServerNameCombinator {
-    type Type = SpecServerName;
+impl SpecCombinator for SpecPskBinderEntriesCombinator {
+    type Type = SpecPskBinderEntries;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecServerNameCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecServerNameCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecPskBinderEntriesCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPskBinderEntriesCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecServerNameCombinatorAlias = Mapped<SpecPair<SpecNameTypeCombinator, SpecServerNameNameCombinator>, ServerNameMapper>;
+pub type SpecPskBinderEntriesCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate2895184764579107747>, AndThen<bytes::Variable, Repeat<SpecPskBinderEntryCombinator>>>, PskBinderEntriesMapper>;
+pub struct Predicate2895184764579107747;
+impl View for Predicate2895184764579107747 {
+    type V = Self;
 
-pub struct ServerNameCombinator(pub ServerNameCombinatorAlias);
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate2895184764579107747 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 33 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate2895184764579107747 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 33 && i <= 65535)
+    }
+}
 
-impl View for ServerNameCombinator {
-    type V = SpecServerNameCombinator;
-    open spec fn view(&self) -> Self::V { SpecServerNameCombinator(self.0@) }
+pub struct PskBinderEntriesCombinator(pub PskBinderEntriesCombinatorAlias);
+
+impl View for PskBinderEntriesCombinator {
+    type V = SpecPskBinderEntriesCombinator;
+    open spec fn view(&self) -> Self::V { SpecPskBinderEntriesCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerNameCombinator {
-    type Type = ServerName<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskBinderEntriesCombinator {
+    type Type = PskBinderEntries<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ServerNameCombinatorAlias = Mapped<Pair<NameTypeCombinator, ServerNameNameCombinator, ServerNameCont0>, ServerNameMapper>;
+}
+pub type PskBinderEntriesCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate2895184764579107747>, AndThen<bytes::Variable, Repeat<PskBinderEntryCombinator>>, PskBinderEntriesCont0>, PskBinderEntriesMapper>;
 
 
-pub open spec fn spec_server_name() -> SpecServerNameCombinator {
-    SpecServerNameCombinator(
+pub open spec fn spec_psk_binder_entries() -> SpecPskBinderEntriesCombinator {
+    SpecPskBinderEntriesCombinator(
     Mapped {
-        inner: Pair::spec_new(spec_name_type(), |deps| spec_server_name_cont0(deps)),
-        mapper: ServerNameMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate2895184764579107747 }, |deps| spec_psk_binder_entries_cont0(deps)),
+        mapper: PskBinderEntriesMapper,
     })
 }
 
-pub open spec fn spec_server_name_cont0(deps: u8) -> SpecServerNameNameCombinator {
-    let name_type = deps;
-    spec_server_name_name(name_type)
+pub open spec fn spec_psk_binder_entries_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecPskBinderEntryCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_psk_binder_entry()))
 }
 
-impl View for ServerNameCont0 {
-    type V = spec_fn(u8) -> SpecServerNameNameCombinator;
+impl View for PskBinderEntriesCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecPskBinderEntryCombinator>>;
 
     open spec fn view(&self) -> Self::V {
-        |deps: u8| {
-            spec_server_name_cont0(deps)
+        |deps: u16| {
+            spec_psk_binder_entries_cont0(deps)
         }
     }
 }
 
                 
-pub fn server_name<'a>() -> (o: ServerNameCombinator)
-    ensures o@ == spec_server_name(),
+pub fn psk_binder_entries<'a>() -> (o: PskBinderEntriesCombinator)
+    ensures o@ == spec_psk_binder_entries(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ServerNameCombinator(
+    let combinator = PskBinderEntriesCombinator(
     Mapped {
-        inner: Pair::new(name_type(), ServerNameCont0),
-        mapper: ServerNameMapper,
-    });
-    assert({
-        &&& combinator@ == spec_server_name()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate2895184764579107747 }, PskBinderEntriesCont0),
+        mapper: PskBinderEntriesMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_psk_binder_entries()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_server_name<'a>(input: &'a [u8]) -> (res: PResult<<ServerNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_psk_binder_entries<'a>(input: &'a [u8]) -> (res: PResult<<PskBinderEntriesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_server_name().spec_parse(input@) == Some((n as int, v@)),
-        spec_server_name().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_psk_binder_entries().spec_parse(input@) == Some((n as int, v@)),
+        spec_psk_binder_entries().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_server_name().spec_parse(input@) is None,
-        spec_server_name().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_psk_binder_entries().spec_parse(input@) is None,
+        spec_psk_binder_entries().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = server_name();
+    let combinator = psk_binder_entries();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_server_name<'a>(v: <ServerNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_psk_binder_entries<'a>(v: <PskBinderEntriesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_server_name().wf(v@),
+        spec_psk_binder_entries().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_server_name().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_server_name().spec_serialize(v@))
+            &&& n == spec_psk_binder_entries().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_psk_binder_entries().spec_serialize(v@))
         },
 {
-    let combinator = server_name();
+    let combinator = psk_binder_entries();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn server_name_len<'a>(v: <ServerNameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn psk_binder_entries_len<'a>(v: <PskBinderEntriesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_server_name().wf(v@),
-        spec_server_name().spec_serialize(v@).len() <= usize::MAX,
+        spec_psk_binder_entries().wf(v@),
+        spec_psk_binder_entries().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_server_name().spec_serialize(v@).len(),
+        serialize_len == spec_psk_binder_entries().spec_serialize(v@).len(),
 {
-    let combinator = server_name();
+    let combinator = psk_binder_entries();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ServerNameCont0;
-type ServerNameCont0Type<'a, 'b> = &'b u8;
-type ServerNameCont0SType<'a, 'x> = &'x u8;
-type ServerNameCont0Input<'a, 'b, 'x> = POrSType<ServerNameCont0Type<'a, 'b>, ServerNameCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ServerNameCont0Input<'a, 'b, 'x>> for ServerNameCont0 {
-    type Output = ServerNameNameCombinator;
+pub struct PskBinderEntriesCont0;
+type PskBinderEntriesCont0Type<'a, 'b> = &'b u16;
+type PskBinderEntriesCont0SType<'a, 'x> = &'x u16;
+type PskBinderEntriesCont0Input<'a, 'b, 'x> = POrSType<PskBinderEntriesCont0Type<'a, 'b>, PskBinderEntriesCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<PskBinderEntriesCont0Input<'a, 'b, 'x>> for PskBinderEntriesCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<PskBinderEntryCombinator>>;
 
-    open spec fn requires(&self, deps: ServerNameCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: PskBinderEntriesCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate2895184764579107747 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: ServerNameCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_server_name_cont0(deps@)
+    open spec fn ensures(&self, deps: PskBinderEntriesCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_psk_binder_entries_cont0(deps@)
     }
 
-    fn apply(&self, deps: ServerNameCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: PskBinderEntriesCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let name_type = *deps;
-                server_name_name(name_type)
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(psk_binder_entry()))
             }
             POrSType::S(deps) => {
-                let name_type = deps;
-                let name_type = *name_type;
-                server_name_name(name_type)
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(psk_binder_entry()))
             }
         }
     }
 }
                 
 
-pub struct SpecServerNameList {
-    pub l: u16,
-    pub list: Seq<SpecServerName>,
+pub struct SpecOfferedPsks {
+    pub identities: SpecPskIdentities,
+    pub binders: SpecPskBinderEntries,
 }
 
-pub type SpecServerNameListInner = (u16, Seq<SpecServerName>);
+pub type SpecOfferedPsksInner = (SpecPskIdentities, SpecPskBinderEntries);
 
 
-impl SpecFrom<SpecServerNameList> for SpecServerNameListInner {
-    open spec fn spec_from(m: SpecServerNameList) -> SpecServerNameListInner {
-        (m.l, m.list)
+impl SpecFrom<SpecOfferedPsks> for SpecOfferedPsksInner {
+    open spec fn spec_from(m: SpecOfferedPsks) -> SpecOfferedPsksInner {
+        (m.identities, m.binders)
     }
 }
 
-impl SpecFrom<SpecServerNameListInner> for SpecServerNameList {
-    open spec fn spec_from(m: SpecServerNameListInner) -> SpecServerNameList {
-        let (l, list) = m;
-        SpecServerNameList { l, list }
+impl SpecFrom<SpecOfferedPsksInner> for SpecOfferedPsks {
+    open spec fn spec_from(m: SpecOfferedPsksInner) -> SpecOfferedPsks {
+        let (identities, binders) = m;
+        SpecOfferedPsks { identities, binders }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ServerNameList<'a> {
-    pub l: u16,
-    pub list: RepeatResult<ServerName<'a>>,
+pub struct OfferedPsks<'a> {
+    pub identities: PskIdentities<'a>,
+    pub binders: PskBinderEntries<'a>,
 }
 
-impl View for ServerNameList<'_> {
-    type V = SpecServerNameList;
+impl View for OfferedPsks<'_> {
+    type V = SpecOfferedPsks;
 
     open spec fn view(&self) -> Self::V {
-        SpecServerNameList {
-            l: self.l@,
-            list: self.list@,
+        SpecOfferedPsks {
+            identities: self.identities@,
+            binders: self.binders@,
         }
     }
 }
-pub type ServerNameListInner<'a> = (u16, RepeatResult<ServerName<'a>>);
+pub type OfferedPsksInner<'a> = (PskIdentities<'a>, PskBinderEntries<'a>);
 
-pub type ServerNameListInnerRef<'a> = (&'a u16, &'a RepeatResult<ServerName<'a>>);
-impl<'a> From<&'a ServerNameList<'a>> for ServerNameListInnerRef<'a> {
-    fn ex_from(m: &'a ServerNameList) -> ServerNameListInnerRef<'a> {
-        (&m.l, &m.list)
+pub type OfferedPsksInnerRef<'a> = (&'a PskIdentities<'a>, &'a PskBinderEntries<'a>);
+impl<'a> From<&'a OfferedPsks<'a>> for OfferedPsksInnerRef<'a> {
+    fn ex_from(m: &'a OfferedPsks) -> OfferedPsksInnerRef<'a> {
+        (&m.identities, &m.binders)
     }
 }
 
-impl<'a> From<ServerNameListInner<'a>> for ServerNameList<'a> {
-    fn ex_from(m: ServerNameListInner) -> ServerNameList {
-        let (l, list) = m;
-        ServerNameList { l, list }
+impl<'a> From<OfferedPsksInner<'a>> for OfferedPsks<'a> {
+    fn ex_from(m: OfferedPsksInner) -> OfferedPsks {
+        let (identities, binders) = m;
+        OfferedPsks { identities, binders }
     }
 }
 
-pub struct ServerNameListMapper;
-impl View for ServerNameListMapper {
+pub struct OfferedPsksMapper;
+impl View for OfferedPsksMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ServerNameListMapper {
-    type Src = SpecServerNameListInner;
-    type Dst = SpecServerNameList;
+impl SpecIso for OfferedPsksMapper {
+    type Src = SpecOfferedPsksInner;
+    type Dst = SpecOfferedPsks;
 }
-impl SpecIsoProof for ServerNameListMapper {
+impl SpecIsoProof for OfferedPsksMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -13423,241 +12668,203 @@ impl SpecIsoProof for ServerNameListMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ServerNameListMapper {
-    type Src = ServerNameListInner<'a>;
-    type Dst = ServerNameList<'a>;
-    type RefSrc = ServerNameListInnerRef<'a>;
-}
-
-pub struct SpecServerNameListCombinator(pub SpecServerNameListCombinatorAlias);
+impl<'a> Iso<'a> for OfferedPsksMapper {
+    type Src = OfferedPsksInner<'a>;
+    type Dst = OfferedPsks<'a>;
+    type RefSrc = OfferedPsksInnerRef<'a>;
+}
+type SpecOfferedPsksCombinatorAlias1 = (SpecPskIdentitiesCombinator, SpecPskBinderEntriesCombinator);
+pub struct SpecOfferedPsksCombinator(pub SpecOfferedPsksCombinatorAlias);
 
-impl SpecCombinator for SpecServerNameListCombinator {
-    type Type = SpecServerNameList;
+impl SpecCombinator for SpecOfferedPsksCombinator {
+    type Type = SpecOfferedPsks;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecServerNameListCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecServerNameListCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOfferedPsksCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOfferedPsksCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecServerNameListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate16977634203518580913>, AndThen<bytes::Variable, Repeat<SpecServerNameCombinator>>>, ServerNameListMapper>;
+pub type SpecOfferedPsksCombinatorAlias = Mapped<SpecOfferedPsksCombinatorAlias1, OfferedPsksMapper>;
+type OfferedPsksCombinatorAlias1 = (PskIdentitiesCombinator, PskBinderEntriesCombinator);
+pub struct OfferedPsksCombinator1(pub OfferedPsksCombinatorAlias1);
+impl View for OfferedPsksCombinator1 {
+    type V = SpecOfferedPsksCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(OfferedPsksCombinator1, OfferedPsksCombinatorAlias1);
 
-pub struct ServerNameListCombinator(pub ServerNameListCombinatorAlias);
+pub struct OfferedPsksCombinator(pub OfferedPsksCombinatorAlias);
 
-impl View for ServerNameListCombinator {
-    type V = SpecServerNameListCombinator;
-    open spec fn view(&self) -> Self::V { SpecServerNameListCombinator(self.0@) }
+impl View for OfferedPsksCombinator {
+    type V = SpecOfferedPsksCombinator;
+    open spec fn view(&self) -> Self::V { SpecOfferedPsksCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerNameListCombinator {
-    type Type = ServerNameList<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OfferedPsksCombinator {
+    type Type = OfferedPsks<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ServerNameListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate16977634203518580913>, AndThen<bytes::Variable, Repeat<ServerNameCombinator>>, ServerNameListCont0>, ServerNameListMapper>;
+}
+pub type OfferedPsksCombinatorAlias = Mapped<OfferedPsksCombinator1, OfferedPsksMapper>;
 
 
-pub open spec fn spec_server_name_list() -> SpecServerNameListCombinator {
-    SpecServerNameListCombinator(
+pub open spec fn spec_offered_psks() -> SpecOfferedPsksCombinator {
+    SpecOfferedPsksCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate16977634203518580913 }, |deps| spec_server_name_list_cont0(deps)),
-        mapper: ServerNameListMapper,
+        inner: (spec_psk_identities(), spec_psk_binder_entries()),
+        mapper: OfferedPsksMapper,
     })
 }
 
-pub open spec fn spec_server_name_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecServerNameCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_server_name()))
-}
-
-impl View for ServerNameListCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecServerNameCombinator>>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_server_name_list_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn server_name_list<'a>() -> (o: ServerNameListCombinator)
-    ensures o@ == spec_server_name_list(),
+pub fn offered_psks<'a>() -> (o: OfferedPsksCombinator)
+    ensures o@ == spec_offered_psks(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ServerNameListCombinator(
+    let combinator = OfferedPsksCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate16977634203518580913 }, ServerNameListCont0),
-        mapper: ServerNameListMapper,
-    });
-    assert({
-        &&& combinator@ == spec_server_name_list()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: OfferedPsksCombinator1((psk_identities(), psk_binder_entries())),
+        mapper: OfferedPsksMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_offered_psks()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_server_name_list<'a>(input: &'a [u8]) -> (res: PResult<<ServerNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_offered_psks<'a>(input: &'a [u8]) -> (res: PResult<<OfferedPsksCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_server_name_list().spec_parse(input@) == Some((n as int, v@)),
-        spec_server_name_list().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_offered_psks().spec_parse(input@) == Some((n as int, v@)),
+        spec_offered_psks().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_server_name_list().spec_parse(input@) is None,
-        spec_server_name_list().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_offered_psks().spec_parse(input@) is None,
+        spec_offered_psks().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = server_name_list();
+    let combinator = offered_psks();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_server_name_list<'a>(v: <ServerNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_offered_psks<'a>(v: <OfferedPsksCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_server_name_list().wf(v@),
+        spec_offered_psks().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_server_name_list().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_server_name_list().spec_serialize(v@))
+            &&& n == spec_offered_psks().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_offered_psks().spec_serialize(v@))
         },
 {
-    let combinator = server_name_list();
+    let combinator = offered_psks();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn server_name_list_len<'a>(v: <ServerNameListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn offered_psks_len<'a>(v: <OfferedPsksCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_server_name_list().wf(v@),
-        spec_server_name_list().spec_serialize(v@).len() <= usize::MAX,
+        spec_offered_psks().wf(v@),
+        spec_offered_psks().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_server_name_list().spec_serialize(v@).len(),
+        serialize_len == spec_offered_psks().spec_serialize(v@).len(),
 {
-    let combinator = server_name_list();
+    let combinator = offered_psks();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ServerNameListCont0;
-type ServerNameListCont0Type<'a, 'b> = &'b u16;
-type ServerNameListCont0SType<'a, 'x> = &'x u16;
-type ServerNameListCont0Input<'a, 'b, 'x> = POrSType<ServerNameListCont0Type<'a, 'b>, ServerNameListCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ServerNameListCont0Input<'a, 'b, 'x>> for ServerNameListCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<ServerNameCombinator>>;
-
-    open spec fn requires(&self, deps: ServerNameListCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: ServerNameListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_server_name_list_cont0(deps@)
-    }
-
-    fn apply(&self, deps: ServerNameListCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(server_name()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(server_name()))
-            }
-        }
-    }
-}
                 
 
-pub struct SpecSignatureSchemeList {
-    pub l: u16,
-    pub list: Seq<u16>,
+pub struct SpecPreSharedKeyClientExtension {
+    pub offers: SpecOfferedPsks,
 }
 
-pub type SpecSignatureSchemeListInner = (u16, Seq<u16>);
+pub type SpecPreSharedKeyClientExtensionInner = SpecOfferedPsks;
 
 
-impl SpecFrom<SpecSignatureSchemeList> for SpecSignatureSchemeListInner {
-    open spec fn spec_from(m: SpecSignatureSchemeList) -> SpecSignatureSchemeListInner {
-        (m.l, m.list)
+impl SpecFrom<SpecPreSharedKeyClientExtension> for SpecPreSharedKeyClientExtensionInner {
+    open spec fn spec_from(m: SpecPreSharedKeyClientExtension) -> SpecPreSharedKeyClientExtensionInner {
+        m.offers
     }
 }
 
-impl SpecFrom<SpecSignatureSchemeListInner> for SpecSignatureSchemeList {
-    open spec fn spec_from(m: SpecSignatureSchemeListInner) -> SpecSignatureSchemeList {
-        let (l, list) = m;
-        SpecSignatureSchemeList { l, list }
+impl SpecFrom<SpecPreSharedKeyClientExtensionInner> for SpecPreSharedKeyClientExtension {
+    open spec fn spec_from(m: SpecPreSharedKeyClientExtensionInner) -> SpecPreSharedKeyClientExtension {
+        let offers = m;
+        SpecPreSharedKeyClientExtension { offers }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct SignatureSchemeList {
-    pub l: u16,
-    pub list: RepeatResult<u16>,
+pub struct PreSharedKeyClientExtension<'a> {
+    pub offers: OfferedPsks<'a>,
 }
 
-impl View for SignatureSchemeList {
-    type V = SpecSignatureSchemeList;
+impl View for PreSharedKeyClientExtension<'_> {
+    type V = SpecPreSharedKeyClientExtension;
 
     open spec fn view(&self) -> Self::V {
-        SpecSignatureSchemeList {
-            l: self.l@,
-            list: self.list@,
+        SpecPreSharedKeyClientExtension {
+            offers: self.offers@,
         }
     }
 }
-pub type SignatureSchemeListInner = (u16, RepeatResult<u16>);
+pub type PreSharedKeyClientExtensionInner<'a> = OfferedPsks<'a>;
 
-pub type SignatureSchemeListInnerRef<'a> = (&'a u16, &'a RepeatResult<u16>);
-impl<'a> From<&'a SignatureSchemeList> for SignatureSchemeListInnerRef<'a> {
-    fn ex_from(m: &'a SignatureSchemeList) -> SignatureSchemeListInnerRef<'a> {
-        (&m.l, &m.list)
+pub type PreSharedKeyClientExtensionInnerRef<'a> = &'a OfferedPsks<'a>;
+impl<'a> From<&'a PreSharedKeyClientExtension<'a>> for PreSharedKeyClientExtensionInnerRef<'a> {
+    fn ex_from(m: &'a PreSharedKeyClientExtension) -> PreSharedKeyClientExtensionInnerRef<'a> {
+        &m.offers
     }
 }
 
-impl From<SignatureSchemeListInner> for SignatureSchemeList {
-    fn ex_from(m: SignatureSchemeListInner) -> SignatureSchemeList {
-        let (l, list) = m;
-        SignatureSchemeList { l, list }
+impl<'a> From<PreSharedKeyClientExtensionInner<'a>> for PreSharedKeyClientExtension<'a> {
+    fn ex_from(m: PreSharedKeyClientExtensionInner) -> PreSharedKeyClientExtension {
+        let offers = m;
+        PreSharedKeyClientExtension { offers }
     }
 }
 
-pub struct SignatureSchemeListMapper;
-impl View for SignatureSchemeListMapper {
+pub struct PreSharedKeyClientExtensionMapper;
+impl View for PreSharedKeyClientExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for SignatureSchemeListMapper {
-    type Src = SpecSignatureSchemeListInner;
-    type Dst = SpecSignatureSchemeList;
+impl SpecIso for PreSharedKeyClientExtensionMapper {
+    type Src = SpecPreSharedKeyClientExtensionInner;
+    type Dst = SpecPreSharedKeyClientExtension;
 }
-impl SpecIsoProof for SignatureSchemeListMapper {
+impl SpecIsoProof for PreSharedKeyClientExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -13665,711 +12872,569 @@ impl SpecIsoProof for SignatureSchemeListMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for SignatureSchemeListMapper {
-    type Src = SignatureSchemeListInner;
-    type Dst = SignatureSchemeList;
-    type RefSrc = SignatureSchemeListInnerRef<'a>;
+impl<'a> Iso<'a> for PreSharedKeyClientExtensionMapper {
+    type Src = PreSharedKeyClientExtensionInner<'a>;
+    type Dst = PreSharedKeyClientExtension<'a>;
+    type RefSrc = PreSharedKeyClientExtensionInnerRef<'a>;
 }
 
-pub struct SpecSignatureSchemeListCombinator(pub SpecSignatureSchemeListCombinatorAlias);
+pub struct SpecPreSharedKeyClientExtensionCombinator(pub SpecPreSharedKeyClientExtensionCombinatorAlias);
 
-impl SpecCombinator for SpecSignatureSchemeListCombinator {
-    type Type = SpecSignatureSchemeList;
+impl SpecCombinator for SpecPreSharedKeyClientExtensionCombinator {
+    type Type = SpecPreSharedKeyClientExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecSignatureSchemeListCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSignatureSchemeListCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecPreSharedKeyClientExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPreSharedKeyClientExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecSignatureSchemeListCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate15206902916018849611>, AndThen<bytes::Variable, Repeat<SpecSignatureSchemeCombinator>>>, SignatureSchemeListMapper>;
+pub type SpecPreSharedKeyClientExtensionCombinatorAlias = Mapped<SpecOfferedPsksCombinator, PreSharedKeyClientExtensionMapper>;
 
-pub struct SignatureSchemeListCombinator(pub SignatureSchemeListCombinatorAlias);
+pub struct PreSharedKeyClientExtensionCombinator(pub PreSharedKeyClientExtensionCombinatorAlias);
 
-impl View for SignatureSchemeListCombinator {
-    type V = SpecSignatureSchemeListCombinator;
-    open spec fn view(&self) -> Self::V { SpecSignatureSchemeListCombinator(self.0@) }
+impl View for PreSharedKeyClientExtensionCombinator {
+    type V = SpecPreSharedKeyClientExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecPreSharedKeyClientExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SignatureSchemeListCombinator {
-    type Type = SignatureSchemeList;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PreSharedKeyClientExtensionCombinator {
+    type Type = PreSharedKeyClientExtension<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SignatureSchemeListCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate15206902916018849611>, AndThen<bytes::Variable, Repeat<SignatureSchemeCombinator>>, SignatureSchemeListCont0>, SignatureSchemeListMapper>;
+}
+pub type PreSharedKeyClientExtensionCombinatorAlias = Mapped<OfferedPsksCombinator, PreSharedKeyClientExtensionMapper>;
 
 
-pub open spec fn spec_signature_scheme_list() -> SpecSignatureSchemeListCombinator {
-    SpecSignatureSchemeListCombinator(
+pub open spec fn spec_pre_shared_key_client_extension() -> SpecPreSharedKeyClientExtensionCombinator {
+    SpecPreSharedKeyClientExtensionCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate15206902916018849611 }, |deps| spec_signature_scheme_list_cont0(deps)),
-        mapper: SignatureSchemeListMapper,
+        inner: spec_offered_psks(),
+        mapper: PreSharedKeyClientExtensionMapper,
     })
 }
 
-pub open spec fn spec_signature_scheme_list_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecSignatureSchemeCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_signature_scheme()))
-}
-
-impl View for SignatureSchemeListCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecSignatureSchemeCombinator>>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_signature_scheme_list_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn signature_scheme_list<'a>() -> (o: SignatureSchemeListCombinator)
-    ensures o@ == spec_signature_scheme_list(),
+pub fn pre_shared_key_client_extension<'a>() -> (o: PreSharedKeyClientExtensionCombinator)
+    ensures o@ == spec_pre_shared_key_client_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = SignatureSchemeListCombinator(
+    let combinator = PreSharedKeyClientExtensionCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate15206902916018849611 }, SignatureSchemeListCont0),
-        mapper: SignatureSchemeListMapper,
-    });
-    assert({
-        &&& combinator@ == spec_signature_scheme_list()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: offered_psks(),
+        mapper: PreSharedKeyClientExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_pre_shared_key_client_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_signature_scheme_list<'a>(input: &'a [u8]) -> (res: PResult<<SignatureSchemeListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_pre_shared_key_client_extension<'a>(input: &'a [u8]) -> (res: PResult<<PreSharedKeyClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_signature_scheme_list().spec_parse(input@) == Some((n as int, v@)),
-        spec_signature_scheme_list().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_pre_shared_key_client_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_pre_shared_key_client_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_signature_scheme_list().spec_parse(input@) is None,
-        spec_signature_scheme_list().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_pre_shared_key_client_extension().spec_parse(input@) is None,
+        spec_pre_shared_key_client_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = signature_scheme_list();
+    let combinator = pre_shared_key_client_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_signature_scheme_list<'a>(v: <SignatureSchemeListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_pre_shared_key_client_extension<'a>(v: <PreSharedKeyClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_signature_scheme_list().wf(v@),
+        spec_pre_shared_key_client_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_signature_scheme_list().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_signature_scheme_list().spec_serialize(v@))
+            &&& n == spec_pre_shared_key_client_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_pre_shared_key_client_extension().spec_serialize(v@))
         },
 {
-    let combinator = signature_scheme_list();
+    let combinator = pre_shared_key_client_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn signature_scheme_list_len<'a>(v: <SignatureSchemeListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn pre_shared_key_client_extension_len<'a>(v: <PreSharedKeyClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_signature_scheme_list().wf(v@),
-        spec_signature_scheme_list().spec_serialize(v@).len() <= usize::MAX,
+        spec_pre_shared_key_client_extension().wf(v@),
+        spec_pre_shared_key_client_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_signature_scheme_list().spec_serialize(v@).len(),
+        serialize_len == spec_pre_shared_key_client_extension().spec_serialize(v@).len(),
 {
-    let combinator = signature_scheme_list();
+    let combinator = pre_shared_key_client_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct SignatureSchemeListCont0;
-type SignatureSchemeListCont0Type<'a, 'b> = &'b u16;
-type SignatureSchemeListCont0SType<'a, 'x> = &'x u16;
-type SignatureSchemeListCont0Input<'a, 'b, 'x> = POrSType<SignatureSchemeListCont0Type<'a, 'b>, SignatureSchemeListCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<SignatureSchemeListCont0Input<'a, 'b, 'x>> for SignatureSchemeListCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<SignatureSchemeCombinator>>;
-
-    open spec fn requires(&self, deps: SignatureSchemeListCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: SignatureSchemeListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_signature_scheme_list_cont0(deps@)
-    }
-
-    fn apply(&self, deps: SignatureSchemeListCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(signature_scheme()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(signature_scheme()))
-            }
-        }
-    }
-}
                 
-
-pub struct SpecCertificateStatusRequest {
-    pub status_type: u8,
-    pub request: SpecOscpStatusRequest,
-}
-
-pub type SpecCertificateStatusRequestInner = (u8, SpecOscpStatusRequest);
-
-
-impl SpecFrom<SpecCertificateStatusRequest> for SpecCertificateStatusRequestInner {
-    open spec fn spec_from(m: SpecCertificateStatusRequest) -> SpecCertificateStatusRequestInner {
-        (m.status_type, m.request)
-    }
-}
-
-impl SpecFrom<SpecCertificateStatusRequestInner> for SpecCertificateStatusRequest {
-    open spec fn spec_from(m: SpecCertificateStatusRequestInner) -> SpecCertificateStatusRequest {
-        let (status_type, request) = m;
-        SpecCertificateStatusRequest { status_type, request }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct CertificateStatusRequest<'a> {
-    pub status_type: u8,
-    pub request: OscpStatusRequest<'a>,
-}
-
-impl View for CertificateStatusRequest<'_> {
-    type V = SpecCertificateStatusRequest;
-
-    open spec fn view(&self) -> Self::V {
-        SpecCertificateStatusRequest {
-            status_type: self.status_type@,
-            request: self.request@,
-        }
-    }
-}
-pub type CertificateStatusRequestInner<'a> = (u8, OscpStatusRequest<'a>);
-
-pub type CertificateStatusRequestInnerRef<'a> = (&'a u8, &'a OscpStatusRequest<'a>);
-impl<'a> From<&'a CertificateStatusRequest<'a>> for CertificateStatusRequestInnerRef<'a> {
-    fn ex_from(m: &'a CertificateStatusRequest) -> CertificateStatusRequestInnerRef<'a> {
-        (&m.status_type, &m.request)
-    }
+pub mod MaxFragmentLength {
+    use super::*;
+    pub spec const SPEC_Pow2_9: u8 = 1;
+    pub spec const SPEC_Pow2_10: u8 = 2;
+    pub spec const SPEC_Pow2_11: u8 = 3;
+    pub spec const SPEC_Pow2_12: u8 = 4;
+    pub exec const Pow2_9: u8 ensures Pow2_9 == SPEC_Pow2_9 { 1 }
+    pub exec const Pow2_10: u8 ensures Pow2_10 == SPEC_Pow2_10 { 2 }
+    pub exec const Pow2_11: u8 ensures Pow2_11 == SPEC_Pow2_11 { 3 }
+    pub exec const Pow2_12: u8 ensures Pow2_12 == SPEC_Pow2_12 { 4 }
 }
 
-impl<'a> From<CertificateStatusRequestInner<'a>> for CertificateStatusRequest<'a> {
-    fn ex_from(m: CertificateStatusRequestInner) -> CertificateStatusRequest {
-        let (status_type, request) = m;
-        CertificateStatusRequest { status_type, request }
-    }
-}
 
-pub struct CertificateStatusRequestMapper;
-impl View for CertificateStatusRequestMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for CertificateStatusRequestMapper {
-    type Src = SpecCertificateStatusRequestInner;
-    type Dst = SpecCertificateStatusRequest;
-}
-impl SpecIsoProof for CertificateStatusRequestMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for CertificateStatusRequestMapper {
-    type Src = CertificateStatusRequestInner<'a>;
-    type Dst = CertificateStatusRequest<'a>;
-    type RefSrc = CertificateStatusRequestInnerRef<'a>;
-}
-pub const CERTIFICATESTATUSREQUESTSTATUS_TYPE_CONST: u8 = 1;
-type SpecCertificateStatusRequestCombinatorAlias1 = (Refined<U8, TagPred<u8>>, SpecOscpStatusRequestCombinator);
-pub struct SpecCertificateStatusRequestCombinator(pub SpecCertificateStatusRequestCombinatorAlias);
+pub struct SpecMaxFragmentLengthCombinator(pub SpecMaxFragmentLengthCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateStatusRequestCombinator {
-    type Type = SpecCertificateStatusRequest;
+impl SpecCombinator for SpecMaxFragmentLengthCombinator {
+    type Type = u8;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateStatusRequestCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateStatusRequestCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecMaxFragmentLengthCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMaxFragmentLengthCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateStatusRequestCombinatorAlias = Mapped<SpecCertificateStatusRequestCombinatorAlias1, CertificateStatusRequestMapper>;
-type CertificateStatusRequestCombinatorAlias1 = (Refined<U8, TagPred<u8>>, OscpStatusRequestCombinator);
-pub struct CertificateStatusRequestCombinator1(pub CertificateStatusRequestCombinatorAlias1);
-impl View for CertificateStatusRequestCombinator1 {
-    type V = SpecCertificateStatusRequestCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateStatusRequestCombinator1, CertificateStatusRequestCombinatorAlias1);
+pub type SpecMaxFragmentLengthCombinatorAlias = U8;
 
-pub struct CertificateStatusRequestCombinator(pub CertificateStatusRequestCombinatorAlias);
+pub struct MaxFragmentLengthCombinator(pub MaxFragmentLengthCombinatorAlias);
 
-impl View for CertificateStatusRequestCombinator {
-    type V = SpecCertificateStatusRequestCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateStatusRequestCombinator(self.0@) }
+impl View for MaxFragmentLengthCombinator {
+    type V = SpecMaxFragmentLengthCombinator;
+    open spec fn view(&self) -> Self::V { SpecMaxFragmentLengthCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateStatusRequestCombinator {
-    type Type = CertificateStatusRequest<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MaxFragmentLengthCombinator {
+    type Type = u8;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateStatusRequestCombinatorAlias = Mapped<CertificateStatusRequestCombinator1, CertificateStatusRequestMapper>;
+}
+pub type MaxFragmentLengthCombinatorAlias = U8;
 
 
-pub open spec fn spec_certificate_status_request() -> SpecCertificateStatusRequestCombinator {
-    SpecCertificateStatusRequestCombinator(
-    Mapped {
-        inner: (Refined { inner: U8, predicate: TagPred(CERTIFICATESTATUSREQUESTSTATUS_TYPE_CONST) }, spec_oscp_status_request()),
-        mapper: CertificateStatusRequestMapper,
-    })
+pub open spec fn spec_max_fragment_length() -> SpecMaxFragmentLengthCombinator {
+    SpecMaxFragmentLengthCombinator(U8)
 }
 
                 
-pub fn certificate_status_request<'a>() -> (o: CertificateStatusRequestCombinator)
-    ensures o@ == spec_certificate_status_request(),
+pub fn max_fragment_length<'a>() -> (o: MaxFragmentLengthCombinator)
+    ensures o@ == spec_max_fragment_length(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateStatusRequestCombinator(
-    Mapped {
-        inner: CertificateStatusRequestCombinator1((Refined { inner: U8, predicate: TagPred(CERTIFICATESTATUSREQUESTSTATUS_TYPE_CONST) }, oscp_status_request())),
-        mapper: CertificateStatusRequestMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_status_request()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = MaxFragmentLengthCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_max_fragment_length()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_status_request<'a>(input: &'a [u8]) -> (res: PResult<<CertificateStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_max_fragment_length<'a>(input: &'a [u8]) -> (res: PResult<<MaxFragmentLengthCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_status_request().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_status_request().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_max_fragment_length().spec_parse(input@) == Some((n as int, v@)),
+        spec_max_fragment_length().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_status_request().spec_parse(input@) is None,
-        spec_certificate_status_request().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_max_fragment_length().spec_parse(input@) is None,
+        spec_max_fragment_length().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_status_request();
+    let combinator = max_fragment_length();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_status_request<'a>(v: <CertificateStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_max_fragment_length<'a>(v: <MaxFragmentLengthCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_status_request().wf(v@),
+        spec_max_fragment_length().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_status_request().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_status_request().spec_serialize(v@))
+            &&& n == spec_max_fragment_length().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_max_fragment_length().spec_serialize(v@))
         },
 {
-    let combinator = certificate_status_request();
+    let combinator = max_fragment_length();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_status_request_len<'a>(v: <CertificateStatusRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn max_fragment_length_len<'a>(v: <MaxFragmentLengthCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_status_request().wf(v@),
-        spec_certificate_status_request().spec_serialize(v@).len() <= usize::MAX,
+        spec_max_fragment_length().wf(v@),
+        spec_max_fragment_length().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_status_request().spec_serialize(v@).len(),
+        serialize_len == spec_max_fragment_length().spec_serialize(v@).len(),
 {
-    let combinator = certificate_status_request();
+    let combinator = max_fragment_length();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-
-pub struct SpecSupportedVersionsClient {
-    pub l: u8,
-    pub list: Seq<u16>,
+pub mod HeartbeatMode {
+    use super::*;
+    pub spec const SPEC_PeerAllowedToSend: u8 = 1;
+    pub spec const SPEC_PeerNotAllowedToSend: u8 = 2;
+    pub exec const PeerAllowedToSend: u8 ensures PeerAllowedToSend == SPEC_PeerAllowedToSend { 1 }
+    pub exec const PeerNotAllowedToSend: u8 ensures PeerNotAllowedToSend == SPEC_PeerNotAllowedToSend { 2 }
 }
 
-pub type SpecSupportedVersionsClientInner = (u8, Seq<u16>);
 
+pub struct SpecHeartbeatModeCombinator(pub SpecHeartbeatModeCombinatorAlias);
 
-impl SpecFrom<SpecSupportedVersionsClient> for SpecSupportedVersionsClientInner {
-    open spec fn spec_from(m: SpecSupportedVersionsClient) -> SpecSupportedVersionsClientInner {
-        (m.l, m.list)
-    }
+impl SpecCombinator for SpecHeartbeatModeCombinator {
+    type Type = u8;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
 }
-
-impl SpecFrom<SpecSupportedVersionsClientInner> for SpecSupportedVersionsClient {
-    open spec fn spec_from(m: SpecSupportedVersionsClientInner) -> SpecSupportedVersionsClient {
-        let (l, list) = m;
-        SpecSupportedVersionsClient { l, list }
-    }
+impl SecureSpecCombinator for SpecHeartbeatModeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHeartbeatModeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+pub type SpecHeartbeatModeCombinatorAlias = U8;
 
-pub struct SupportedVersionsClient {
-    pub l: u8,
-    pub list: RepeatResult<u16>,
+pub struct HeartbeatModeCombinator(pub HeartbeatModeCombinatorAlias);
+
+impl View for HeartbeatModeCombinator {
+    type V = SpecHeartbeatModeCombinator;
+    open spec fn view(&self) -> Self::V { SpecHeartbeatModeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeartbeatModeCombinator {
+    type Type = u8;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+pub type HeartbeatModeCombinatorAlias = U8;
 
-impl View for SupportedVersionsClient {
-    type V = SpecSupportedVersionsClient;
 
-    open spec fn view(&self) -> Self::V {
-        SpecSupportedVersionsClient {
-            l: self.l@,
-            list: self.list@,
-        }
-    }
+pub open spec fn spec_heartbeat_mode() -> SpecHeartbeatModeCombinator {
+    SpecHeartbeatModeCombinator(U8)
 }
-pub type SupportedVersionsClientInner = (u8, RepeatResult<u16>);
 
-pub type SupportedVersionsClientInnerRef<'a> = (&'a u8, &'a RepeatResult<u16>);
-impl<'a> From<&'a SupportedVersionsClient> for SupportedVersionsClientInnerRef<'a> {
-    fn ex_from(m: &'a SupportedVersionsClient) -> SupportedVersionsClientInnerRef<'a> {
-        (&m.l, &m.list)
-    }
+                
+pub fn heartbeat_mode<'a>() -> (o: HeartbeatModeCombinator)
+    ensures o@ == spec_heartbeat_mode(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = HeartbeatModeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_heartbeat_mode()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
 }
 
-impl From<SupportedVersionsClientInner> for SupportedVersionsClient {
-    fn ex_from(m: SupportedVersionsClientInner) -> SupportedVersionsClient {
-        let (l, list) = m;
-        SupportedVersionsClient { l, list }
-    }
+pub fn parse_heartbeat_mode<'a>(input: &'a [u8]) -> (res: PResult<<HeartbeatModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_heartbeat_mode().spec_parse(input@) == Some((n as int, v@)),
+        spec_heartbeat_mode().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_heartbeat_mode().spec_parse(input@) is None,
+        spec_heartbeat_mode().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = heartbeat_mode();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub struct SupportedVersionsClientMapper;
-impl View for SupportedVersionsClientMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for SupportedVersionsClientMapper {
-    type Src = SpecSupportedVersionsClientInner;
-    type Dst = SpecSupportedVersionsClient;
+pub fn serialize_heartbeat_mode<'a>(v: <HeartbeatModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_heartbeat_mode().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_heartbeat_mode().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_heartbeat_mode().spec_serialize(v@))
+        },
+{
+    let combinator = heartbeat_mode();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
-impl SpecIsoProof for SupportedVersionsClientMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
+
+pub fn heartbeat_mode_len<'a>(v: <HeartbeatModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_heartbeat_mode().wf(v@),
+        spec_heartbeat_mode().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_heartbeat_mode().spec_serialize(v@).len(),
+{
+    let combinator = heartbeat_mode();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
-impl<'a> Iso<'a> for SupportedVersionsClientMapper {
-    type Src = SupportedVersionsClientInner;
-    type Dst = SupportedVersionsClient;
-    type RefSrc = SupportedVersionsClientInnerRef<'a>;
+
+                
+pub mod CertificateType {
+    use super::*;
+    pub spec const SPEC_X509: u8 = 0;
+    pub spec const SPEC_RawPublicKey: u8 = 2;
+    pub exec const X509: u8 ensures X509 == SPEC_X509 { 0 }
+    pub exec const RawPublicKey: u8 ensures RawPublicKey == SPEC_RawPublicKey { 2 }
 }
 
-pub struct SpecSupportedVersionsClientCombinator(pub SpecSupportedVersionsClientCombinatorAlias);
 
-impl SpecCombinator for SpecSupportedVersionsClientCombinator {
-    type Type = SpecSupportedVersionsClient;
+pub struct SpecCertificateTypeCombinator(pub SpecCertificateTypeCombinatorAlias);
+
+impl SpecCombinator for SpecCertificateTypeCombinator {
+    type Type = u8;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecSupportedVersionsClientCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSupportedVersionsClientCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateTypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecSupportedVersionsClientCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate7470776374180795781>, AndThen<bytes::Variable, Repeat<SpecProtocolVersionCombinator>>>, SupportedVersionsClientMapper>;
-pub struct Predicate7470776374180795781;
-impl View for Predicate7470776374180795781 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u8> for Predicate7470776374180795781 {
-    fn apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        (i >= 2 && i <= 254)
-    }
-}
-impl SpecPred<u8> for Predicate7470776374180795781 {
-    open spec fn spec_apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        (i >= 2 && i <= 254)
-    }
-}
+pub type SpecCertificateTypeCombinatorAlias = U8;
 
-pub struct SupportedVersionsClientCombinator(pub SupportedVersionsClientCombinatorAlias);
+pub struct CertificateTypeCombinator(pub CertificateTypeCombinatorAlias);
 
-impl View for SupportedVersionsClientCombinator {
-    type V = SpecSupportedVersionsClientCombinator;
-    open spec fn view(&self) -> Self::V { SpecSupportedVersionsClientCombinator(self.0@) }
+impl View for CertificateTypeCombinator {
+    type V = SpecCertificateTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateTypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SupportedVersionsClientCombinator {
-    type Type = SupportedVersionsClient;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateTypeCombinator {
+    type Type = u8;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SupportedVersionsClientCombinatorAlias = Mapped<Pair<Refined<U8, Predicate7470776374180795781>, AndThen<bytes::Variable, Repeat<ProtocolVersionCombinator>>, SupportedVersionsClientCont0>, SupportedVersionsClientMapper>;
-
-
-pub open spec fn spec_supported_versions_client() -> SpecSupportedVersionsClientCombinator {
-    SpecSupportedVersionsClientCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate7470776374180795781 }, |deps| spec_supported_versions_client_cont0(deps)),
-        mapper: SupportedVersionsClientMapper,
-    })
-}
-
-pub open spec fn spec_supported_versions_client_cont0(deps: u8) -> AndThen<bytes::Variable, Repeat<SpecProtocolVersionCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_protocol_version()))
 }
+pub type CertificateTypeCombinatorAlias = U8;
 
-impl View for SupportedVersionsClientCont0 {
-    type V = spec_fn(u8) -> AndThen<bytes::Variable, Repeat<SpecProtocolVersionCombinator>>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u8| {
-            spec_supported_versions_client_cont0(deps)
-        }
-    }
+pub open spec fn spec_certificate_type() -> SpecCertificateTypeCombinator {
+    SpecCertificateTypeCombinator(U8)
 }
 
                 
-pub fn supported_versions_client<'a>() -> (o: SupportedVersionsClientCombinator)
-    ensures o@ == spec_supported_versions_client(),
+pub fn certificate_type<'a>() -> (o: CertificateTypeCombinator)
+    ensures o@ == spec_certificate_type(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = SupportedVersionsClientCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U8, predicate: Predicate7470776374180795781 }, SupportedVersionsClientCont0),
-        mapper: SupportedVersionsClientMapper,
-    });
-    assert({
-        &&& combinator@ == spec_supported_versions_client()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = CertificateTypeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_certificate_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_supported_versions_client<'a>(input: &'a [u8]) -> (res: PResult<<SupportedVersionsClientCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_type<'a>(input: &'a [u8]) -> (res: PResult<<CertificateTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_supported_versions_client().spec_parse(input@) == Some((n as int, v@)),
-        spec_supported_versions_client().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_type().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_supported_versions_client().spec_parse(input@) is None,
-        spec_supported_versions_client().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_type().spec_parse(input@) is None,
+        spec_certificate_type().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = supported_versions_client();
+    let combinator = certificate_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_supported_versions_client<'a>(v: <SupportedVersionsClientCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_type<'a>(v: <CertificateTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_supported_versions_client().wf(v@),
+        spec_certificate_type().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_supported_versions_client().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_supported_versions_client().spec_serialize(v@))
+            &&& n == spec_certificate_type().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_type().spec_serialize(v@))
         },
 {
-    let combinator = supported_versions_client();
+    let combinator = certificate_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn supported_versions_client_len<'a>(v: <SupportedVersionsClientCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_type_len<'a>(v: <CertificateTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_supported_versions_client().wf(v@),
-        spec_supported_versions_client().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_type().wf(v@),
+        spec_certificate_type().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_supported_versions_client().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_type().spec_serialize(v@).len(),
 {
-    let combinator = supported_versions_client();
+    let combinator = certificate_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct SupportedVersionsClientCont0;
-type SupportedVersionsClientCont0Type<'a, 'b> = &'b u8;
-type SupportedVersionsClientCont0SType<'a, 'x> = &'x u8;
-type SupportedVersionsClientCont0Input<'a, 'b, 'x> = POrSType<SupportedVersionsClientCont0Type<'a, 'b>, SupportedVersionsClientCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<SupportedVersionsClientCont0Input<'a, 'b, 'x>> for SupportedVersionsClientCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<ProtocolVersionCombinator>>;
+                
 
-    open spec fn requires(&self, deps: SupportedVersionsClientCont0Input<'a, 'b, 'x>) -> bool { true }
+pub struct SpecClientCertTypeClientExtension {
+    pub l: u8,
+    pub list: Seq<u8>,
+}
 
-    open spec fn ensures(&self, deps: SupportedVersionsClientCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_supported_versions_client_cont0(deps@)
-    }
-
-    fn apply(&self, deps: SupportedVersionsClientCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(protocol_version()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(protocol_version()))
-            }
-        }
-    }
-}
-                
-
-pub struct SpecKeyShareClientHello {
-    pub l: u16,
-    pub list: Seq<SpecKeyShareEntry>,
-}
-
-pub type SpecKeyShareClientHelloInner = (u16, Seq<SpecKeyShareEntry>);
+pub type SpecClientCertTypeClientExtensionInner = (u8, Seq<u8>);
 
 
-impl SpecFrom<SpecKeyShareClientHello> for SpecKeyShareClientHelloInner {
-    open spec fn spec_from(m: SpecKeyShareClientHello) -> SpecKeyShareClientHelloInner {
+impl SpecFrom<SpecClientCertTypeClientExtension> for SpecClientCertTypeClientExtensionInner {
+    open spec fn spec_from(m: SpecClientCertTypeClientExtension) -> SpecClientCertTypeClientExtensionInner {
         (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecKeyShareClientHelloInner> for SpecKeyShareClientHello {
-    open spec fn spec_from(m: SpecKeyShareClientHelloInner) -> SpecKeyShareClientHello {
+impl SpecFrom<SpecClientCertTypeClientExtensionInner> for SpecClientCertTypeClientExtension {
+    open spec fn spec_from(m: SpecClientCertTypeClientExtensionInner) -> SpecClientCertTypeClientExtension {
         let (l, list) = m;
-        SpecKeyShareClientHello { l, list }
+        SpecClientCertTypeClientExtension { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct KeyShareClientHello<'a> {
-    pub l: u16,
-    pub list: RepeatResult<KeyShareEntry<'a>>,
+pub struct ClientCertTypeClientExtension {
+    pub l: u8,
+    pub list: RepeatResult<u8>,
 }
 
-impl View for KeyShareClientHello<'_> {
-    type V = SpecKeyShareClientHello;
+impl View for ClientCertTypeClientExtension {
+    type V = SpecClientCertTypeClientExtension;
 
     open spec fn view(&self) -> Self::V {
-        SpecKeyShareClientHello {
+        SpecClientCertTypeClientExtension {
             l: self.l@,
             list: self.list@,
         }
     }
 }
-pub type KeyShareClientHelloInner<'a> = (u16, RepeatResult<KeyShareEntry<'a>>);
+pub type ClientCertTypeClientExtensionInner = (u8, RepeatResult<u8>);
 
-pub type KeyShareClientHelloInnerRef<'a> = (&'a u16, &'a RepeatResult<KeyShareEntry<'a>>);
-impl<'a> From<&'a KeyShareClientHello<'a>> for KeyShareClientHelloInnerRef<'a> {
-    fn ex_from(m: &'a KeyShareClientHello) -> KeyShareClientHelloInnerRef<'a> {
+pub type ClientCertTypeClientExtensionInnerRef<'a> = (&'a u8, &'a RepeatResult<u8>);
+impl<'a> From<&'a ClientCertTypeClientExtension> for ClientCertTypeClientExtensionInnerRef<'a> {
+    fn ex_from(m: &'a ClientCertTypeClientExtension) -> ClientCertTypeClientExtensionInnerRef<'a> {
         (&m.l, &m.list)
     }
 }
 
-impl<'a> From<KeyShareClientHelloInner<'a>> for KeyShareClientHello<'a> {
-    fn ex_from(m: KeyShareClientHelloInner) -> KeyShareClientHello {
+impl From<ClientCertTypeClientExtensionInner> for ClientCertTypeClientExtension {
+    fn ex_from(m: ClientCertTypeClientExtensionInner) -> ClientCertTypeClientExtension {
         let (l, list) = m;
-        KeyShareClientHello { l, list }
+        ClientCertTypeClientExtension { l, list }
     }
 }
 
-pub struct KeyShareClientHelloMapper;
-impl View for KeyShareClientHelloMapper {
+pub struct ClientCertTypeClientExtensionMapper;
+impl View for ClientCertTypeClientExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for KeyShareClientHelloMapper {
-    type Src = SpecKeyShareClientHelloInner;
-    type Dst = SpecKeyShareClientHello;
+impl SpecIso for ClientCertTypeClientExtensionMapper {
+    type Src = SpecClientCertTypeClientExtensionInner;
+    type Dst = SpecClientCertTypeClientExtension;
 }
-impl SpecIsoProof for KeyShareClientHelloMapper {
+impl SpecIsoProof for ClientCertTypeClientExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -14377,363 +13442,245 @@ impl SpecIsoProof for KeyShareClientHelloMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for KeyShareClientHelloMapper {
-    type Src = KeyShareClientHelloInner<'a>;
-    type Dst = KeyShareClientHello<'a>;
-    type RefSrc = KeyShareClientHelloInnerRef<'a>;
+impl<'a> Iso<'a> for ClientCertTypeClientExtensionMapper {
+    type Src = ClientCertTypeClientExtensionInner;
+    type Dst = ClientCertTypeClientExtension;
+    type RefSrc = ClientCertTypeClientExtensionInnerRef<'a>;
 }
 
-pub struct SpecKeyShareClientHelloCombinator(pub SpecKeyShareClientHelloCombinatorAlias);
+pub struct SpecClientCertTypeClientExtensionCombinator(pub SpecClientCertTypeClientExtensionCombinatorAlias);
 
-impl SpecCombinator for SpecKeyShareClientHelloCombinator {
-    type Type = SpecKeyShareClientHello;
+impl SpecCombinator for SpecClientCertTypeClientExtensionCombinator {
+    type Type = SpecClientCertTypeClientExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecKeyShareClientHelloCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecKeyShareClientHelloCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecClientCertTypeClientExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecClientCertTypeClientExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecKeyShareClientHelloCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecKeyShareEntryCombinator>>>, KeyShareClientHelloMapper>;
+pub type SpecClientCertTypeClientExtensionCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>>>, ClientCertTypeClientExtensionMapper>;
 
-pub struct KeyShareClientHelloCombinator(pub KeyShareClientHelloCombinatorAlias);
+pub struct ClientCertTypeClientExtensionCombinator(pub ClientCertTypeClientExtensionCombinatorAlias);
 
-impl View for KeyShareClientHelloCombinator {
-    type V = SpecKeyShareClientHelloCombinator;
-    open spec fn view(&self) -> Self::V { SpecKeyShareClientHelloCombinator(self.0@) }
+impl View for ClientCertTypeClientExtensionCombinator {
+    type V = SpecClientCertTypeClientExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecClientCertTypeClientExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for KeyShareClientHelloCombinator {
-    type Type = KeyShareClientHello<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientCertTypeClientExtensionCombinator {
+    type Type = ClientCertTypeClientExtension;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type KeyShareClientHelloCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<KeyShareEntryCombinator>>, KeyShareClientHelloCont0>, KeyShareClientHelloMapper>;
+}
+pub type ClientCertTypeClientExtensionCombinatorAlias = Mapped<Pair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<CertificateTypeCombinator>>, ClientCertTypeClientExtensionCont0>, ClientCertTypeClientExtensionMapper>;
 
 
-pub open spec fn spec_key_share_client_hello() -> SpecKeyShareClientHelloCombinator {
-    SpecKeyShareClientHelloCombinator(
+pub open spec fn spec_client_cert_type_client_extension() -> SpecClientCertTypeClientExtensionCombinator {
+    SpecClientCertTypeClientExtensionCombinator(
     Mapped {
-        inner: Pair::spec_new(U16Be, |deps| spec_key_share_client_hello_cont0(deps)),
-        mapper: KeyShareClientHelloMapper,
+        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, |deps| spec_client_cert_type_client_extension_cont0(deps)),
+        mapper: ClientCertTypeClientExtensionMapper,
     })
 }
 
-pub open spec fn spec_key_share_client_hello_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecKeyShareEntryCombinator>> {
+pub open spec fn spec_client_cert_type_client_extension_cont0(deps: u8) -> AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>> {
     let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_key_share_entry()))
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_certificate_type()))
 }
 
-impl View for KeyShareClientHelloCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecKeyShareEntryCombinator>>;
+impl View for ClientCertTypeClientExtensionCont0 {
+    type V = spec_fn(u8) -> AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>>;
 
     open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_key_share_client_hello_cont0(deps)
+        |deps: u8| {
+            spec_client_cert_type_client_extension_cont0(deps)
         }
     }
 }
 
                 
-pub fn key_share_client_hello<'a>() -> (o: KeyShareClientHelloCombinator)
-    ensures o@ == spec_key_share_client_hello(),
+pub fn client_cert_type_client_extension<'a>() -> (o: ClientCertTypeClientExtensionCombinator)
+    ensures o@ == spec_client_cert_type_client_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = KeyShareClientHelloCombinator(
+    let combinator = ClientCertTypeClientExtensionCombinator(
     Mapped {
-        inner: Pair::new(U16Be, KeyShareClientHelloCont0),
-        mapper: KeyShareClientHelloMapper,
-    });
-    assert({
-        &&& combinator@ == spec_key_share_client_hello()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, ClientCertTypeClientExtensionCont0),
+        mapper: ClientCertTypeClientExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_client_cert_type_client_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_key_share_client_hello<'a>(input: &'a [u8]) -> (res: PResult<<KeyShareClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_client_cert_type_client_extension<'a>(input: &'a [u8]) -> (res: PResult<<ClientCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_key_share_client_hello().spec_parse(input@) == Some((n as int, v@)),
-        spec_key_share_client_hello().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_client_cert_type_client_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_client_cert_type_client_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_key_share_client_hello().spec_parse(input@) is None,
-        spec_key_share_client_hello().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_client_cert_type_client_extension().spec_parse(input@) is None,
+        spec_client_cert_type_client_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = key_share_client_hello();
+    let combinator = client_cert_type_client_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_key_share_client_hello<'a>(v: <KeyShareClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_client_cert_type_client_extension<'a>(v: <ClientCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_key_share_client_hello().wf(v@),
+        spec_client_cert_type_client_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_key_share_client_hello().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_key_share_client_hello().spec_serialize(v@))
+            &&& n == spec_client_cert_type_client_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_client_cert_type_client_extension().spec_serialize(v@))
         },
 {
-    let combinator = key_share_client_hello();
+    let combinator = client_cert_type_client_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn key_share_client_hello_len<'a>(v: <KeyShareClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn client_cert_type_client_extension_len<'a>(v: <ClientCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_key_share_client_hello().wf(v@),
-        spec_key_share_client_hello().spec_serialize(v@).len() <= usize::MAX,
+        spec_client_cert_type_client_extension().wf(v@),
+        spec_client_cert_type_client_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_key_share_client_hello().spec_serialize(v@).len(),
+        serialize_len == spec_client_cert_type_client_extension().spec_serialize(v@).len(),
 {
-    let combinator = key_share_client_hello();
+    let combinator = client_cert_type_client_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct KeyShareClientHelloCont0;
-type KeyShareClientHelloCont0Type<'a, 'b> = &'b u16;
-type KeyShareClientHelloCont0SType<'a, 'x> = &'x u16;
-type KeyShareClientHelloCont0Input<'a, 'b, 'x> = POrSType<KeyShareClientHelloCont0Type<'a, 'b>, KeyShareClientHelloCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<KeyShareClientHelloCont0Input<'a, 'b, 'x>> for KeyShareClientHelloCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<KeyShareEntryCombinator>>;
+pub struct ClientCertTypeClientExtensionCont0;
+type ClientCertTypeClientExtensionCont0Type<'a, 'b> = &'b u8;
+type ClientCertTypeClientExtensionCont0SType<'a, 'x> = &'x u8;
+type ClientCertTypeClientExtensionCont0Input<'a, 'b, 'x> = POrSType<ClientCertTypeClientExtensionCont0Type<'a, 'b>, ClientCertTypeClientExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ClientCertTypeClientExtensionCont0Input<'a, 'b, 'x>> for ClientCertTypeClientExtensionCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<CertificateTypeCombinator>>;
 
-    open spec fn requires(&self, deps: KeyShareClientHelloCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: ClientCertTypeClientExtensionCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U8, predicate: Predicate13984338198318635021 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: KeyShareClientHelloCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_key_share_client_hello_cont0(deps@)
+    open spec fn ensures(&self, deps: ClientCertTypeClientExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_client_cert_type_client_extension_cont0(deps@)
     }
 
-    fn apply(&self, deps: KeyShareClientHelloCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: ClientCertTypeClientExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(key_share_entry()))
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(certificate_type()))
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(key_share_entry()))
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(certificate_type()))
             }
         }
     }
 }
                 
-pub mod PskKeyExchangeMode {
-    use super::*;
-    pub spec const SPEC_PSK_KE: u8 = 0;
-    pub spec const SPEC_PSK_DHE_KE: u8 = 1;
-    pub exec const PSK_KE: u8 ensures PSK_KE == SPEC_PSK_KE { 0 }
-    pub exec const PSK_DHE_KE: u8 ensures PSK_DHE_KE == SPEC_PSK_DHE_KE { 1 }
+
+pub struct SpecServerCertTypeClientExtension {
+    pub l: u8,
+    pub list: Seq<u8>,
 }
 
+pub type SpecServerCertTypeClientExtensionInner = (u8, Seq<u8>);
 
-pub struct SpecPskKeyExchangeModeCombinator(pub SpecPskKeyExchangeModeCombinatorAlias);
 
-impl SpecCombinator for SpecPskKeyExchangeModeCombinator {
-    type Type = u8;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecPskKeyExchangeModeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecPskKeyExchangeModeCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
+impl SpecFrom<SpecServerCertTypeClientExtension> for SpecServerCertTypeClientExtensionInner {
+    open spec fn spec_from(m: SpecServerCertTypeClientExtension) -> SpecServerCertTypeClientExtensionInner {
+        (m.l, m.list)
+    }
 }
-pub type SpecPskKeyExchangeModeCombinatorAlias = U8;
 
-pub struct PskKeyExchangeModeCombinator(pub PskKeyExchangeModeCombinatorAlias);
+impl SpecFrom<SpecServerCertTypeClientExtensionInner> for SpecServerCertTypeClientExtension {
+    open spec fn spec_from(m: SpecServerCertTypeClientExtensionInner) -> SpecServerCertTypeClientExtension {
+        let (l, list) = m;
+        SpecServerCertTypeClientExtension { l, list }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-impl View for PskKeyExchangeModeCombinator {
-    type V = SpecPskKeyExchangeModeCombinator;
-    open spec fn view(&self) -> Self::V { SpecPskKeyExchangeModeCombinator(self.0@) }
+pub struct ServerCertTypeClientExtension {
+    pub l: u8,
+    pub list: RepeatResult<u8>,
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskKeyExchangeModeCombinator {
-    type Type = u8;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type PskKeyExchangeModeCombinatorAlias = U8;
 
+impl View for ServerCertTypeClientExtension {
+    type V = SpecServerCertTypeClientExtension;
 
-pub open spec fn spec_psk_key_exchange_mode() -> SpecPskKeyExchangeModeCombinator {
-    SpecPskKeyExchangeModeCombinator(U8)
+    open spec fn view(&self) -> Self::V {
+        SpecServerCertTypeClientExtension {
+            l: self.l@,
+            list: self.list@,
+        }
+    }
 }
+pub type ServerCertTypeClientExtensionInner = (u8, RepeatResult<u8>);
 
-                
-pub fn psk_key_exchange_mode<'a>() -> (o: PskKeyExchangeModeCombinator)
-    ensures o@ == spec_psk_key_exchange_mode(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = PskKeyExchangeModeCombinator(U8);
-    assert({
-        &&& combinator@ == spec_psk_key_exchange_mode()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
-
-pub fn parse_psk_key_exchange_mode<'a>(input: &'a [u8]) -> (res: PResult<<PskKeyExchangeModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_psk_key_exchange_mode().spec_parse(input@) == Some((n as int, v@)),
-        spec_psk_key_exchange_mode().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_psk_key_exchange_mode().spec_parse(input@) is None,
-        spec_psk_key_exchange_mode().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = psk_key_exchange_mode();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
-}
-
-pub fn serialize_psk_key_exchange_mode<'a>(v: <PskKeyExchangeModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_psk_key_exchange_mode().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_psk_key_exchange_mode().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_psk_key_exchange_mode().spec_serialize(v@))
-        },
-{
-    let combinator = psk_key_exchange_mode();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
-}
-
-pub fn psk_key_exchange_mode_len<'a>(v: <PskKeyExchangeModeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_psk_key_exchange_mode().wf(v@),
-        spec_psk_key_exchange_mode().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_psk_key_exchange_mode().spec_serialize(v@).len(),
-{
-    let combinator = psk_key_exchange_mode();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
-}
-
-                
-
-pub struct SpecPskKeyExchangeModes {
-    pub l: u8,
-    pub list: Seq<u8>,
-}
-
-pub type SpecPskKeyExchangeModesInner = (u8, Seq<u8>);
-
-
-impl SpecFrom<SpecPskKeyExchangeModes> for SpecPskKeyExchangeModesInner {
-    open spec fn spec_from(m: SpecPskKeyExchangeModes) -> SpecPskKeyExchangeModesInner {
-        (m.l, m.list)
-    }
-}
-
-impl SpecFrom<SpecPskKeyExchangeModesInner> for SpecPskKeyExchangeModes {
-    open spec fn spec_from(m: SpecPskKeyExchangeModesInner) -> SpecPskKeyExchangeModes {
-        let (l, list) = m;
-        SpecPskKeyExchangeModes { l, list }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct PskKeyExchangeModes {
-    pub l: u8,
-    pub list: RepeatResult<u8>,
-}
-
-impl View for PskKeyExchangeModes {
-    type V = SpecPskKeyExchangeModes;
-
-    open spec fn view(&self) -> Self::V {
-        SpecPskKeyExchangeModes {
-            l: self.l@,
-            list: self.list@,
-        }
-    }
-}
-pub type PskKeyExchangeModesInner = (u8, RepeatResult<u8>);
-
-pub type PskKeyExchangeModesInnerRef<'a> = (&'a u8, &'a RepeatResult<u8>);
-impl<'a> From<&'a PskKeyExchangeModes> for PskKeyExchangeModesInnerRef<'a> {
-    fn ex_from(m: &'a PskKeyExchangeModes) -> PskKeyExchangeModesInnerRef<'a> {
+pub type ServerCertTypeClientExtensionInnerRef<'a> = (&'a u8, &'a RepeatResult<u8>);
+impl<'a> From<&'a ServerCertTypeClientExtension> for ServerCertTypeClientExtensionInnerRef<'a> {
+    fn ex_from(m: &'a ServerCertTypeClientExtension) -> ServerCertTypeClientExtensionInnerRef<'a> {
         (&m.l, &m.list)
     }
 }
 
-impl From<PskKeyExchangeModesInner> for PskKeyExchangeModes {
-    fn ex_from(m: PskKeyExchangeModesInner) -> PskKeyExchangeModes {
+impl From<ServerCertTypeClientExtensionInner> for ServerCertTypeClientExtension {
+    fn ex_from(m: ServerCertTypeClientExtensionInner) -> ServerCertTypeClientExtension {
         let (l, list) = m;
-        PskKeyExchangeModes { l, list }
+        ServerCertTypeClientExtension { l, list }
     }
 }
 
-pub struct PskKeyExchangeModesMapper;
-impl View for PskKeyExchangeModesMapper {
+pub struct ServerCertTypeClientExtensionMapper;
+impl View for ServerCertTypeClientExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for PskKeyExchangeModesMapper {
-    type Src = SpecPskKeyExchangeModesInner;
-    type Dst = SpecPskKeyExchangeModes;
+impl SpecIso for ServerCertTypeClientExtensionMapper {
+    type Src = SpecServerCertTypeClientExtensionInner;
+    type Dst = SpecServerCertTypeClientExtension;
 }
-impl SpecIsoProof for PskKeyExchangeModesMapper {
+impl SpecIsoProof for ServerCertTypeClientExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -14741,241 +13688,328 @@ impl SpecIsoProof for PskKeyExchangeModesMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for PskKeyExchangeModesMapper {
-    type Src = PskKeyExchangeModesInner;
-    type Dst = PskKeyExchangeModes;
-    type RefSrc = PskKeyExchangeModesInnerRef<'a>;
+impl<'a> Iso<'a> for ServerCertTypeClientExtensionMapper {
+    type Src = ServerCertTypeClientExtensionInner;
+    type Dst = ServerCertTypeClientExtension;
+    type RefSrc = ServerCertTypeClientExtensionInnerRef<'a>;
 }
 
-pub struct SpecPskKeyExchangeModesCombinator(pub SpecPskKeyExchangeModesCombinatorAlias);
+pub struct SpecServerCertTypeClientExtensionCombinator(pub SpecServerCertTypeClientExtensionCombinatorAlias);
 
-impl SpecCombinator for SpecPskKeyExchangeModesCombinator {
-    type Type = SpecPskKeyExchangeModes;
+impl SpecCombinator for SpecServerCertTypeClientExtensionCombinator {
+    type Type = SpecServerCertTypeClientExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecPskKeyExchangeModesCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecPskKeyExchangeModesCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecServerCertTypeClientExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecServerCertTypeClientExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecPskKeyExchangeModesCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<SpecPskKeyExchangeModeCombinator>>>, PskKeyExchangeModesMapper>;
+pub type SpecServerCertTypeClientExtensionCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>>>, ServerCertTypeClientExtensionMapper>;
 
-pub struct PskKeyExchangeModesCombinator(pub PskKeyExchangeModesCombinatorAlias);
+pub struct ServerCertTypeClientExtensionCombinator(pub ServerCertTypeClientExtensionCombinatorAlias);
 
-impl View for PskKeyExchangeModesCombinator {
-    type V = SpecPskKeyExchangeModesCombinator;
-    open spec fn view(&self) -> Self::V { SpecPskKeyExchangeModesCombinator(self.0@) }
+impl View for ServerCertTypeClientExtensionCombinator {
+    type V = SpecServerCertTypeClientExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecServerCertTypeClientExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskKeyExchangeModesCombinator {
-    type Type = PskKeyExchangeModes;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerCertTypeClientExtensionCombinator {
+    type Type = ServerCertTypeClientExtension;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type PskKeyExchangeModesCombinatorAlias = Mapped<Pair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<PskKeyExchangeModeCombinator>>, PskKeyExchangeModesCont0>, PskKeyExchangeModesMapper>;
+}
+pub type ServerCertTypeClientExtensionCombinatorAlias = Mapped<Pair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<CertificateTypeCombinator>>, ServerCertTypeClientExtensionCont0>, ServerCertTypeClientExtensionMapper>;
 
 
-pub open spec fn spec_psk_key_exchange_modes() -> SpecPskKeyExchangeModesCombinator {
-    SpecPskKeyExchangeModesCombinator(
+pub open spec fn spec_server_cert_type_client_extension() -> SpecServerCertTypeClientExtensionCombinator {
+    SpecServerCertTypeClientExtensionCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, |deps| spec_psk_key_exchange_modes_cont0(deps)),
-        mapper: PskKeyExchangeModesMapper,
+        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, |deps| spec_server_cert_type_client_extension_cont0(deps)),
+        mapper: ServerCertTypeClientExtensionMapper,
     })
 }
 
-pub open spec fn spec_psk_key_exchange_modes_cont0(deps: u8) -> AndThen<bytes::Variable, Repeat<SpecPskKeyExchangeModeCombinator>> {
+pub open spec fn spec_server_cert_type_client_extension_cont0(deps: u8) -> AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>> {
     let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_psk_key_exchange_mode()))
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_certificate_type()))
 }
 
-impl View for PskKeyExchangeModesCont0 {
-    type V = spec_fn(u8) -> AndThen<bytes::Variable, Repeat<SpecPskKeyExchangeModeCombinator>>;
+impl View for ServerCertTypeClientExtensionCont0 {
+    type V = spec_fn(u8) -> AndThen<bytes::Variable, Repeat<SpecCertificateTypeCombinator>>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u8| {
-            spec_psk_key_exchange_modes_cont0(deps)
+            spec_server_cert_type_client_extension_cont0(deps)
         }
     }
 }
 
                 
-pub fn psk_key_exchange_modes<'a>() -> (o: PskKeyExchangeModesCombinator)
-    ensures o@ == spec_psk_key_exchange_modes(),
+pub fn server_cert_type_client_extension<'a>() -> (o: ServerCertTypeClientExtensionCombinator)
+    ensures o@ == spec_server_cert_type_client_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = PskKeyExchangeModesCombinator(
+    let combinator = ServerCertTypeClientExtensionCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, PskKeyExchangeModesCont0),
-        mapper: PskKeyExchangeModesMapper,
-    });
-    assert({
-        &&& combinator@ == spec_psk_key_exchange_modes()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, ServerCertTypeClientExtensionCont0),
+        mapper: ServerCertTypeClientExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_server_cert_type_client_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_psk_key_exchange_modes<'a>(input: &'a [u8]) -> (res: PResult<<PskKeyExchangeModesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_server_cert_type_client_extension<'a>(input: &'a [u8]) -> (res: PResult<<ServerCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_psk_key_exchange_modes().spec_parse(input@) == Some((n as int, v@)),
-        spec_psk_key_exchange_modes().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_server_cert_type_client_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_server_cert_type_client_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_psk_key_exchange_modes().spec_parse(input@) is None,
-        spec_psk_key_exchange_modes().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_server_cert_type_client_extension().spec_parse(input@) is None,
+        spec_server_cert_type_client_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = psk_key_exchange_modes();
+    let combinator = server_cert_type_client_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_psk_key_exchange_modes<'a>(v: <PskKeyExchangeModesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_server_cert_type_client_extension<'a>(v: <ServerCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_psk_key_exchange_modes().wf(v@),
+        spec_server_cert_type_client_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_psk_key_exchange_modes().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_psk_key_exchange_modes().spec_serialize(v@))
+            &&& n == spec_server_cert_type_client_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_server_cert_type_client_extension().spec_serialize(v@))
         },
 {
-    let combinator = psk_key_exchange_modes();
+    let combinator = server_cert_type_client_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn psk_key_exchange_modes_len<'a>(v: <PskKeyExchangeModesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn server_cert_type_client_extension_len<'a>(v: <ServerCertTypeClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_psk_key_exchange_modes().wf(v@),
-        spec_psk_key_exchange_modes().spec_serialize(v@).len() <= usize::MAX,
+        spec_server_cert_type_client_extension().wf(v@),
+        spec_server_cert_type_client_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_psk_key_exchange_modes().spec_serialize(v@).len(),
+        serialize_len == spec_server_cert_type_client_extension().spec_serialize(v@).len(),
 {
-    let combinator = psk_key_exchange_modes();
+    let combinator = server_cert_type_client_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct PskKeyExchangeModesCont0;
-type PskKeyExchangeModesCont0Type<'a, 'b> = &'b u8;
-type PskKeyExchangeModesCont0SType<'a, 'x> = &'x u8;
-type PskKeyExchangeModesCont0Input<'a, 'b, 'x> = POrSType<PskKeyExchangeModesCont0Type<'a, 'b>, PskKeyExchangeModesCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<PskKeyExchangeModesCont0Input<'a, 'b, 'x>> for PskKeyExchangeModesCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<PskKeyExchangeModeCombinator>>;
+pub struct ServerCertTypeClientExtensionCont0;
+type ServerCertTypeClientExtensionCont0Type<'a, 'b> = &'b u8;
+type ServerCertTypeClientExtensionCont0SType<'a, 'x> = &'x u8;
+type ServerCertTypeClientExtensionCont0Input<'a, 'b, 'x> = POrSType<ServerCertTypeClientExtensionCont0Type<'a, 'b>, ServerCertTypeClientExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ServerCertTypeClientExtensionCont0Input<'a, 'b, 'x>> for ServerCertTypeClientExtensionCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<CertificateTypeCombinator>>;
 
-    open spec fn requires(&self, deps: PskKeyExchangeModesCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: ServerCertTypeClientExtensionCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U8, predicate: Predicate13984338198318635021 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: PskKeyExchangeModesCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_psk_key_exchange_modes_cont0(deps@)
+    open spec fn ensures(&self, deps: ServerCertTypeClientExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_server_cert_type_client_extension_cont0(deps@)
     }
 
-    fn apply(&self, deps: PskKeyExchangeModesCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: ServerCertTypeClientExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(psk_key_exchange_mode()))
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(certificate_type()))
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(psk_key_exchange_mode()))
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(certificate_type()))
             }
         }
     }
 }
                 
 
-pub struct SpecPskBinderEntry {
-    pub l: u8,
-    pub entries: Seq<u8>,
+pub enum SpecClientHelloExtensionRest {
+    MaxFragmentLength(u8),
+    Heartbeat(u8),
+    SignedCertificateTimeStamp(SpecSignedCertificateTimestampList),
+    ClientCertificateType(SpecClientCertTypeClientExtension),
+    ServerCertificateType(SpecServerCertTypeClientExtension),
+    Padding(Seq<u8>),
+    Cookie(SpecCookie),
+    CertificateAuthorities(SpecCertificateAuthoritiesExtension),
+    OidFilters(SpecOidFilterExtension),
+    SignatureAlgorithmsCert(SpecSignatureSchemeList),
+    Unrecognized(Seq<u8>),
 }
 
-pub type SpecPskBinderEntryInner = (u8, Seq<u8>);
-
-
-impl SpecFrom<SpecPskBinderEntry> for SpecPskBinderEntryInner {
-    open spec fn spec_from(m: SpecPskBinderEntry) -> SpecPskBinderEntryInner {
-        (m.l, m.entries)
-    }
-}
+pub type SpecClientHelloExtensionRestInner = Either<u8, Either<u8, Either<SpecSignedCertificateTimestampList, Either<SpecClientCertTypeClientExtension, Either<SpecServerCertTypeClientExtension, Either<Seq<u8>, Either<SpecCookie, Either<SpecCertificateAuthoritiesExtension, Either<SpecOidFilterExtension, Either<SpecSignatureSchemeList, Seq<u8>>>>>>>>>>>;
 
-impl SpecFrom<SpecPskBinderEntryInner> for SpecPskBinderEntry {
-    open spec fn spec_from(m: SpecPskBinderEntryInner) -> SpecPskBinderEntry {
-        let (l, entries) = m;
-        SpecPskBinderEntry { l, entries }
+impl SpecFrom<SpecClientHelloExtensionRest> for SpecClientHelloExtensionRestInner {
+    open spec fn spec_from(m: SpecClientHelloExtensionRest) -> SpecClientHelloExtensionRestInner {
+        match m {
+            SpecClientHelloExtensionRest::MaxFragmentLength(m) => Either::Left(m),
+            SpecClientHelloExtensionRest::Heartbeat(m) => Either::Right(Either::Left(m)),
+            SpecClientHelloExtensionRest::SignedCertificateTimeStamp(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecClientHelloExtensionRest::ClientCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecClientHelloExtensionRest::ServerCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecClientHelloExtensionRest::Padding(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            SpecClientHelloExtensionRest::Cookie(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            SpecClientHelloExtensionRest::CertificateAuthorities(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
+            SpecClientHelloExtensionRest::OidFilters(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
+            SpecClientHelloExtensionRest::SignatureAlgorithmsCert(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))),
+            SpecClientHelloExtensionRest::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))),
+        }
     }
+
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct PskBinderEntry<'a> {
-    pub l: u8,
-    pub entries: &'a [u8],
+                
+impl SpecFrom<SpecClientHelloExtensionRestInner> for SpecClientHelloExtensionRest {
+    open spec fn spec_from(m: SpecClientHelloExtensionRestInner) -> SpecClientHelloExtensionRest {
+        match m {
+            Either::Left(m) => SpecClientHelloExtensionRest::MaxFragmentLength(m),
+            Either::Right(Either::Left(m)) => SpecClientHelloExtensionRest::Heartbeat(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecClientHelloExtensionRest::SignedCertificateTimeStamp(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecClientHelloExtensionRest::ClientCertificateType(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecClientHelloExtensionRest::ServerCertificateType(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecClientHelloExtensionRest::Padding(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => SpecClientHelloExtensionRest::Cookie(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => SpecClientHelloExtensionRest::CertificateAuthorities(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => SpecClientHelloExtensionRest::OidFilters(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))) => SpecClientHelloExtensionRest::SignatureAlgorithmsCert(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))) => SpecClientHelloExtensionRest::Unrecognized(m),
+        }
+    }
+
 }
 
-impl View for PskBinderEntry<'_> {
-    type V = SpecPskBinderEntry;
 
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ClientHelloExtensionRest<'a> {
+    MaxFragmentLength(u8),
+    Heartbeat(u8),
+    SignedCertificateTimeStamp(SignedCertificateTimestampList<'a>),
+    ClientCertificateType(ClientCertTypeClientExtension),
+    ServerCertificateType(ServerCertTypeClientExtension),
+    Padding(&'a [u8]),
+    Cookie(Cookie<'a>),
+    CertificateAuthorities(CertificateAuthoritiesExtension<'a>),
+    OidFilters(OidFilterExtension<'a>),
+    SignatureAlgorithmsCert(SignatureSchemeList),
+    Unrecognized(&'a [u8]),
+}
+
+pub type ClientHelloExtensionRestInner<'a> = Either<u8, Either<u8, Either<SignedCertificateTimestampList<'a>, Either<ClientCertTypeClientExtension, Either<ServerCertTypeClientExtension, Either<&'a [u8], Either<Cookie<'a>, Either<CertificateAuthoritiesExtension<'a>, Either<OidFilterExtension<'a>, Either<SignatureSchemeList, &'a [u8]>>>>>>>>>>;
+
+pub type ClientHelloExtensionRestInnerRef<'a> = Either<&'a u8, Either<&'a u8, Either<&'a SignedCertificateTimestampList<'a>, Either<&'a ClientCertTypeClientExtension, Either<&'a ServerCertTypeClientExtension, Either<&'a &'a [u8], Either<&'a Cookie<'a>, Either<&'a CertificateAuthoritiesExtension<'a>, Either<&'a OidFilterExtension<'a>, Either<&'a SignatureSchemeList, &'a &'a [u8]>>>>>>>>>>;
+
+
+impl<'a> View for ClientHelloExtensionRest<'a> {
+    type V = SpecClientHelloExtensionRest;
     open spec fn view(&self) -> Self::V {
-        SpecPskBinderEntry {
-            l: self.l@,
-            entries: self.entries@,
+        match self {
+            ClientHelloExtensionRest::MaxFragmentLength(m) => SpecClientHelloExtensionRest::MaxFragmentLength(m@),
+            ClientHelloExtensionRest::Heartbeat(m) => SpecClientHelloExtensionRest::Heartbeat(m@),
+            ClientHelloExtensionRest::SignedCertificateTimeStamp(m) => SpecClientHelloExtensionRest::SignedCertificateTimeStamp(m@),
+            ClientHelloExtensionRest::ClientCertificateType(m) => SpecClientHelloExtensionRest::ClientCertificateType(m@),
+            ClientHelloExtensionRest::ServerCertificateType(m) => SpecClientHelloExtensionRest::ServerCertificateType(m@),
+            ClientHelloExtensionRest::Padding(m) => SpecClientHelloExtensionRest::Padding(m@),
+            ClientHelloExtensionRest::Cookie(m) => SpecClientHelloExtensionRest::Cookie(m@),
+            ClientHelloExtensionRest::CertificateAuthorities(m) => SpecClientHelloExtensionRest::CertificateAuthorities(m@),
+            ClientHelloExtensionRest::OidFilters(m) => SpecClientHelloExtensionRest::OidFilters(m@),
+            ClientHelloExtensionRest::SignatureAlgorithmsCert(m) => SpecClientHelloExtensionRest::SignatureAlgorithmsCert(m@),
+            ClientHelloExtensionRest::Unrecognized(m) => SpecClientHelloExtensionRest::Unrecognized(m@),
         }
     }
 }
-pub type PskBinderEntryInner<'a> = (u8, &'a [u8]);
 
-pub type PskBinderEntryInnerRef<'a> = (&'a u8, &'a &'a [u8]);
-impl<'a> From<&'a PskBinderEntry<'a>> for PskBinderEntryInnerRef<'a> {
-    fn ex_from(m: &'a PskBinderEntry) -> PskBinderEntryInnerRef<'a> {
-        (&m.l, &m.entries)
+
+impl<'a> From<&'a ClientHelloExtensionRest<'a>> for ClientHelloExtensionRestInnerRef<'a> {
+    fn ex_from(m: &'a ClientHelloExtensionRest<'a>) -> ClientHelloExtensionRestInnerRef<'a> {
+        match m {
+            ClientHelloExtensionRest::MaxFragmentLength(m) => Either::Left(m),
+            ClientHelloExtensionRest::Heartbeat(m) => Either::Right(Either::Left(m)),
+            ClientHelloExtensionRest::SignedCertificateTimeStamp(m) => Either::Right(Either::Right(Either::Left(m))),
+            ClientHelloExtensionRest::ClientCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            ClientHelloExtensionRest::ServerCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            ClientHelloExtensionRest::Padding(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            ClientHelloExtensionRest::Cookie(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            ClientHelloExtensionRest::CertificateAuthorities(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
+            ClientHelloExtensionRest::OidFilters(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
+            ClientHelloExtensionRest::SignatureAlgorithmsCert(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))),
+            ClientHelloExtensionRest::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))),
+        }
     }
+
 }
 
-impl<'a> From<PskBinderEntryInner<'a>> for PskBinderEntry<'a> {
-    fn ex_from(m: PskBinderEntryInner) -> PskBinderEntry {
-        let (l, entries) = m;
-        PskBinderEntry { l, entries }
+impl<'a> From<ClientHelloExtensionRestInner<'a>> for ClientHelloExtensionRest<'a> {
+    fn ex_from(m: ClientHelloExtensionRestInner<'a>) -> ClientHelloExtensionRest<'a> {
+        match m {
+            Either::Left(m) => ClientHelloExtensionRest::MaxFragmentLength(m),
+            Either::Right(Either::Left(m)) => ClientHelloExtensionRest::Heartbeat(m),
+            Either::Right(Either::Right(Either::Left(m))) => ClientHelloExtensionRest::SignedCertificateTimeStamp(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => ClientHelloExtensionRest::ClientCertificateType(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => ClientHelloExtensionRest::ServerCertificateType(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => ClientHelloExtensionRest::Padding(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => ClientHelloExtensionRest::Cookie(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => ClientHelloExtensionRest::CertificateAuthorities(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => ClientHelloExtensionRest::OidFilters(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))) => ClientHelloExtensionRest::SignatureAlgorithmsCert(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))) => ClientHelloExtensionRest::Unrecognized(m),
+        }
     }
+    
 }
 
-pub struct PskBinderEntryMapper;
-impl View for PskBinderEntryMapper {
+
+pub struct ClientHelloExtensionRestMapper;
+impl View for ClientHelloExtensionRestMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for PskBinderEntryMapper {
-    type Src = SpecPskBinderEntryInner;
-    type Dst = SpecPskBinderEntry;
+impl SpecIso for ClientHelloExtensionRestMapper {
+    type Src = SpecClientHelloExtensionRestInner;
+    type Dst = SpecClientHelloExtensionRest;
 }
-impl SpecIsoProof for PskBinderEntryMapper {
+impl SpecIsoProof for ClientHelloExtensionRestMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -14983,261 +14017,363 @@ impl SpecIsoProof for PskBinderEntryMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for PskBinderEntryMapper {
-    type Src = PskBinderEntryInner<'a>;
-    type Dst = PskBinderEntry<'a>;
-    type RefSrc = PskBinderEntryInnerRef<'a>;
+impl<'a> Iso<'a> for ClientHelloExtensionRestMapper {
+    type Src = ClientHelloExtensionRestInner<'a>;
+    type Dst = ClientHelloExtensionRest<'a>;
+    type RefSrc = ClientHelloExtensionRestInnerRef<'a>;
 }
 
-pub struct SpecPskBinderEntryCombinator(pub SpecPskBinderEntryCombinatorAlias);
+type SpecClientHelloExtensionRestCombinatorAlias1 = Choice<Cond<SpecSignatureSchemeListCombinator>, Cond<bytes::Variable>>;
+type SpecClientHelloExtensionRestCombinatorAlias2 = Choice<Cond<SpecOidFilterExtensionCombinator>, SpecClientHelloExtensionRestCombinatorAlias1>;
+type SpecClientHelloExtensionRestCombinatorAlias3 = Choice<Cond<SpecCertificateAuthoritiesExtensionCombinator>, SpecClientHelloExtensionRestCombinatorAlias2>;
+type SpecClientHelloExtensionRestCombinatorAlias4 = Choice<Cond<SpecCookieCombinator>, SpecClientHelloExtensionRestCombinatorAlias3>;
+type SpecClientHelloExtensionRestCombinatorAlias5 = Choice<Cond<bytes::Variable>, SpecClientHelloExtensionRestCombinatorAlias4>;
+type SpecClientHelloExtensionRestCombinatorAlias6 = Choice<Cond<SpecServerCertTypeClientExtensionCombinator>, SpecClientHelloExtensionRestCombinatorAlias5>;
+type SpecClientHelloExtensionRestCombinatorAlias7 = Choice<Cond<SpecClientCertTypeClientExtensionCombinator>, SpecClientHelloExtensionRestCombinatorAlias6>;
+type SpecClientHelloExtensionRestCombinatorAlias8 = Choice<Cond<SpecSignedCertificateTimestampListCombinator>, SpecClientHelloExtensionRestCombinatorAlias7>;
+type SpecClientHelloExtensionRestCombinatorAlias9 = Choice<Cond<SpecHeartbeatModeCombinator>, SpecClientHelloExtensionRestCombinatorAlias8>;
+type SpecClientHelloExtensionRestCombinatorAlias10 = Choice<Cond<SpecMaxFragmentLengthCombinator>, SpecClientHelloExtensionRestCombinatorAlias9>;
+pub struct SpecClientHelloExtensionRestCombinator(pub SpecClientHelloExtensionRestCombinatorAlias);
 
-impl SpecCombinator for SpecPskBinderEntryCombinator {
-    type Type = SpecPskBinderEntry;
+impl SpecCombinator for SpecClientHelloExtensionRestCombinator {
+    type Type = SpecClientHelloExtensionRest;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecPskBinderEntryCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecPskBinderEntryCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecClientHelloExtensionRestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecClientHelloExtensionRestCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecPskBinderEntryCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate12415296748708102903>, bytes::Variable>, PskBinderEntryMapper>;
-pub struct Predicate12415296748708102903;
-impl View for Predicate12415296748708102903 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u8> for Predicate12415296748708102903 {
-    fn apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        (i >= 32 && i <= 255)
-    }
-}
-impl SpecPred<u8> for Predicate12415296748708102903 {
-    open spec fn spec_apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        (i >= 32 && i <= 255)
-    }
+pub type SpecClientHelloExtensionRestCombinatorAlias = Mapped<SpecClientHelloExtensionRestCombinatorAlias10, ClientHelloExtensionRestMapper>;
+type ClientHelloExtensionRestCombinatorAlias1 = Choice<Cond<SignatureSchemeListCombinator>, Cond<bytes::Variable>>;
+type ClientHelloExtensionRestCombinatorAlias2 = Choice<Cond<OidFilterExtensionCombinator>, ClientHelloExtensionRestCombinator1>;
+type ClientHelloExtensionRestCombinatorAlias3 = Choice<Cond<CertificateAuthoritiesExtensionCombinator>, ClientHelloExtensionRestCombinator2>;
+type ClientHelloExtensionRestCombinatorAlias4 = Choice<Cond<CookieCombinator>, ClientHelloExtensionRestCombinator3>;
+type ClientHelloExtensionRestCombinatorAlias5 = Choice<Cond<bytes::Variable>, ClientHelloExtensionRestCombinator4>;
+type ClientHelloExtensionRestCombinatorAlias6 = Choice<Cond<ServerCertTypeClientExtensionCombinator>, ClientHelloExtensionRestCombinator5>;
+type ClientHelloExtensionRestCombinatorAlias7 = Choice<Cond<ClientCertTypeClientExtensionCombinator>, ClientHelloExtensionRestCombinator6>;
+type ClientHelloExtensionRestCombinatorAlias8 = Choice<Cond<SignedCertificateTimestampListCombinator>, ClientHelloExtensionRestCombinator7>;
+type ClientHelloExtensionRestCombinatorAlias9 = Choice<Cond<HeartbeatModeCombinator>, ClientHelloExtensionRestCombinator8>;
+type ClientHelloExtensionRestCombinatorAlias10 = Choice<Cond<MaxFragmentLengthCombinator>, ClientHelloExtensionRestCombinator9>;
+pub struct ClientHelloExtensionRestCombinator1(pub ClientHelloExtensionRestCombinatorAlias1);
+impl View for ClientHelloExtensionRestCombinator1 {
+    type V = SpecClientHelloExtensionRestCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ClientHelloExtensionRestCombinator1, ClientHelloExtensionRestCombinatorAlias1);
 
-pub struct PskBinderEntryCombinator(pub PskBinderEntryCombinatorAlias);
-
-impl View for PskBinderEntryCombinator {
-    type V = SpecPskBinderEntryCombinator;
-    open spec fn view(&self) -> Self::V { SpecPskBinderEntryCombinator(self.0@) }
+pub struct ClientHelloExtensionRestCombinator2(pub ClientHelloExtensionRestCombinatorAlias2);
+impl View for ClientHelloExtensionRestCombinator2 {
+    type V = SpecClientHelloExtensionRestCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskBinderEntryCombinator {
-    type Type = PskBinderEntry<'a>;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type PskBinderEntryCombinatorAlias = Mapped<Pair<Refined<U8, Predicate12415296748708102903>, bytes::Variable, PskBinderEntryCont0>, PskBinderEntryMapper>;
-
+impl_wrapper_combinator!(ClientHelloExtensionRestCombinator2, ClientHelloExtensionRestCombinatorAlias2);
 
-pub open spec fn spec_psk_binder_entry() -> SpecPskBinderEntryCombinator {
-    SpecPskBinderEntryCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate12415296748708102903 }, |deps| spec_psk_binder_entry_cont0(deps)),
-        mapper: PskBinderEntryMapper,
-    })
+pub struct ClientHelloExtensionRestCombinator3(pub ClientHelloExtensionRestCombinatorAlias3);
+impl View for ClientHelloExtensionRestCombinator3 {
+    type V = SpecClientHelloExtensionRestCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ClientHelloExtensionRestCombinator3, ClientHelloExtensionRestCombinatorAlias3);
 
-pub open spec fn spec_psk_binder_entry_cont0(deps: u8) -> bytes::Variable {
-    let l = deps;
-    bytes::Variable(l.spec_into())
+pub struct ClientHelloExtensionRestCombinator4(pub ClientHelloExtensionRestCombinatorAlias4);
+impl View for ClientHelloExtensionRestCombinator4 {
+    type V = SpecClientHelloExtensionRestCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ClientHelloExtensionRestCombinator4, ClientHelloExtensionRestCombinatorAlias4);
 
-impl View for PskBinderEntryCont0 {
-    type V = spec_fn(u8) -> bytes::Variable;
+pub struct ClientHelloExtensionRestCombinator5(pub ClientHelloExtensionRestCombinatorAlias5);
+impl View for ClientHelloExtensionRestCombinator5 {
+    type V = SpecClientHelloExtensionRestCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloExtensionRestCombinator5, ClientHelloExtensionRestCombinatorAlias5);
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u8| {
-            spec_psk_binder_entry_cont0(deps)
-        }
-    }
+pub struct ClientHelloExtensionRestCombinator6(pub ClientHelloExtensionRestCombinatorAlias6);
+impl View for ClientHelloExtensionRestCombinator6 {
+    type V = SpecClientHelloExtensionRestCombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ClientHelloExtensionRestCombinator6, ClientHelloExtensionRestCombinatorAlias6);
 
-                
-pub fn psk_binder_entry<'a>() -> (o: PskBinderEntryCombinator)
-    ensures o@ == spec_psk_binder_entry(),
+pub struct ClientHelloExtensionRestCombinator7(pub ClientHelloExtensionRestCombinatorAlias7);
+impl View for ClientHelloExtensionRestCombinator7 {
+    type V = SpecClientHelloExtensionRestCombinatorAlias7;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloExtensionRestCombinator7, ClientHelloExtensionRestCombinatorAlias7);
+
+pub struct ClientHelloExtensionRestCombinator8(pub ClientHelloExtensionRestCombinatorAlias8);
+impl View for ClientHelloExtensionRestCombinator8 {
+    type V = SpecClientHelloExtensionRestCombinatorAlias8;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloExtensionRestCombinator8, ClientHelloExtensionRestCombinatorAlias8);
+
+pub struct ClientHelloExtensionRestCombinator9(pub ClientHelloExtensionRestCombinatorAlias9);
+impl View for ClientHelloExtensionRestCombinator9 {
+    type V = SpecClientHelloExtensionRestCombinatorAlias9;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloExtensionRestCombinator9, ClientHelloExtensionRestCombinatorAlias9);
+
+pub struct ClientHelloExtensionRestCombinator10(pub ClientHelloExtensionRestCombinatorAlias10);
+impl View for ClientHelloExtensionRestCombinator10 {
+    type V = SpecClientHelloExtensionRestCombinatorAlias10;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloExtensionRestCombinator10, ClientHelloExtensionRestCombinatorAlias10);
+
+pub struct ClientHelloExtensionRestCombinator(pub ClientHelloExtensionRestCombinatorAlias);
+
+impl View for ClientHelloExtensionRestCombinator {
+    type V = SpecClientHelloExtensionRestCombinator;
+    open spec fn view(&self) -> Self::V { SpecClientHelloExtensionRestCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientHelloExtensionRestCombinator {
+    type Type = ClientHelloExtensionRest<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ClientHelloExtensionRestCombinatorAlias = Mapped<ClientHelloExtensionRestCombinator10, ClientHelloExtensionRestMapper>;
+
+
+pub open spec fn spec_client_hello_extension_rest(ext_len: u16, extension_type: u16) -> SpecClientHelloExtensionRestCombinator {
+    SpecClientHelloExtensionRestCombinator(Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_MaxFragmentLength, inner: spec_max_fragment_length() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_Heartbeat, inner: spec_heartbeat_mode() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp, inner: spec_signed_certificate_timestamp_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ClientCertificateType, inner: spec_client_cert_type_client_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ServerCertificateType, inner: spec_server_cert_type_client_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_Padding, inner: bytes::Variable((usize::spec_from(ext_len)) as usize) }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_Cookie, inner: spec_cookie() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_CertificateAuthorities, inner: spec_certificate_authorities_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_OidFilters, inner: spec_oid_filter_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignatureAlgorithmsCert, inner: spec_signature_scheme_list() }, Cond { cond: !(extension_type == ExtensionType::SPEC_MaxFragmentLength || extension_type == ExtensionType::SPEC_Heartbeat || extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp || extension_type == ExtensionType::SPEC_ClientCertificateType || extension_type == ExtensionType::SPEC_ServerCertificateType || extension_type == ExtensionType::SPEC_Padding || extension_type == ExtensionType::SPEC_Cookie || extension_type == ExtensionType::SPEC_CertificateAuthorities || extension_type == ExtensionType::SPEC_OidFilters || extension_type == ExtensionType::SPEC_SignatureAlgorithmsCert), inner: bytes::Variable((usize::spec_from(ext_len)) as usize) })))))))))), mapper: ClientHelloExtensionRestMapper })
+}
+
+pub fn client_hello_extension_rest<'a>(ext_len: u16, extension_type: u16) -> (o: ClientHelloExtensionRestCombinator)
+    requires
+        spec_extension_type().wf(extension_type@),
+
+    ensures o@ == spec_client_hello_extension_rest(ext_len@, extension_type@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = PskBinderEntryCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U8, predicate: Predicate12415296748708102903 }, PskBinderEntryCont0),
-        mapper: PskBinderEntryMapper,
-    });
-    assert({
-        &&& combinator@ == spec_psk_binder_entry()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ClientHelloExtensionRestCombinator(Mapped { inner: ClientHelloExtensionRestCombinator10(Choice::new(Cond { cond: extension_type == ExtensionType::MaxFragmentLength, inner: max_fragment_length() }, ClientHelloExtensionRestCombinator9(Choice::new(Cond { cond: extension_type == ExtensionType::Heartbeat, inner: heartbeat_mode() }, ClientHelloExtensionRestCombinator8(Choice::new(Cond { cond: extension_type == ExtensionType::SignedCertificateTimeStamp, inner: signed_certificate_timestamp_list() }, ClientHelloExtensionRestCombinator7(Choice::new(Cond { cond: extension_type == ExtensionType::ClientCertificateType, inner: client_cert_type_client_extension() }, ClientHelloExtensionRestCombinator6(Choice::new(Cond { cond: extension_type == ExtensionType::ServerCertificateType, inner: server_cert_type_client_extension() }, ClientHelloExtensionRestCombinator5(Choice::new(Cond { cond: extension_type == ExtensionType::Padding, inner: bytes::Variable((usize::ex_from(ext_len)) as usize) }, ClientHelloExtensionRestCombinator4(Choice::new(Cond { cond: extension_type == ExtensionType::Cookie, inner: cookie() }, ClientHelloExtensionRestCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::CertificateAuthorities, inner: certificate_authorities_extension() }, ClientHelloExtensionRestCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::OidFilters, inner: oid_filter_extension() }, ClientHelloExtensionRestCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::SignatureAlgorithmsCert, inner: signature_scheme_list() }, Cond { cond: !(extension_type == ExtensionType::MaxFragmentLength || extension_type == ExtensionType::Heartbeat || extension_type == ExtensionType::SignedCertificateTimeStamp || extension_type == ExtensionType::ClientCertificateType || extension_type == ExtensionType::ServerCertificateType || extension_type == ExtensionType::Padding || extension_type == ExtensionType::Cookie || extension_type == ExtensionType::CertificateAuthorities || extension_type == ExtensionType::OidFilters || extension_type == ExtensionType::SignatureAlgorithmsCert), inner: bytes::Variable((usize::ex_from(ext_len)) as usize) })))))))))))))))))))), mapper: ClientHelloExtensionRestMapper });
+    // assert({
+    //     &&& combinator@ == spec_client_hello_extension_rest(ext_len@, extension_type@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_psk_binder_entry<'a>(input: &'a [u8]) -> (res: PResult<<PskBinderEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_client_hello_extension_rest<'a>(input: &'a [u8], ext_len: u16, extension_type: u16) -> (res: PResult<<ClientHelloExtensionRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_psk_binder_entry().spec_parse(input@) == Some((n as int, v@)),
-        spec_psk_binder_entry().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_client_hello_extension_rest(ext_len@, extension_type@).spec_parse(input@) == Some((n as int, v@)),
+        spec_client_hello_extension_rest(ext_len@, extension_type@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_psk_binder_entry().spec_parse(input@) is None,
-        spec_psk_binder_entry().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_client_hello_extension_rest(ext_len@, extension_type@).spec_parse(input@) is None,
+        spec_client_hello_extension_rest(ext_len@, extension_type@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = psk_binder_entry();
+    let combinator = client_hello_extension_rest( ext_len, extension_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_psk_binder_entry<'a>(v: <PskBinderEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_client_hello_extension_rest<'a>(v: <ClientHelloExtensionRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16, extension_type: u16) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_psk_binder_entry().wf(v@),
+        spec_client_hello_extension_rest(ext_len@, extension_type@).wf(v@),
+        spec_extension_type().wf(extension_type@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_psk_binder_entry().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_psk_binder_entry().spec_serialize(v@))
+            &&& n == spec_client_hello_extension_rest(ext_len@, extension_type@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_client_hello_extension_rest(ext_len@, extension_type@).spec_serialize(v@))
         },
 {
-    let combinator = psk_binder_entry();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = client_hello_extension_rest( ext_len, extension_type );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn psk_binder_entry_len<'a>(v: <PskBinderEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn client_hello_extension_rest_len<'a>(v: <ClientHelloExtensionRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16, extension_type: u16) -> (serialize_len: usize)
     requires
-        spec_psk_binder_entry().wf(v@),
-        spec_psk_binder_entry().spec_serialize(v@).len() <= usize::MAX,
+        spec_client_hello_extension_rest(ext_len@, extension_type@).wf(v@),
+        spec_client_hello_extension_rest(ext_len@, extension_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        serialize_len == spec_psk_binder_entry().spec_serialize(v@).len(),
+        serialize_len == spec_client_hello_extension_rest(ext_len@, extension_type@).spec_serialize(v@).len(),
 {
-    let combinator = psk_binder_entry();
+    let combinator = client_hello_extension_rest( ext_len, extension_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct PskBinderEntryCont0;
-type PskBinderEntryCont0Type<'a, 'b> = &'b u8;
-type PskBinderEntryCont0SType<'a, 'x> = &'x u8;
-type PskBinderEntryCont0Input<'a, 'b, 'x> = POrSType<PskBinderEntryCont0Type<'a, 'b>, PskBinderEntryCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<PskBinderEntryCont0Input<'a, 'b, 'x>> for PskBinderEntryCont0 {
-    type Output = bytes::Variable;
 
-    open spec fn requires(&self, deps: PskBinderEntryCont0Input<'a, 'b, 'x>) -> bool { true }
+pub enum SpecClientHelloExtensionExtensionData {
+    ServerName(SpecServerNameList),
+    SignatureAlgorithms(SpecSignatureSchemeList),
+    SupportedGroups(SpecNamedGroupList),
+    StatusRequest(SpecCertificateStatusRequest),
+    ApplicationLayerProtocolNegotiation(SpecProtocolNameList),
+    SupportedVersions(SpecSupportedVersionsClient),
+    KeyShare(SpecKeyShareClientHello),
+    PskKeyExchangeModes(SpecPskKeyExchangeModes),
+    PreSharedKey(SpecPreSharedKeyClientExtension),
+    Unrecognized(SpecClientHelloExtensionRest),
+}
 
-    open spec fn ensures(&self, deps: PskBinderEntryCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_psk_binder_entry_cont0(deps@)
-    }
+pub type SpecClientHelloExtensionExtensionDataInner = Either<SpecServerNameList, Either<SpecSignatureSchemeList, Either<SpecNamedGroupList, Either<SpecCertificateStatusRequest, Either<SpecProtocolNameList, Either<SpecSupportedVersionsClient, Either<SpecKeyShareClientHello, Either<SpecPskKeyExchangeModes, Either<SpecPreSharedKeyClientExtension, SpecClientHelloExtensionRest>>>>>>>>>;
 
-    fn apply(&self, deps: PskBinderEntryCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                bytes::Variable(l.ex_into())
-            }
+impl SpecFrom<SpecClientHelloExtensionExtensionData> for SpecClientHelloExtensionExtensionDataInner {
+    open spec fn spec_from(m: SpecClientHelloExtensionExtensionData) -> SpecClientHelloExtensionExtensionDataInner {
+        match m {
+            SpecClientHelloExtensionExtensionData::ServerName(m) => Either::Left(m),
+            SpecClientHelloExtensionExtensionData::SignatureAlgorithms(m) => Either::Right(Either::Left(m)),
+            SpecClientHelloExtensionExtensionData::SupportedGroups(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecClientHelloExtensionExtensionData::StatusRequest(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecClientHelloExtensionExtensionData::SupportedVersions(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            SpecClientHelloExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            SpecClientHelloExtensionExtensionData::PskKeyExchangeModes(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
+            SpecClientHelloExtensionExtensionData::PreSharedKey(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
+            SpecClientHelloExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))),
         }
     }
+
 }
+
                 
+impl SpecFrom<SpecClientHelloExtensionExtensionDataInner> for SpecClientHelloExtensionExtensionData {
+    open spec fn spec_from(m: SpecClientHelloExtensionExtensionDataInner) -> SpecClientHelloExtensionExtensionData {
+        match m {
+            Either::Left(m) => SpecClientHelloExtensionExtensionData::ServerName(m),
+            Either::Right(Either::Left(m)) => SpecClientHelloExtensionExtensionData::SignatureAlgorithms(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecClientHelloExtensionExtensionData::SupportedGroups(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecClientHelloExtensionExtensionData::StatusRequest(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecClientHelloExtensionExtensionData::SupportedVersions(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => SpecClientHelloExtensionExtensionData::KeyShare(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => SpecClientHelloExtensionExtensionData::PskKeyExchangeModes(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => SpecClientHelloExtensionExtensionData::PreSharedKey(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))) => SpecClientHelloExtensionExtensionData::Unrecognized(m),
+        }
+    }
 
-pub struct SpecPskBinderEntries {
-    pub l: u16,
-    pub list: Seq<SpecPskBinderEntry>,
 }
 
-pub type SpecPskBinderEntriesInner = (u16, Seq<SpecPskBinderEntry>);
 
 
-impl SpecFrom<SpecPskBinderEntries> for SpecPskBinderEntriesInner {
-    open spec fn spec_from(m: SpecPskBinderEntries) -> SpecPskBinderEntriesInner {
-        (m.l, m.list)
-    }
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ClientHelloExtensionExtensionData<'a> {
+    ServerName(ServerNameList<'a>),
+    SignatureAlgorithms(SignatureSchemeList),
+    SupportedGroups(NamedGroupList),
+    StatusRequest(CertificateStatusRequest<'a>),
+    ApplicationLayerProtocolNegotiation(ProtocolNameList<'a>),
+    SupportedVersions(SupportedVersionsClient),
+    KeyShare(KeyShareClientHello<'a>),
+    PskKeyExchangeModes(PskKeyExchangeModes),
+    PreSharedKey(PreSharedKeyClientExtension<'a>),
+    Unrecognized(ClientHelloExtensionRest<'a>),
 }
 
-impl SpecFrom<SpecPskBinderEntriesInner> for SpecPskBinderEntries {
-    open spec fn spec_from(m: SpecPskBinderEntriesInner) -> SpecPskBinderEntries {
-        let (l, list) = m;
-        SpecPskBinderEntries { l, list }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
+pub type ClientHelloExtensionExtensionDataInner<'a> = Either<ServerNameList<'a>, Either<SignatureSchemeList, Either<NamedGroupList, Either<CertificateStatusRequest<'a>, Either<ProtocolNameList<'a>, Either<SupportedVersionsClient, Either<KeyShareClientHello<'a>, Either<PskKeyExchangeModes, Either<PreSharedKeyClientExtension<'a>, ClientHelloExtensionRest<'a>>>>>>>>>>;
 
-pub struct PskBinderEntries<'a> {
-    pub l: u16,
-    pub list: RepeatResult<PskBinderEntry<'a>>,
-}
+pub type ClientHelloExtensionExtensionDataInnerRef<'a> = Either<&'a ServerNameList<'a>, Either<&'a SignatureSchemeList, Either<&'a NamedGroupList, Either<&'a CertificateStatusRequest<'a>, Either<&'a ProtocolNameList<'a>, Either<&'a SupportedVersionsClient, Either<&'a KeyShareClientHello<'a>, Either<&'a PskKeyExchangeModes, Either<&'a PreSharedKeyClientExtension<'a>, &'a ClientHelloExtensionRest<'a>>>>>>>>>>;
 
-impl View for PskBinderEntries<'_> {
-    type V = SpecPskBinderEntries;
 
+impl<'a> View for ClientHelloExtensionExtensionData<'a> {
+    type V = SpecClientHelloExtensionExtensionData;
     open spec fn view(&self) -> Self::V {
-        SpecPskBinderEntries {
-            l: self.l@,
-            list: self.list@,
+        match self {
+            ClientHelloExtensionExtensionData::ServerName(m) => SpecClientHelloExtensionExtensionData::ServerName(m@),
+            ClientHelloExtensionExtensionData::SignatureAlgorithms(m) => SpecClientHelloExtensionExtensionData::SignatureAlgorithms(m@),
+            ClientHelloExtensionExtensionData::SupportedGroups(m) => SpecClientHelloExtensionExtensionData::SupportedGroups(m@),
+            ClientHelloExtensionExtensionData::StatusRequest(m) => SpecClientHelloExtensionExtensionData::StatusRequest(m@),
+            ClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => SpecClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m@),
+            ClientHelloExtensionExtensionData::SupportedVersions(m) => SpecClientHelloExtensionExtensionData::SupportedVersions(m@),
+            ClientHelloExtensionExtensionData::KeyShare(m) => SpecClientHelloExtensionExtensionData::KeyShare(m@),
+            ClientHelloExtensionExtensionData::PskKeyExchangeModes(m) => SpecClientHelloExtensionExtensionData::PskKeyExchangeModes(m@),
+            ClientHelloExtensionExtensionData::PreSharedKey(m) => SpecClientHelloExtensionExtensionData::PreSharedKey(m@),
+            ClientHelloExtensionExtensionData::Unrecognized(m) => SpecClientHelloExtensionExtensionData::Unrecognized(m@),
         }
     }
 }
-pub type PskBinderEntriesInner<'a> = (u16, RepeatResult<PskBinderEntry<'a>>);
 
-pub type PskBinderEntriesInnerRef<'a> = (&'a u16, &'a RepeatResult<PskBinderEntry<'a>>);
-impl<'a> From<&'a PskBinderEntries<'a>> for PskBinderEntriesInnerRef<'a> {
-    fn ex_from(m: &'a PskBinderEntries) -> PskBinderEntriesInnerRef<'a> {
-        (&m.l, &m.list)
+
+impl<'a> From<&'a ClientHelloExtensionExtensionData<'a>> for ClientHelloExtensionExtensionDataInnerRef<'a> {
+    fn ex_from(m: &'a ClientHelloExtensionExtensionData<'a>) -> ClientHelloExtensionExtensionDataInnerRef<'a> {
+        match m {
+            ClientHelloExtensionExtensionData::ServerName(m) => Either::Left(m),
+            ClientHelloExtensionExtensionData::SignatureAlgorithms(m) => Either::Right(Either::Left(m)),
+            ClientHelloExtensionExtensionData::SupportedGroups(m) => Either::Right(Either::Right(Either::Left(m))),
+            ClientHelloExtensionExtensionData::StatusRequest(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            ClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            ClientHelloExtensionExtensionData::SupportedVersions(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            ClientHelloExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            ClientHelloExtensionExtensionData::PskKeyExchangeModes(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
+            ClientHelloExtensionExtensionData::PreSharedKey(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
+            ClientHelloExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))),
+        }
     }
+
 }
 
-impl<'a> From<PskBinderEntriesInner<'a>> for PskBinderEntries<'a> {
-    fn ex_from(m: PskBinderEntriesInner) -> PskBinderEntries {
-        let (l, list) = m;
-        PskBinderEntries { l, list }
+impl<'a> From<ClientHelloExtensionExtensionDataInner<'a>> for ClientHelloExtensionExtensionData<'a> {
+    fn ex_from(m: ClientHelloExtensionExtensionDataInner<'a>) -> ClientHelloExtensionExtensionData<'a> {
+        match m {
+            Either::Left(m) => ClientHelloExtensionExtensionData::ServerName(m),
+            Either::Right(Either::Left(m)) => ClientHelloExtensionExtensionData::SignatureAlgorithms(m),
+            Either::Right(Either::Right(Either::Left(m))) => ClientHelloExtensionExtensionData::SupportedGroups(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => ClientHelloExtensionExtensionData::StatusRequest(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => ClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => ClientHelloExtensionExtensionData::SupportedVersions(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => ClientHelloExtensionExtensionData::KeyShare(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => ClientHelloExtensionExtensionData::PskKeyExchangeModes(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => ClientHelloExtensionExtensionData::PreSharedKey(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))) => ClientHelloExtensionExtensionData::Unrecognized(m),
+        }
     }
+    
 }
 
-pub struct PskBinderEntriesMapper;
-impl View for PskBinderEntriesMapper {
+
+pub struct ClientHelloExtensionExtensionDataMapper;
+impl View for ClientHelloExtensionExtensionDataMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for PskBinderEntriesMapper {
-    type Src = SpecPskBinderEntriesInner;
-    type Dst = SpecPskBinderEntries;
+impl SpecIso for ClientHelloExtensionExtensionDataMapper {
+    type Src = SpecClientHelloExtensionExtensionDataInner;
+    type Dst = SpecClientHelloExtensionExtensionData;
 }
-impl SpecIsoProof for PskBinderEntriesMapper {
+impl SpecIsoProof for ClientHelloExtensionExtensionDataMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -15245,261 +14381,281 @@ impl SpecIsoProof for PskBinderEntriesMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for PskBinderEntriesMapper {
-    type Src = PskBinderEntriesInner<'a>;
-    type Dst = PskBinderEntries<'a>;
-    type RefSrc = PskBinderEntriesInnerRef<'a>;
+impl<'a> Iso<'a> for ClientHelloExtensionExtensionDataMapper {
+    type Src = ClientHelloExtensionExtensionDataInner<'a>;
+    type Dst = ClientHelloExtensionExtensionData<'a>;
+    type RefSrc = ClientHelloExtensionExtensionDataInnerRef<'a>;
 }
 
-pub struct SpecPskBinderEntriesCombinator(pub SpecPskBinderEntriesCombinatorAlias);
+type SpecClientHelloExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecPreSharedKeyClientExtensionCombinator>, Cond<SpecClientHelloExtensionRestCombinator>>;
+type SpecClientHelloExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecPskKeyExchangeModesCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias1>;
+type SpecClientHelloExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SpecKeyShareClientHelloCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias2>;
+type SpecClientHelloExtensionExtensionDataCombinatorAlias4 = Choice<Cond<SpecSupportedVersionsClientCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias3>;
+type SpecClientHelloExtensionExtensionDataCombinatorAlias5 = Choice<Cond<SpecProtocolNameListCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias4>;
+type SpecClientHelloExtensionExtensionDataCombinatorAlias6 = Choice<Cond<SpecCertificateStatusRequestCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias5>;
+type SpecClientHelloExtensionExtensionDataCombinatorAlias7 = Choice<Cond<SpecNamedGroupListCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias6>;
+type SpecClientHelloExtensionExtensionDataCombinatorAlias8 = Choice<Cond<SpecSignatureSchemeListCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias7>;
+type SpecClientHelloExtensionExtensionDataCombinatorAlias9 = Choice<Cond<SpecServerNameListCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias8>;
+pub struct SpecClientHelloExtensionExtensionDataCombinator(pub SpecClientHelloExtensionExtensionDataCombinatorAlias);
 
-impl SpecCombinator for SpecPskBinderEntriesCombinator {
-    type Type = SpecPskBinderEntries;
+impl SpecCombinator for SpecClientHelloExtensionExtensionDataCombinator {
+    type Type = SpecClientHelloExtensionExtensionData;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecPskBinderEntriesCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecPskBinderEntriesCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecClientHelloExtensionExtensionDataCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecClientHelloExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecPskBinderEntriesCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate2895184764579107747>, AndThen<bytes::Variable, Repeat<SpecPskBinderEntryCombinator>>>, PskBinderEntriesMapper>;
-pub struct Predicate2895184764579107747;
-impl View for Predicate2895184764579107747 {
-    type V = Self;
+pub type SpecClientHelloExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecClientHelloExtensionExtensionDataCombinatorAlias9, ClientHelloExtensionExtensionDataMapper>>;
+type ClientHelloExtensionExtensionDataCombinatorAlias1 = Choice<Cond<PreSharedKeyClientExtensionCombinator>, Cond<ClientHelloExtensionRestCombinator>>;
+type ClientHelloExtensionExtensionDataCombinatorAlias2 = Choice<Cond<PskKeyExchangeModesCombinator>, ClientHelloExtensionExtensionDataCombinator1>;
+type ClientHelloExtensionExtensionDataCombinatorAlias3 = Choice<Cond<KeyShareClientHelloCombinator>, ClientHelloExtensionExtensionDataCombinator2>;
+type ClientHelloExtensionExtensionDataCombinatorAlias4 = Choice<Cond<SupportedVersionsClientCombinator>, ClientHelloExtensionExtensionDataCombinator3>;
+type ClientHelloExtensionExtensionDataCombinatorAlias5 = Choice<Cond<ProtocolNameListCombinator>, ClientHelloExtensionExtensionDataCombinator4>;
+type ClientHelloExtensionExtensionDataCombinatorAlias6 = Choice<Cond<CertificateStatusRequestCombinator>, ClientHelloExtensionExtensionDataCombinator5>;
+type ClientHelloExtensionExtensionDataCombinatorAlias7 = Choice<Cond<NamedGroupListCombinator>, ClientHelloExtensionExtensionDataCombinator6>;
+type ClientHelloExtensionExtensionDataCombinatorAlias8 = Choice<Cond<SignatureSchemeListCombinator>, ClientHelloExtensionExtensionDataCombinator7>;
+type ClientHelloExtensionExtensionDataCombinatorAlias9 = Choice<Cond<ServerNameListCombinator>, ClientHelloExtensionExtensionDataCombinator8>;
+pub struct ClientHelloExtensionExtensionDataCombinator1(pub ClientHelloExtensionExtensionDataCombinatorAlias1);
+impl View for ClientHelloExtensionExtensionDataCombinator1 {
+    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator1, ClientHelloExtensionExtensionDataCombinatorAlias1);
 
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
+pub struct ClientHelloExtensionExtensionDataCombinator2(pub ClientHelloExtensionExtensionDataCombinatorAlias2);
+impl View for ClientHelloExtensionExtensionDataCombinator2 {
+    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl Pred<u16> for Predicate2895184764579107747 {
-    fn apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 33 && i <= 65535)
-    }
+impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator2, ClientHelloExtensionExtensionDataCombinatorAlias2);
+
+pub struct ClientHelloExtensionExtensionDataCombinator3(pub ClientHelloExtensionExtensionDataCombinatorAlias3);
+impl View for ClientHelloExtensionExtensionDataCombinator3 {
+    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl SpecPred<u16> for Predicate2895184764579107747 {
-    open spec fn spec_apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 33 && i <= 65535)
-    }
+impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator3, ClientHelloExtensionExtensionDataCombinatorAlias3);
+
+pub struct ClientHelloExtensionExtensionDataCombinator4(pub ClientHelloExtensionExtensionDataCombinatorAlias4);
+impl View for ClientHelloExtensionExtensionDataCombinator4 {
+    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator4, ClientHelloExtensionExtensionDataCombinatorAlias4);
 
-pub struct PskBinderEntriesCombinator(pub PskBinderEntriesCombinatorAlias);
+pub struct ClientHelloExtensionExtensionDataCombinator5(pub ClientHelloExtensionExtensionDataCombinatorAlias5);
+impl View for ClientHelloExtensionExtensionDataCombinator5 {
+    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator5, ClientHelloExtensionExtensionDataCombinatorAlias5);
 
-impl View for PskBinderEntriesCombinator {
-    type V = SpecPskBinderEntriesCombinator;
-    open spec fn view(&self) -> Self::V { SpecPskBinderEntriesCombinator(self.0@) }
+pub struct ClientHelloExtensionExtensionDataCombinator6(pub ClientHelloExtensionExtensionDataCombinatorAlias6);
+impl View for ClientHelloExtensionExtensionDataCombinator6 {
+    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PskBinderEntriesCombinator {
-    type Type = PskBinderEntries<'a>;
+impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator6, ClientHelloExtensionExtensionDataCombinatorAlias6);
+
+pub struct ClientHelloExtensionExtensionDataCombinator7(pub ClientHelloExtensionExtensionDataCombinatorAlias7);
+impl View for ClientHelloExtensionExtensionDataCombinator7 {
+    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias7;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator7, ClientHelloExtensionExtensionDataCombinatorAlias7);
+
+pub struct ClientHelloExtensionExtensionDataCombinator8(pub ClientHelloExtensionExtensionDataCombinatorAlias8);
+impl View for ClientHelloExtensionExtensionDataCombinator8 {
+    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias8;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator8, ClientHelloExtensionExtensionDataCombinatorAlias8);
+
+pub struct ClientHelloExtensionExtensionDataCombinator9(pub ClientHelloExtensionExtensionDataCombinatorAlias9);
+impl View for ClientHelloExtensionExtensionDataCombinator9 {
+    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias9;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator9, ClientHelloExtensionExtensionDataCombinatorAlias9);
+
+pub struct ClientHelloExtensionExtensionDataCombinator(pub ClientHelloExtensionExtensionDataCombinatorAlias);
+
+impl View for ClientHelloExtensionExtensionDataCombinator {
+    type V = SpecClientHelloExtensionExtensionDataCombinator;
+    open spec fn view(&self) -> Self::V { SpecClientHelloExtensionExtensionDataCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientHelloExtensionExtensionDataCombinator {
+    type Type = ClientHelloExtensionExtensionData<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type PskBinderEntriesCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate2895184764579107747>, AndThen<bytes::Variable, Repeat<PskBinderEntryCombinator>>, PskBinderEntriesCont0>, PskBinderEntriesMapper>;
-
-
-pub open spec fn spec_psk_binder_entries() -> SpecPskBinderEntriesCombinator {
-    SpecPskBinderEntriesCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate2895184764579107747 }, |deps| spec_psk_binder_entries_cont0(deps)),
-        mapper: PskBinderEntriesMapper,
-    })
-}
-
-pub open spec fn spec_psk_binder_entries_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecPskBinderEntryCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_psk_binder_entry()))
 }
+pub type ClientHelloExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<ClientHelloExtensionExtensionDataCombinator9, ClientHelloExtensionExtensionDataMapper>>;
 
-impl View for PskBinderEntriesCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecPskBinderEntryCombinator>>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_psk_binder_entries_cont0(deps)
-        }
-    }
+pub open spec fn spec_client_hello_extension_extension_data(extension_type: u16, ext_len: u16) -> SpecClientHelloExtensionExtensionDataCombinator {
+    SpecClientHelloExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::spec_from(ext_len)) as usize), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_ServerName, inner: spec_server_name_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignatureAlgorithms, inner: spec_signature_scheme_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SupportedGroups, inner: spec_named_group_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_StatusRequest, inner: spec_certificate_status_request() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ApplicationLayerProtocolNegotiation, inner: spec_protocol_name_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SupportedVersions, inner: spec_supported_versions_client() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_KeyShare, inner: spec_key_share_client_hello() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_PskKeyExchangeModes, inner: spec_psk_key_exchange_modes() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_PreSharedKey, inner: spec_pre_shared_key_client_extension() }, Cond { cond: !(extension_type == ExtensionType::SPEC_ServerName || extension_type == ExtensionType::SPEC_SignatureAlgorithms || extension_type == ExtensionType::SPEC_SupportedGroups || extension_type == ExtensionType::SPEC_StatusRequest || extension_type == ExtensionType::SPEC_ApplicationLayerProtocolNegotiation || extension_type == ExtensionType::SPEC_SupportedVersions || extension_type == ExtensionType::SPEC_KeyShare || extension_type == ExtensionType::SPEC_PskKeyExchangeModes || extension_type == ExtensionType::SPEC_PreSharedKey), inner: spec_client_hello_extension_rest(ext_len, extension_type) }))))))))), mapper: ClientHelloExtensionExtensionDataMapper }))
 }
 
-                
-pub fn psk_binder_entries<'a>() -> (o: PskBinderEntriesCombinator)
-    ensures o@ == spec_psk_binder_entries(),
+pub fn client_hello_extension_extension_data<'a>(extension_type: u16, ext_len: u16) -> (o: ClientHelloExtensionExtensionDataCombinator)
+    requires
+        spec_extension_type().wf(extension_type@),
+
+    ensures o@ == spec_client_hello_extension_extension_data(extension_type@, ext_len@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = PskBinderEntriesCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate2895184764579107747 }, PskBinderEntriesCont0),
-        mapper: PskBinderEntriesMapper,
-    });
-    assert({
-        &&& combinator@ == spec_psk_binder_entries()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ClientHelloExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::ex_from(ext_len)) as usize), Mapped { inner: ClientHelloExtensionExtensionDataCombinator9(Choice::new(Cond { cond: extension_type == ExtensionType::ServerName, inner: server_name_list() }, ClientHelloExtensionExtensionDataCombinator8(Choice::new(Cond { cond: extension_type == ExtensionType::SignatureAlgorithms, inner: signature_scheme_list() }, ClientHelloExtensionExtensionDataCombinator7(Choice::new(Cond { cond: extension_type == ExtensionType::SupportedGroups, inner: named_group_list() }, ClientHelloExtensionExtensionDataCombinator6(Choice::new(Cond { cond: extension_type == ExtensionType::StatusRequest, inner: certificate_status_request() }, ClientHelloExtensionExtensionDataCombinator5(Choice::new(Cond { cond: extension_type == ExtensionType::ApplicationLayerProtocolNegotiation, inner: protocol_name_list() }, ClientHelloExtensionExtensionDataCombinator4(Choice::new(Cond { cond: extension_type == ExtensionType::SupportedVersions, inner: supported_versions_client() }, ClientHelloExtensionExtensionDataCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::KeyShare, inner: key_share_client_hello() }, ClientHelloExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::PskKeyExchangeModes, inner: psk_key_exchange_modes() }, ClientHelloExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::PreSharedKey, inner: pre_shared_key_client_extension() }, Cond { cond: !(extension_type == ExtensionType::ServerName || extension_type == ExtensionType::SignatureAlgorithms || extension_type == ExtensionType::SupportedGroups || extension_type == ExtensionType::StatusRequest || extension_type == ExtensionType::ApplicationLayerProtocolNegotiation || extension_type == ExtensionType::SupportedVersions || extension_type == ExtensionType::KeyShare || extension_type == ExtensionType::PskKeyExchangeModes || extension_type == ExtensionType::PreSharedKey), inner: client_hello_extension_rest(ext_len, extension_type) })))))))))))))))))), mapper: ClientHelloExtensionExtensionDataMapper }));
+    // assert({
+    //     &&& combinator@ == spec_client_hello_extension_extension_data(extension_type@, ext_len@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_psk_binder_entries<'a>(input: &'a [u8]) -> (res: PResult<<PskBinderEntriesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_client_hello_extension_extension_data<'a>(input: &'a [u8], extension_type: u16, ext_len: u16) -> (res: PResult<<ClientHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_psk_binder_entries().spec_parse(input@) == Some((n as int, v@)),
-        spec_psk_binder_entries().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_client_hello_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) == Some((n as int, v@)),
+        spec_client_hello_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_psk_binder_entries().spec_parse(input@) is None,
-        spec_psk_binder_entries().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_client_hello_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None,
+        spec_client_hello_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = psk_binder_entries();
+    let combinator = client_hello_extension_extension_data( extension_type, ext_len );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_psk_binder_entries<'a>(v: <PskBinderEntriesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_client_hello_extension_extension_data<'a>(v: <ClientHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, extension_type: u16, ext_len: u16) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_psk_binder_entries().wf(v@),
+        spec_client_hello_extension_extension_data(extension_type@, ext_len@).wf(v@),
+        spec_extension_type().wf(extension_type@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_psk_binder_entries().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_psk_binder_entries().spec_serialize(v@))
+            &&& n == spec_client_hello_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_client_hello_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@))
         },
 {
-    let combinator = psk_binder_entries();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = client_hello_extension_extension_data( extension_type, ext_len );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn psk_binder_entries_len<'a>(v: <PskBinderEntriesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn client_hello_extension_extension_data_len<'a>(v: <ClientHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, extension_type: u16, ext_len: u16) -> (serialize_len: usize)
     requires
-        spec_psk_binder_entries().wf(v@),
-        spec_psk_binder_entries().spec_serialize(v@).len() <= usize::MAX,
+        spec_client_hello_extension_extension_data(extension_type@, ext_len@).wf(v@),
+        spec_client_hello_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        serialize_len == spec_psk_binder_entries().spec_serialize(v@).len(),
+        serialize_len == spec_client_hello_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len(),
 {
-    let combinator = psk_binder_entries();
+    let combinator = client_hello_extension_extension_data( extension_type, ext_len );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct PskBinderEntriesCont0;
-type PskBinderEntriesCont0Type<'a, 'b> = &'b u16;
-type PskBinderEntriesCont0SType<'a, 'x> = &'x u16;
-type PskBinderEntriesCont0Input<'a, 'b, 'x> = POrSType<PskBinderEntriesCont0Type<'a, 'b>, PskBinderEntriesCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<PskBinderEntriesCont0Input<'a, 'b, 'x>> for PskBinderEntriesCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<PskBinderEntryCombinator>>;
-
-    open spec fn requires(&self, deps: PskBinderEntriesCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: PskBinderEntriesCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_psk_binder_entries_cont0(deps@)
-    }
-
-    fn apply(&self, deps: PskBinderEntriesCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(psk_binder_entry()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(psk_binder_entry()))
-            }
-        }
-    }
-}
-                
 
-pub struct SpecOfferedPsks {
-    pub identities: SpecPskIdentities,
-    pub binders: SpecPskBinderEntries,
+pub struct SpecClientHelloExtension {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: SpecClientHelloExtensionExtensionData,
 }
 
-pub type SpecOfferedPsksInner = (SpecPskIdentities, SpecPskBinderEntries);
+pub type SpecClientHelloExtensionInner = ((u16, u16), SpecClientHelloExtensionExtensionData);
 
 
-impl SpecFrom<SpecOfferedPsks> for SpecOfferedPsksInner {
-    open spec fn spec_from(m: SpecOfferedPsks) -> SpecOfferedPsksInner {
-        (m.identities, m.binders)
+impl SpecFrom<SpecClientHelloExtension> for SpecClientHelloExtensionInner {
+    open spec fn spec_from(m: SpecClientHelloExtension) -> SpecClientHelloExtensionInner {
+        ((m.extension_type, m.ext_len), m.extension_data)
     }
 }
 
-impl SpecFrom<SpecOfferedPsksInner> for SpecOfferedPsks {
-    open spec fn spec_from(m: SpecOfferedPsksInner) -> SpecOfferedPsks {
-        let (identities, binders) = m;
-        SpecOfferedPsks { identities, binders }
+impl SpecFrom<SpecClientHelloExtensionInner> for SpecClientHelloExtension {
+    open spec fn spec_from(m: SpecClientHelloExtensionInner) -> SpecClientHelloExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        SpecClientHelloExtension { extension_type, ext_len, extension_data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct OfferedPsks<'a> {
-    pub identities: PskIdentities<'a>,
-    pub binders: PskBinderEntries<'a>,
+pub struct ClientHelloExtension<'a> {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: ClientHelloExtensionExtensionData<'a>,
 }
 
-impl View for OfferedPsks<'_> {
-    type V = SpecOfferedPsks;
+impl View for ClientHelloExtension<'_> {
+    type V = SpecClientHelloExtension;
 
     open spec fn view(&self) -> Self::V {
-        SpecOfferedPsks {
-            identities: self.identities@,
-            binders: self.binders@,
+        SpecClientHelloExtension {
+            extension_type: self.extension_type@,
+            ext_len: self.ext_len@,
+            extension_data: self.extension_data@,
         }
     }
 }
-pub type OfferedPsksInner<'a> = (PskIdentities<'a>, PskBinderEntries<'a>);
-
-pub type OfferedPsksInnerRef<'a> = (&'a PskIdentities<'a>, &'a PskBinderEntries<'a>);
-impl<'a> From<&'a OfferedPsks<'a>> for OfferedPsksInnerRef<'a> {
-    fn ex_from(m: &'a OfferedPsks) -> OfferedPsksInnerRef<'a> {
-        (&m.identities, &m.binders)
-    }
-}
+pub type ClientHelloExtensionInner<'a> = ((u16, u16), ClientHelloExtensionExtensionData<'a>);
 
-impl<'a> From<OfferedPsksInner<'a>> for OfferedPsks<'a> {
-    fn ex_from(m: OfferedPsksInner) -> OfferedPsks {
-        let (identities, binders) = m;
-        OfferedPsks { identities, binders }
+pub type ClientHelloExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a ClientHelloExtensionExtensionData<'a>);
+impl<'a> From<&'a ClientHelloExtension<'a>> for ClientHelloExtensionInnerRef<'a> {
+    fn ex_from(m: &'a ClientHelloExtension) -> ClientHelloExtensionInnerRef<'a> {
+        ((&m.extension_type, &m.ext_len), &m.extension_data)
     }
 }
 
-pub struct OfferedPsksMapper;
-impl View for OfferedPsksMapper {
+impl<'a> From<ClientHelloExtensionInner<'a>> for ClientHelloExtension<'a> {
+    fn ex_from(m: ClientHelloExtensionInner) -> ClientHelloExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        ClientHelloExtension { extension_type, ext_len, extension_data }
+    }
+}
+
+pub struct ClientHelloExtensionMapper;
+impl View for ClientHelloExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for OfferedPsksMapper {
-    type Src = SpecOfferedPsksInner;
-    type Dst = SpecOfferedPsks;
+impl SpecIso for ClientHelloExtensionMapper {
+    type Src = SpecClientHelloExtensionInner;
+    type Dst = SpecClientHelloExtension;
 }
-impl SpecIsoProof for OfferedPsksMapper {
+impl SpecIsoProof for ClientHelloExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -15507,203 +14663,293 @@ impl SpecIsoProof for OfferedPsksMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for OfferedPsksMapper {
-    type Src = OfferedPsksInner<'a>;
-    type Dst = OfferedPsks<'a>;
-    type RefSrc = OfferedPsksInnerRef<'a>;
+impl<'a> Iso<'a> for ClientHelloExtensionMapper {
+    type Src = ClientHelloExtensionInner<'a>;
+    type Dst = ClientHelloExtension<'a>;
+    type RefSrc = ClientHelloExtensionInnerRef<'a>;
 }
-type SpecOfferedPsksCombinatorAlias1 = (SpecPskIdentitiesCombinator, SpecPskBinderEntriesCombinator);
-pub struct SpecOfferedPsksCombinator(pub SpecOfferedPsksCombinatorAlias);
 
-impl SpecCombinator for SpecOfferedPsksCombinator {
-    type Type = SpecOfferedPsks;
+pub struct SpecClientHelloExtensionCombinator(pub SpecClientHelloExtensionCombinatorAlias);
+
+impl SpecCombinator for SpecClientHelloExtensionCombinator {
+    type Type = SpecClientHelloExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOfferedPsksCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOfferedPsksCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecClientHelloExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecClientHelloExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOfferedPsksCombinatorAlias = Mapped<SpecOfferedPsksCombinatorAlias1, OfferedPsksMapper>;
-type OfferedPsksCombinatorAlias1 = (PskIdentitiesCombinator, PskBinderEntriesCombinator);
-pub struct OfferedPsksCombinator1(pub OfferedPsksCombinatorAlias1);
-impl View for OfferedPsksCombinator1 {
-    type V = SpecOfferedPsksCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(OfferedPsksCombinator1, OfferedPsksCombinatorAlias1);
+pub type SpecClientHelloExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecClientHelloExtensionExtensionDataCombinator>, ClientHelloExtensionMapper>;
 
-pub struct OfferedPsksCombinator(pub OfferedPsksCombinatorAlias);
+pub struct ClientHelloExtensionCombinator(pub ClientHelloExtensionCombinatorAlias);
 
-impl View for OfferedPsksCombinator {
-    type V = SpecOfferedPsksCombinator;
-    open spec fn view(&self) -> Self::V { SpecOfferedPsksCombinator(self.0@) }
+impl View for ClientHelloExtensionCombinator {
+    type V = SpecClientHelloExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecClientHelloExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OfferedPsksCombinator {
-    type Type = OfferedPsks<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientHelloExtensionCombinator {
+    type Type = ClientHelloExtension<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type OfferedPsksCombinatorAlias = Mapped<OfferedPsksCombinator1, OfferedPsksMapper>;
+}
+pub type ClientHelloExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, ClientHelloExtensionCont1>, ClientHelloExtensionExtensionDataCombinator, ClientHelloExtensionCont0>, ClientHelloExtensionMapper>;
 
 
-pub open spec fn spec_offered_psks() -> SpecOfferedPsksCombinator {
-    SpecOfferedPsksCombinator(
+pub open spec fn spec_client_hello_extension() -> SpecClientHelloExtensionCombinator {
+    SpecClientHelloExtensionCombinator(
     Mapped {
-        inner: (spec_psk_identities(), spec_psk_binder_entries()),
-        mapper: OfferedPsksMapper,
+        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_client_hello_extension_cont1(deps)), |deps| spec_client_hello_extension_cont0(deps)),
+        mapper: ClientHelloExtensionMapper,
     })
 }
 
+pub open spec fn spec_client_hello_extension_cont1(deps: u16) -> U16Be {
+    let extension_type = deps;
+    U16Be
+}
+
+impl View for ClientHelloExtensionCont1 {
+    type V = spec_fn(u16) -> U16Be;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_client_hello_extension_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_client_hello_extension_cont0(deps: (u16, u16)) -> SpecClientHelloExtensionExtensionDataCombinator {
+    let (extension_type, ext_len) = deps;
+    spec_client_hello_extension_extension_data(extension_type, ext_len)
+}
+
+impl View for ClientHelloExtensionCont0 {
+    type V = spec_fn((u16, u16)) -> SpecClientHelloExtensionExtensionDataCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u16, u16)| {
+            spec_client_hello_extension_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn offered_psks<'a>() -> (o: OfferedPsksCombinator)
-    ensures o@ == spec_offered_psks(),
+pub fn client_hello_extension<'a>() -> (o: ClientHelloExtensionCombinator)
+    ensures o@ == spec_client_hello_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = OfferedPsksCombinator(
+    let combinator = ClientHelloExtensionCombinator(
     Mapped {
-        inner: OfferedPsksCombinator1((psk_identities(), psk_binder_entries())),
-        mapper: OfferedPsksMapper,
-    });
-    assert({
-        &&& combinator@ == spec_offered_psks()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Pair::new(extension_type(), ClientHelloExtensionCont1), ClientHelloExtensionCont0),
+        mapper: ClientHelloExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_client_hello_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_offered_psks<'a>(input: &'a [u8]) -> (res: PResult<<OfferedPsksCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_client_hello_extension<'a>(input: &'a [u8]) -> (res: PResult<<ClientHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_offered_psks().spec_parse(input@) == Some((n as int, v@)),
-        spec_offered_psks().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_client_hello_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_client_hello_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_offered_psks().spec_parse(input@) is None,
-        spec_offered_psks().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_client_hello_extension().spec_parse(input@) is None,
+        spec_client_hello_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = offered_psks();
+    let combinator = client_hello_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_offered_psks<'a>(v: <OfferedPsksCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_client_hello_extension<'a>(v: <ClientHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_offered_psks().wf(v@),
+        spec_client_hello_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_offered_psks().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_offered_psks().spec_serialize(v@))
+            &&& n == spec_client_hello_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_client_hello_extension().spec_serialize(v@))
         },
 {
-    let combinator = offered_psks();
+    let combinator = client_hello_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn offered_psks_len<'a>(v: <OfferedPsksCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn client_hello_extension_len<'a>(v: <ClientHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_offered_psks().wf(v@),
-        spec_offered_psks().spec_serialize(v@).len() <= usize::MAX,
+        spec_client_hello_extension().wf(v@),
+        spec_client_hello_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_offered_psks().spec_serialize(v@).len(),
+        serialize_len == spec_client_hello_extension().spec_serialize(v@).len(),
 {
-    let combinator = offered_psks();
+    let combinator = client_hello_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct ClientHelloExtensionCont1;
+type ClientHelloExtensionCont1Type<'a, 'b> = &'b u16;
+type ClientHelloExtensionCont1SType<'a, 'x> = &'x u16;
+type ClientHelloExtensionCont1Input<'a, 'b, 'x> = POrSType<ClientHelloExtensionCont1Type<'a, 'b>, ClientHelloExtensionCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ClientHelloExtensionCont1Input<'a, 'b, 'x>> for ClientHelloExtensionCont1 {
+    type Output = U16Be;
+
+    open spec fn requires(&self, deps: ClientHelloExtensionCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_extension_type()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: ClientHelloExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_client_hello_extension_cont1(deps@)
+    }
+
+    fn apply(&self, deps: ClientHelloExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
+            }
+            POrSType::S(deps) => {
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
+            }
+        }
+    }
+}
+pub struct ClientHelloExtensionCont0;
+type ClientHelloExtensionCont0Type<'a, 'b> = &'b (u16, u16);
+type ClientHelloExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
+type ClientHelloExtensionCont0Input<'a, 'b, 'x> = POrSType<ClientHelloExtensionCont0Type<'a, 'b>, ClientHelloExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ClientHelloExtensionCont0Input<'a, 'b, 'x>> for ClientHelloExtensionCont0 {
+    type Output = ClientHelloExtensionExtensionDataCombinator;
+
+    open spec fn requires(&self, deps: ClientHelloExtensionCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_extension_type(), |deps| spec_client_hello_extension_cont1(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: ClientHelloExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_client_hello_extension_cont0(deps@)
+    }
+
+    fn apply(&self, deps: ClientHelloExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                client_hello_extension_extension_data(extension_type, ext_len)
+            }
+            POrSType::S(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                client_hello_extension_extension_data(extension_type, ext_len)
+            }
+        }
+    }
+}
                 
 
-pub struct SpecPreSharedKeyClientExtension {
-    pub offers: SpecOfferedPsks,
+pub struct SpecClientExtensions {
+    pub l: u16,
+    pub list: Seq<SpecClientHelloExtension>,
 }
 
-pub type SpecPreSharedKeyClientExtensionInner = SpecOfferedPsks;
+pub type SpecClientExtensionsInner = (u16, Seq<SpecClientHelloExtension>);
 
 
-impl SpecFrom<SpecPreSharedKeyClientExtension> for SpecPreSharedKeyClientExtensionInner {
-    open spec fn spec_from(m: SpecPreSharedKeyClientExtension) -> SpecPreSharedKeyClientExtensionInner {
-        m.offers
+impl SpecFrom<SpecClientExtensions> for SpecClientExtensionsInner {
+    open spec fn spec_from(m: SpecClientExtensions) -> SpecClientExtensionsInner {
+        (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecPreSharedKeyClientExtensionInner> for SpecPreSharedKeyClientExtension {
-    open spec fn spec_from(m: SpecPreSharedKeyClientExtensionInner) -> SpecPreSharedKeyClientExtension {
-        let offers = m;
-        SpecPreSharedKeyClientExtension { offers }
+impl SpecFrom<SpecClientExtensionsInner> for SpecClientExtensions {
+    open spec fn spec_from(m: SpecClientExtensionsInner) -> SpecClientExtensions {
+        let (l, list) = m;
+        SpecClientExtensions { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct PreSharedKeyClientExtension<'a> {
-    pub offers: OfferedPsks<'a>,
+pub struct ClientExtensions<'a> {
+    pub l: u16,
+    pub list: RepeatResult<ClientHelloExtension<'a>>,
 }
 
-impl View for PreSharedKeyClientExtension<'_> {
-    type V = SpecPreSharedKeyClientExtension;
+impl View for ClientExtensions<'_> {
+    type V = SpecClientExtensions;
 
     open spec fn view(&self) -> Self::V {
-        SpecPreSharedKeyClientExtension {
-            offers: self.offers@,
+        SpecClientExtensions {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
-pub type PreSharedKeyClientExtensionInner<'a> = OfferedPsks<'a>;
+pub type ClientExtensionsInner<'a> = (u16, RepeatResult<ClientHelloExtension<'a>>);
 
-pub type PreSharedKeyClientExtensionInnerRef<'a> = &'a OfferedPsks<'a>;
-impl<'a> From<&'a PreSharedKeyClientExtension<'a>> for PreSharedKeyClientExtensionInnerRef<'a> {
-    fn ex_from(m: &'a PreSharedKeyClientExtension) -> PreSharedKeyClientExtensionInnerRef<'a> {
-        &m.offers
+pub type ClientExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<ClientHelloExtension<'a>>);
+impl<'a> From<&'a ClientExtensions<'a>> for ClientExtensionsInnerRef<'a> {
+    fn ex_from(m: &'a ClientExtensions) -> ClientExtensionsInnerRef<'a> {
+        (&m.l, &m.list)
     }
 }
 
-impl<'a> From<PreSharedKeyClientExtensionInner<'a>> for PreSharedKeyClientExtension<'a> {
-    fn ex_from(m: PreSharedKeyClientExtensionInner) -> PreSharedKeyClientExtension {
-        let offers = m;
-        PreSharedKeyClientExtension { offers }
+impl<'a> From<ClientExtensionsInner<'a>> for ClientExtensions<'a> {
+    fn ex_from(m: ClientExtensionsInner) -> ClientExtensions {
+        let (l, list) = m;
+        ClientExtensions { l, list }
     }
 }
 
-pub struct PreSharedKeyClientExtensionMapper;
-impl View for PreSharedKeyClientExtensionMapper {
+pub struct ClientExtensionsMapper;
+impl View for ClientExtensionsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for PreSharedKeyClientExtensionMapper {
-    type Src = SpecPreSharedKeyClientExtensionInner;
-    type Dst = SpecPreSharedKeyClientExtension;
+impl SpecIso for ClientExtensionsMapper {
+    type Src = SpecClientExtensionsInner;
+    type Dst = SpecClientExtensions;
 }
-impl SpecIsoProof for PreSharedKeyClientExtensionMapper {
+impl SpecIsoProof for ClientExtensionsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -15711,199 +14957,277 @@ impl SpecIsoProof for PreSharedKeyClientExtensionMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for PreSharedKeyClientExtensionMapper {
-    type Src = PreSharedKeyClientExtensionInner<'a>;
-    type Dst = PreSharedKeyClientExtension<'a>;
-    type RefSrc = PreSharedKeyClientExtensionInnerRef<'a>;
+impl<'a> Iso<'a> for ClientExtensionsMapper {
+    type Src = ClientExtensionsInner<'a>;
+    type Dst = ClientExtensions<'a>;
+    type RefSrc = ClientExtensionsInnerRef<'a>;
 }
 
-pub struct SpecPreSharedKeyClientExtensionCombinator(pub SpecPreSharedKeyClientExtensionCombinatorAlias);
+pub struct SpecClientExtensionsCombinator(pub SpecClientExtensionsCombinatorAlias);
 
-impl SpecCombinator for SpecPreSharedKeyClientExtensionCombinator {
-    type Type = SpecPreSharedKeyClientExtension;
+impl SpecCombinator for SpecClientExtensionsCombinator {
+    type Type = SpecClientExtensions;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecPreSharedKeyClientExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecPreSharedKeyClientExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecClientExtensionsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecClientExtensionsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecPreSharedKeyClientExtensionCombinatorAlias = Mapped<SpecOfferedPsksCombinator, PreSharedKeyClientExtensionMapper>;
+pub type SpecClientExtensionsCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate9952414989822543135>, AndThen<bytes::Variable, Repeat<SpecClientHelloExtensionCombinator>>>, ClientExtensionsMapper>;
+pub struct Predicate9952414989822543135;
+impl View for Predicate9952414989822543135 {
+    type V = Self;
 
-pub struct PreSharedKeyClientExtensionCombinator(pub PreSharedKeyClientExtensionCombinatorAlias);
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate9952414989822543135 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 8 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate9952414989822543135 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 8 && i <= 65535)
+    }
+}
 
-impl View for PreSharedKeyClientExtensionCombinator {
-    type V = SpecPreSharedKeyClientExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecPreSharedKeyClientExtensionCombinator(self.0@) }
+pub struct ClientExtensionsCombinator(pub ClientExtensionsCombinatorAlias);
+
+impl View for ClientExtensionsCombinator {
+    type V = SpecClientExtensionsCombinator;
+    open spec fn view(&self) -> Self::V { SpecClientExtensionsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PreSharedKeyClientExtensionCombinator {
-    type Type = PreSharedKeyClientExtension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientExtensionsCombinator {
+    type Type = ClientExtensions<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type PreSharedKeyClientExtensionCombinatorAlias = Mapped<OfferedPsksCombinator, PreSharedKeyClientExtensionMapper>;
+}
+pub type ClientExtensionsCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate9952414989822543135>, AndThen<bytes::Variable, Repeat<ClientHelloExtensionCombinator>>, ClientExtensionsCont0>, ClientExtensionsMapper>;
 
 
-pub open spec fn spec_pre_shared_key_client_extension() -> SpecPreSharedKeyClientExtensionCombinator {
-    SpecPreSharedKeyClientExtensionCombinator(
+pub open spec fn spec_client_extensions() -> SpecClientExtensionsCombinator {
+    SpecClientExtensionsCombinator(
     Mapped {
-        inner: spec_offered_psks(),
-        mapper: PreSharedKeyClientExtensionMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate9952414989822543135 }, |deps| spec_client_extensions_cont0(deps)),
+        mapper: ClientExtensionsMapper,
     })
 }
 
+pub open spec fn spec_client_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecClientHelloExtensionCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_client_hello_extension()))
+}
+
+impl View for ClientExtensionsCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecClientHelloExtensionCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_client_extensions_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn pre_shared_key_client_extension<'a>() -> (o: PreSharedKeyClientExtensionCombinator)
-    ensures o@ == spec_pre_shared_key_client_extension(),
+pub fn client_extensions<'a>() -> (o: ClientExtensionsCombinator)
+    ensures o@ == spec_client_extensions(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = PreSharedKeyClientExtensionCombinator(
+    let combinator = ClientExtensionsCombinator(
     Mapped {
-        inner: offered_psks(),
-        mapper: PreSharedKeyClientExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_pre_shared_key_client_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate9952414989822543135 }, ClientExtensionsCont0),
+        mapper: ClientExtensionsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_client_extensions()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_pre_shared_key_client_extension<'a>(input: &'a [u8]) -> (res: PResult<<PreSharedKeyClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_client_extensions<'a>(input: &'a [u8]) -> (res: PResult<<ClientExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_pre_shared_key_client_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_pre_shared_key_client_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_client_extensions().spec_parse(input@) == Some((n as int, v@)),
+        spec_client_extensions().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_pre_shared_key_client_extension().spec_parse(input@) is None,
-        spec_pre_shared_key_client_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_client_extensions().spec_parse(input@) is None,
+        spec_client_extensions().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = pre_shared_key_client_extension();
+    let combinator = client_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_pre_shared_key_client_extension<'a>(v: <PreSharedKeyClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_client_extensions<'a>(v: <ClientExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_pre_shared_key_client_extension().wf(v@),
+        spec_client_extensions().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_pre_shared_key_client_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_pre_shared_key_client_extension().spec_serialize(v@))
+            &&& n == spec_client_extensions().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_client_extensions().spec_serialize(v@))
         },
 {
-    let combinator = pre_shared_key_client_extension();
+    let combinator = client_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn pre_shared_key_client_extension_len<'a>(v: <PreSharedKeyClientExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn client_extensions_len<'a>(v: <ClientExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_pre_shared_key_client_extension().wf(v@),
-        spec_pre_shared_key_client_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_client_extensions().wf(v@),
+        spec_client_extensions().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_pre_shared_key_client_extension().spec_serialize(v@).len(),
+        serialize_len == spec_client_extensions().spec_serialize(v@).len(),
 {
-    let combinator = pre_shared_key_client_extension();
+    let combinator = client_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct ClientExtensionsCont0;
+type ClientExtensionsCont0Type<'a, 'b> = &'b u16;
+type ClientExtensionsCont0SType<'a, 'x> = &'x u16;
+type ClientExtensionsCont0Input<'a, 'b, 'x> = POrSType<ClientExtensionsCont0Type<'a, 'b>, ClientExtensionsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ClientExtensionsCont0Input<'a, 'b, 'x>> for ClientExtensionsCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<ClientHelloExtensionCombinator>>;
+
+    open spec fn requires(&self, deps: ClientExtensionsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate9952414989822543135 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: ClientExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_client_extensions_cont0(deps@)
+    }
+
+    fn apply(&self, deps: ClientExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(client_hello_extension()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(client_hello_extension()))
+            }
+        }
+    }
+}
                 
 
-pub struct SpecCertificateAuthoritiesExtension {
-    pub l: u16,
-    pub list: Seq<SpecDistinguishedName>,
+pub struct SpecClientHello {
+    pub legacy_version: u16,
+    pub random: Seq<u8>,
+    pub legacy_session_id: SpecSessionId,
+    pub cipher_suites: SpecCipherSuiteList,
+    pub legacy_compression_methods: SpecOpaque1Ff,
+    pub extensions: SpecClientExtensions,
 }
 
-pub type SpecCertificateAuthoritiesExtensionInner = (u16, Seq<SpecDistinguishedName>);
+pub type SpecClientHelloInner = (u16, (Seq<u8>, (SpecSessionId, (SpecCipherSuiteList, (SpecOpaque1Ff, SpecClientExtensions)))));
 
 
-impl SpecFrom<SpecCertificateAuthoritiesExtension> for SpecCertificateAuthoritiesExtensionInner {
-    open spec fn spec_from(m: SpecCertificateAuthoritiesExtension) -> SpecCertificateAuthoritiesExtensionInner {
-        (m.l, m.list)
+impl SpecFrom<SpecClientHello> for SpecClientHelloInner {
+    open spec fn spec_from(m: SpecClientHello) -> SpecClientHelloInner {
+        (m.legacy_version, (m.random, (m.legacy_session_id, (m.cipher_suites, (m.legacy_compression_methods, m.extensions)))))
     }
 }
 
-impl SpecFrom<SpecCertificateAuthoritiesExtensionInner> for SpecCertificateAuthoritiesExtension {
-    open spec fn spec_from(m: SpecCertificateAuthoritiesExtensionInner) -> SpecCertificateAuthoritiesExtension {
-        let (l, list) = m;
-        SpecCertificateAuthoritiesExtension { l, list }
+impl SpecFrom<SpecClientHelloInner> for SpecClientHello {
+    open spec fn spec_from(m: SpecClientHelloInner) -> SpecClientHello {
+        let (legacy_version, (random, (legacy_session_id, (cipher_suites, (legacy_compression_methods, extensions))))) = m;
+        SpecClientHello { legacy_version, random, legacy_session_id, cipher_suites, legacy_compression_methods, extensions }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CertificateAuthoritiesExtension<'a> {
-    pub l: u16,
-    pub list: RepeatResult<DistinguishedName<'a>>,
+pub struct ClientHello<'a> {
+    pub legacy_version: u16,
+    pub random: &'a [u8],
+    pub legacy_session_id: SessionId<'a>,
+    pub cipher_suites: CipherSuiteList,
+    pub legacy_compression_methods: Opaque1Ff<'a>,
+    pub extensions: ClientExtensions<'a>,
 }
 
-impl View for CertificateAuthoritiesExtension<'_> {
-    type V = SpecCertificateAuthoritiesExtension;
+impl View for ClientHello<'_> {
+    type V = SpecClientHello;
 
     open spec fn view(&self) -> Self::V {
-        SpecCertificateAuthoritiesExtension {
-            l: self.l@,
-            list: self.list@,
+        SpecClientHello {
+            legacy_version: self.legacy_version@,
+            random: self.random@,
+            legacy_session_id: self.legacy_session_id@,
+            cipher_suites: self.cipher_suites@,
+            legacy_compression_methods: self.legacy_compression_methods@,
+            extensions: self.extensions@,
         }
     }
 }
-pub type CertificateAuthoritiesExtensionInner<'a> = (u16, RepeatResult<DistinguishedName<'a>>);
+pub type ClientHelloInner<'a> = (u16, (&'a [u8], (SessionId<'a>, (CipherSuiteList, (Opaque1Ff<'a>, ClientExtensions<'a>)))));
 
-pub type CertificateAuthoritiesExtensionInnerRef<'a> = (&'a u16, &'a RepeatResult<DistinguishedName<'a>>);
-impl<'a> From<&'a CertificateAuthoritiesExtension<'a>> for CertificateAuthoritiesExtensionInnerRef<'a> {
-    fn ex_from(m: &'a CertificateAuthoritiesExtension) -> CertificateAuthoritiesExtensionInnerRef<'a> {
-        (&m.l, &m.list)
+pub type ClientHelloInnerRef<'a> = (&'a u16, (&'a &'a [u8], (&'a SessionId<'a>, (&'a CipherSuiteList, (&'a Opaque1Ff<'a>, &'a ClientExtensions<'a>)))));
+impl<'a> From<&'a ClientHello<'a>> for ClientHelloInnerRef<'a> {
+    fn ex_from(m: &'a ClientHello) -> ClientHelloInnerRef<'a> {
+        (&m.legacy_version, (&m.random, (&m.legacy_session_id, (&m.cipher_suites, (&m.legacy_compression_methods, &m.extensions)))))
     }
 }
 
-impl<'a> From<CertificateAuthoritiesExtensionInner<'a>> for CertificateAuthoritiesExtension<'a> {
-    fn ex_from(m: CertificateAuthoritiesExtensionInner) -> CertificateAuthoritiesExtension {
-        let (l, list) = m;
-        CertificateAuthoritiesExtension { l, list }
+impl<'a> From<ClientHelloInner<'a>> for ClientHello<'a> {
+    fn ex_from(m: ClientHelloInner) -> ClientHello {
+        let (legacy_version, (random, (legacy_session_id, (cipher_suites, (legacy_compression_methods, extensions))))) = m;
+        ClientHello { legacy_version, random, legacy_session_id, cipher_suites, legacy_compression_methods, extensions }
     }
 }
 
-pub struct CertificateAuthoritiesExtensionMapper;
-impl View for CertificateAuthoritiesExtensionMapper {
+pub struct ClientHelloMapper;
+impl View for ClientHelloMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateAuthoritiesExtensionMapper {
-    type Src = SpecCertificateAuthoritiesExtensionInner;
-    type Dst = SpecCertificateAuthoritiesExtension;
+impl SpecIso for ClientHelloMapper {
+    type Src = SpecClientHelloInner;
+    type Dst = SpecClientHello;
 }
-impl SpecIsoProof for CertificateAuthoritiesExtensionMapper {
+impl SpecIsoProof for ClientHelloMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -15911,261 +15235,243 @@ impl SpecIsoProof for CertificateAuthoritiesExtensionMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateAuthoritiesExtensionMapper {
-    type Src = CertificateAuthoritiesExtensionInner<'a>;
-    type Dst = CertificateAuthoritiesExtension<'a>;
-    type RefSrc = CertificateAuthoritiesExtensionInnerRef<'a>;
+impl<'a> Iso<'a> for ClientHelloMapper {
+    type Src = ClientHelloInner<'a>;
+    type Dst = ClientHello<'a>;
+    type RefSrc = ClientHelloInnerRef<'a>;
 }
+pub const CLIENTHELLOLEGACY_VERSION_CONST: u16 = 771;
+type SpecClientHelloCombinatorAlias1 = (SpecOpaque1FfCombinator, SpecClientExtensionsCombinator);
+type SpecClientHelloCombinatorAlias2 = (SpecCipherSuiteListCombinator, SpecClientHelloCombinatorAlias1);
+type SpecClientHelloCombinatorAlias3 = (SpecSessionIdCombinator, SpecClientHelloCombinatorAlias2);
+type SpecClientHelloCombinatorAlias4 = (bytes::Fixed<32>, SpecClientHelloCombinatorAlias3);
+type SpecClientHelloCombinatorAlias5 = (Refined<U16Be, TagPred<u16>>, SpecClientHelloCombinatorAlias4);
+pub struct SpecClientHelloCombinator(pub SpecClientHelloCombinatorAlias);
 
-pub struct SpecCertificateAuthoritiesExtensionCombinator(pub SpecCertificateAuthoritiesExtensionCombinatorAlias);
-
-impl SpecCombinator for SpecCertificateAuthoritiesExtensionCombinator {
-    type Type = SpecCertificateAuthoritiesExtension;
+impl SpecCombinator for SpecClientHelloCombinator {
+    type Type = SpecClientHello;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateAuthoritiesExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateAuthoritiesExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecClientHelloCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecClientHelloCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateAuthoritiesExtensionCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate7402808336413996182>, AndThen<bytes::Variable, Repeat<SpecDistinguishedNameCombinator>>>, CertificateAuthoritiesExtensionMapper>;
-pub struct Predicate7402808336413996182;
-impl View for Predicate7402808336413996182 {
-    type V = Self;
+pub type SpecClientHelloCombinatorAlias = Mapped<SpecClientHelloCombinatorAlias5, ClientHelloMapper>;
+type ClientHelloCombinatorAlias1 = (Opaque1FfCombinator, ClientExtensionsCombinator);
+type ClientHelloCombinatorAlias2 = (CipherSuiteListCombinator, ClientHelloCombinator1);
+type ClientHelloCombinatorAlias3 = (SessionIdCombinator, ClientHelloCombinator2);
+type ClientHelloCombinatorAlias4 = (bytes::Fixed<32>, ClientHelloCombinator3);
+type ClientHelloCombinatorAlias5 = (Refined<U16Be, TagPred<u16>>, ClientHelloCombinator4);
+pub struct ClientHelloCombinator1(pub ClientHelloCombinatorAlias1);
+impl View for ClientHelloCombinator1 {
+    type V = SpecClientHelloCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloCombinator1, ClientHelloCombinatorAlias1);
 
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
+pub struct ClientHelloCombinator2(pub ClientHelloCombinatorAlias2);
+impl View for ClientHelloCombinator2 {
+    type V = SpecClientHelloCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl Pred<u16> for Predicate7402808336413996182 {
-    fn apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 3 && i <= 65535)
-    }
+impl_wrapper_combinator!(ClientHelloCombinator2, ClientHelloCombinatorAlias2);
+
+pub struct ClientHelloCombinator3(pub ClientHelloCombinatorAlias3);
+impl View for ClientHelloCombinator3 {
+    type V = SpecClientHelloCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl SpecPred<u16> for Predicate7402808336413996182 {
-    open spec fn spec_apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 3 && i <= 65535)
-    }
+impl_wrapper_combinator!(ClientHelloCombinator3, ClientHelloCombinatorAlias3);
+
+pub struct ClientHelloCombinator4(pub ClientHelloCombinatorAlias4);
+impl View for ClientHelloCombinator4 {
+    type V = SpecClientHelloCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ClientHelloCombinator4, ClientHelloCombinatorAlias4);
 
-pub struct CertificateAuthoritiesExtensionCombinator(pub CertificateAuthoritiesExtensionCombinatorAlias);
+pub struct ClientHelloCombinator5(pub ClientHelloCombinatorAlias5);
+impl View for ClientHelloCombinator5 {
+    type V = SpecClientHelloCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ClientHelloCombinator5, ClientHelloCombinatorAlias5);
 
-impl View for CertificateAuthoritiesExtensionCombinator {
-    type V = SpecCertificateAuthoritiesExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateAuthoritiesExtensionCombinator(self.0@) }
+pub struct ClientHelloCombinator(pub ClientHelloCombinatorAlias);
+
+impl View for ClientHelloCombinator {
+    type V = SpecClientHelloCombinator;
+    open spec fn view(&self) -> Self::V { SpecClientHelloCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateAuthoritiesExtensionCombinator {
-    type Type = CertificateAuthoritiesExtension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientHelloCombinator {
+    type Type = ClientHello<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateAuthoritiesExtensionCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate7402808336413996182>, AndThen<bytes::Variable, Repeat<DistinguishedNameCombinator>>, CertificateAuthoritiesExtensionCont0>, CertificateAuthoritiesExtensionMapper>;
+}
+pub type ClientHelloCombinatorAlias = Mapped<ClientHelloCombinator5, ClientHelloMapper>;
 
 
-pub open spec fn spec_certificate_authorities_extension() -> SpecCertificateAuthoritiesExtensionCombinator {
-    SpecCertificateAuthoritiesExtensionCombinator(
+pub open spec fn spec_client_hello() -> SpecClientHelloCombinator {
+    SpecClientHelloCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate7402808336413996182 }, |deps| spec_certificate_authorities_extension_cont0(deps)),
-        mapper: CertificateAuthoritiesExtensionMapper,
+        inner: (Refined { inner: U16Be, predicate: TagPred(CLIENTHELLOLEGACY_VERSION_CONST) }, (bytes::Fixed::<32>, (spec_session_id(), (spec_cipher_suite_list(), (spec_opaque_1_ff(), spec_client_extensions()))))),
+        mapper: ClientHelloMapper,
     })
 }
 
-pub open spec fn spec_certificate_authorities_extension_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecDistinguishedNameCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_distinguished_name()))
-}
-
-impl View for CertificateAuthoritiesExtensionCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecDistinguishedNameCombinator>>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_certificate_authorities_extension_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn certificate_authorities_extension<'a>() -> (o: CertificateAuthoritiesExtensionCombinator)
-    ensures o@ == spec_certificate_authorities_extension(),
+pub fn client_hello<'a>() -> (o: ClientHelloCombinator)
+    ensures o@ == spec_client_hello(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateAuthoritiesExtensionCombinator(
+    let combinator = ClientHelloCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate7402808336413996182 }, CertificateAuthoritiesExtensionCont0),
-        mapper: CertificateAuthoritiesExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_authorities_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: ClientHelloCombinator5((Refined { inner: U16Be, predicate: TagPred(CLIENTHELLOLEGACY_VERSION_CONST) }, ClientHelloCombinator4((bytes::Fixed::<32>, ClientHelloCombinator3((session_id(), ClientHelloCombinator2((cipher_suite_list(), ClientHelloCombinator1((opaque_1_ff(), client_extensions())))))))))),
+        mapper: ClientHelloMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_client_hello()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_authorities_extension<'a>(input: &'a [u8]) -> (res: PResult<<CertificateAuthoritiesExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_client_hello<'a>(input: &'a [u8]) -> (res: PResult<<ClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_authorities_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_authorities_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_client_hello().spec_parse(input@) == Some((n as int, v@)),
+        spec_client_hello().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_authorities_extension().spec_parse(input@) is None,
-        spec_certificate_authorities_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_client_hello().spec_parse(input@) is None,
+        spec_client_hello().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_authorities_extension();
+    let combinator = client_hello();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_authorities_extension<'a>(v: <CertificateAuthoritiesExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_client_hello<'a>(v: <ClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_authorities_extension().wf(v@),
+        spec_client_hello().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_authorities_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_authorities_extension().spec_serialize(v@))
+            &&& n == spec_client_hello().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_client_hello().spec_serialize(v@))
         },
 {
-    let combinator = certificate_authorities_extension();
+    let combinator = client_hello();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_authorities_extension_len<'a>(v: <CertificateAuthoritiesExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn client_hello_len<'a>(v: <ClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_authorities_extension().wf(v@),
-        spec_certificate_authorities_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_client_hello().wf(v@),
+        spec_client_hello().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_authorities_extension().spec_serialize(v@).len(),
+        serialize_len == spec_client_hello().spec_serialize(v@).len(),
 {
-    let combinator = certificate_authorities_extension();
+    let combinator = client_hello();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct CertificateAuthoritiesExtensionCont0;
-type CertificateAuthoritiesExtensionCont0Type<'a, 'b> = &'b u16;
-type CertificateAuthoritiesExtensionCont0SType<'a, 'x> = &'x u16;
-type CertificateAuthoritiesExtensionCont0Input<'a, 'b, 'x> = POrSType<CertificateAuthoritiesExtensionCont0Type<'a, 'b>, CertificateAuthoritiesExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CertificateAuthoritiesExtensionCont0Input<'a, 'b, 'x>> for CertificateAuthoritiesExtensionCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<DistinguishedNameCombinator>>;
-
-    open spec fn requires(&self, deps: CertificateAuthoritiesExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: CertificateAuthoritiesExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_certificate_authorities_extension_cont0(deps@)
-    }
-
-    fn apply(&self, deps: CertificateAuthoritiesExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(distinguished_name()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(distinguished_name()))
-            }
-        }
-    }
-}
                 
 
-pub struct SpecOidFilter {
-    pub certificate_extension_oid: SpecOpaque1Ff,
-    pub certificate_extension_values: SpecOpaque0Ffff,
+pub struct SpecOpaque0Ff {
+    pub l: u8,
+    pub data: Seq<u8>,
 }
 
-pub type SpecOidFilterInner = (SpecOpaque1Ff, SpecOpaque0Ffff);
+pub type SpecOpaque0FfInner = (u8, Seq<u8>);
 
 
-impl SpecFrom<SpecOidFilter> for SpecOidFilterInner {
-    open spec fn spec_from(m: SpecOidFilter) -> SpecOidFilterInner {
-        (m.certificate_extension_oid, m.certificate_extension_values)
+impl SpecFrom<SpecOpaque0Ff> for SpecOpaque0FfInner {
+    open spec fn spec_from(m: SpecOpaque0Ff) -> SpecOpaque0FfInner {
+        (m.l, m.data)
     }
 }
 
-impl SpecFrom<SpecOidFilterInner> for SpecOidFilter {
-    open spec fn spec_from(m: SpecOidFilterInner) -> SpecOidFilter {
-        let (certificate_extension_oid, certificate_extension_values) = m;
-        SpecOidFilter { certificate_extension_oid, certificate_extension_values }
+impl SpecFrom<SpecOpaque0FfInner> for SpecOpaque0Ff {
+    open spec fn spec_from(m: SpecOpaque0FfInner) -> SpecOpaque0Ff {
+        let (l, data) = m;
+        SpecOpaque0Ff { l, data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct OidFilter<'a> {
-    pub certificate_extension_oid: Opaque1Ff<'a>,
-    pub certificate_extension_values: Opaque0Ffff<'a>,
+pub struct Opaque0Ff<'a> {
+    pub l: u8,
+    pub data: &'a [u8],
 }
 
-impl View for OidFilter<'_> {
-    type V = SpecOidFilter;
+impl View for Opaque0Ff<'_> {
+    type V = SpecOpaque0Ff;
 
     open spec fn view(&self) -> Self::V {
-        SpecOidFilter {
-            certificate_extension_oid: self.certificate_extension_oid@,
-            certificate_extension_values: self.certificate_extension_values@,
+        SpecOpaque0Ff {
+            l: self.l@,
+            data: self.data@,
         }
     }
 }
-pub type OidFilterInner<'a> = (Opaque1Ff<'a>, Opaque0Ffff<'a>);
+pub type Opaque0FfInner<'a> = (u8, &'a [u8]);
 
-pub type OidFilterInnerRef<'a> = (&'a Opaque1Ff<'a>, &'a Opaque0Ffff<'a>);
-impl<'a> From<&'a OidFilter<'a>> for OidFilterInnerRef<'a> {
-    fn ex_from(m: &'a OidFilter) -> OidFilterInnerRef<'a> {
-        (&m.certificate_extension_oid, &m.certificate_extension_values)
+pub type Opaque0FfInnerRef<'a> = (&'a u8, &'a &'a [u8]);
+impl<'a> From<&'a Opaque0Ff<'a>> for Opaque0FfInnerRef<'a> {
+    fn ex_from(m: &'a Opaque0Ff) -> Opaque0FfInnerRef<'a> {
+        (&m.l, &m.data)
     }
 }
 
-impl<'a> From<OidFilterInner<'a>> for OidFilter<'a> {
-    fn ex_from(m: OidFilterInner) -> OidFilter {
-        let (certificate_extension_oid, certificate_extension_values) = m;
-        OidFilter { certificate_extension_oid, certificate_extension_values }
+impl<'a> From<Opaque0FfInner<'a>> for Opaque0Ff<'a> {
+    fn ex_from(m: Opaque0FfInner) -> Opaque0Ff {
+        let (l, data) = m;
+        Opaque0Ff { l, data }
     }
 }
 
-pub struct OidFilterMapper;
-impl View for OidFilterMapper {
+pub struct Opaque0FfMapper;
+impl View for Opaque0FfMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for OidFilterMapper {
-    type Src = SpecOidFilterInner;
-    type Dst = SpecOidFilter;
+impl SpecIso for Opaque0FfMapper {
+    type Src = SpecOpaque0FfInner;
+    type Dst = SpecOpaque0Ff;
 }
-impl SpecIsoProof for OidFilterMapper {
+impl SpecIsoProof for Opaque0FfMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -16173,206 +15479,242 @@ impl SpecIsoProof for OidFilterMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for OidFilterMapper {
-    type Src = OidFilterInner<'a>;
-    type Dst = OidFilter<'a>;
-    type RefSrc = OidFilterInnerRef<'a>;
+impl<'a> Iso<'a> for Opaque0FfMapper {
+    type Src = Opaque0FfInner<'a>;
+    type Dst = Opaque0Ff<'a>;
+    type RefSrc = Opaque0FfInnerRef<'a>;
 }
-type SpecOidFilterCombinatorAlias1 = (SpecOpaque1FfCombinator, SpecOpaque0FfffCombinator);
-pub struct SpecOidFilterCombinator(pub SpecOidFilterCombinatorAlias);
 
-impl SpecCombinator for SpecOidFilterCombinator {
-    type Type = SpecOidFilter;
+pub struct SpecOpaque0FfCombinator(pub SpecOpaque0FfCombinatorAlias);
+
+impl SpecCombinator for SpecOpaque0FfCombinator {
+    type Type = SpecOpaque0Ff;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOidFilterCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOidFilterCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOpaque0FfCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOpaque0FfCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOidFilterCombinatorAlias = Mapped<SpecOidFilterCombinatorAlias1, OidFilterMapper>;
-type OidFilterCombinatorAlias1 = (Opaque1FfCombinator, Opaque0FfffCombinator);
-pub struct OidFilterCombinator1(pub OidFilterCombinatorAlias1);
-impl View for OidFilterCombinator1 {
-    type V = SpecOidFilterCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(OidFilterCombinator1, OidFilterCombinatorAlias1);
+pub type SpecOpaque0FfCombinatorAlias = Mapped<SpecPair<U8, bytes::Variable>, Opaque0FfMapper>;
 
-pub struct OidFilterCombinator(pub OidFilterCombinatorAlias);
+pub struct Opaque0FfCombinator(pub Opaque0FfCombinatorAlias);
 
-impl View for OidFilterCombinator {
-    type V = SpecOidFilterCombinator;
-    open spec fn view(&self) -> Self::V { SpecOidFilterCombinator(self.0@) }
+impl View for Opaque0FfCombinator {
+    type V = SpecOpaque0FfCombinator;
+    open spec fn view(&self) -> Self::V { SpecOpaque0FfCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OidFilterCombinator {
-    type Type = OidFilter<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque0FfCombinator {
+    type Type = Opaque0Ff<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type OidFilterCombinatorAlias = Mapped<OidFilterCombinator1, OidFilterMapper>;
+}
+pub type Opaque0FfCombinatorAlias = Mapped<Pair<U8, bytes::Variable, Opaque0FfCont0>, Opaque0FfMapper>;
 
 
-pub open spec fn spec_oid_filter() -> SpecOidFilterCombinator {
-    SpecOidFilterCombinator(
+pub open spec fn spec_opaque_0_ff() -> SpecOpaque0FfCombinator {
+    SpecOpaque0FfCombinator(
     Mapped {
-        inner: (spec_opaque_1_ff(), spec_opaque_0_ffff()),
-        mapper: OidFilterMapper,
+        inner: Pair::spec_new(U8, |deps| spec_opaque0_ff_cont0(deps)),
+        mapper: Opaque0FfMapper,
     })
 }
 
+pub open spec fn spec_opaque0_ff_cont0(deps: u8) -> bytes::Variable {
+    let l = deps;
+    bytes::Variable((usize::spec_from(l)) as usize)
+}
+
+impl View for Opaque0FfCont0 {
+    type V = spec_fn(u8) -> bytes::Variable;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u8| {
+            spec_opaque0_ff_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn oid_filter<'a>() -> (o: OidFilterCombinator)
-    ensures o@ == spec_oid_filter(),
+pub fn opaque_0_ff<'a>() -> (o: Opaque0FfCombinator)
+    ensures o@ == spec_opaque_0_ff(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = OidFilterCombinator(
+    let combinator = Opaque0FfCombinator(
     Mapped {
-        inner: OidFilterCombinator1((opaque_1_ff(), opaque_0_ffff())),
-        mapper: OidFilterMapper,
-    });
-    assert({
-        &&& combinator@ == spec_oid_filter()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(U8, Opaque0FfCont0),
+        mapper: Opaque0FfMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_opaque_0_ff()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_oid_filter<'a>(input: &'a [u8]) -> (res: PResult<<OidFilterCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_opaque_0_ff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque0FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_oid_filter().spec_parse(input@) == Some((n as int, v@)),
-        spec_oid_filter().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_opaque_0_ff().spec_parse(input@) == Some((n as int, v@)),
+        spec_opaque_0_ff().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_oid_filter().spec_parse(input@) is None,
-        spec_oid_filter().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_opaque_0_ff().spec_parse(input@) is None,
+        spec_opaque_0_ff().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = oid_filter();
+    let combinator = opaque_0_ff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_oid_filter<'a>(v: <OidFilterCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_opaque_0_ff<'a>(v: <Opaque0FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_oid_filter().wf(v@),
+        spec_opaque_0_ff().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_oid_filter().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_oid_filter().spec_serialize(v@))
+            &&& n == spec_opaque_0_ff().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_0_ff().spec_serialize(v@))
         },
 {
-    let combinator = oid_filter();
+    let combinator = opaque_0_ff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn oid_filter_len<'a>(v: <OidFilterCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn opaque_0_ff_len<'a>(v: <Opaque0FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_oid_filter().wf(v@),
-        spec_oid_filter().spec_serialize(v@).len() <= usize::MAX,
+        spec_opaque_0_ff().wf(v@),
+        spec_opaque_0_ff().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_oid_filter().spec_serialize(v@).len(),
+        serialize_len == spec_opaque_0_ff().spec_serialize(v@).len(),
 {
-    let combinator = oid_filter();
+    let combinator = opaque_0_ff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct Opaque0FfCont0;
+type Opaque0FfCont0Type<'a, 'b> = &'b u8;
+type Opaque0FfCont0SType<'a, 'x> = &'x u8;
+type Opaque0FfCont0Input<'a, 'b, 'x> = POrSType<Opaque0FfCont0Type<'a, 'b>, Opaque0FfCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Opaque0FfCont0Input<'a, 'b, 'x>> for Opaque0FfCont0 {
+    type Output = bytes::Variable;
+
+    open spec fn requires(&self, deps: Opaque0FfCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U8).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: Opaque0FfCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_opaque0_ff_cont0(deps@)
+    }
+
+    fn apply(&self, deps: Opaque0FfCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
+            }
+        }
+    }
+}
                 
 
-pub struct SpecOidFilterExtension {
-    pub l: u16,
-    pub list: Seq<SpecOidFilter>,
+pub struct SpecEarlyDataIndicationNewSessionTicket {
+    pub max_early_data_size: u32,
 }
 
-pub type SpecOidFilterExtensionInner = (u16, Seq<SpecOidFilter>);
+pub type SpecEarlyDataIndicationNewSessionTicketInner = u32;
 
 
-impl SpecFrom<SpecOidFilterExtension> for SpecOidFilterExtensionInner {
-    open spec fn spec_from(m: SpecOidFilterExtension) -> SpecOidFilterExtensionInner {
-        (m.l, m.list)
+impl SpecFrom<SpecEarlyDataIndicationNewSessionTicket> for SpecEarlyDataIndicationNewSessionTicketInner {
+    open spec fn spec_from(m: SpecEarlyDataIndicationNewSessionTicket) -> SpecEarlyDataIndicationNewSessionTicketInner {
+        m.max_early_data_size
     }
 }
 
-impl SpecFrom<SpecOidFilterExtensionInner> for SpecOidFilterExtension {
-    open spec fn spec_from(m: SpecOidFilterExtensionInner) -> SpecOidFilterExtension {
-        let (l, list) = m;
-        SpecOidFilterExtension { l, list }
+impl SpecFrom<SpecEarlyDataIndicationNewSessionTicketInner> for SpecEarlyDataIndicationNewSessionTicket {
+    open spec fn spec_from(m: SpecEarlyDataIndicationNewSessionTicketInner) -> SpecEarlyDataIndicationNewSessionTicket {
+        let max_early_data_size = m;
+        SpecEarlyDataIndicationNewSessionTicket { max_early_data_size }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct OidFilterExtension<'a> {
-    pub l: u16,
-    pub list: RepeatResult<OidFilter<'a>>,
+pub struct EarlyDataIndicationNewSessionTicket {
+    pub max_early_data_size: u32,
 }
 
-impl View for OidFilterExtension<'_> {
-    type V = SpecOidFilterExtension;
+impl View for EarlyDataIndicationNewSessionTicket {
+    type V = SpecEarlyDataIndicationNewSessionTicket;
 
     open spec fn view(&self) -> Self::V {
-        SpecOidFilterExtension {
-            l: self.l@,
-            list: self.list@,
+        SpecEarlyDataIndicationNewSessionTicket {
+            max_early_data_size: self.max_early_data_size@,
         }
     }
 }
-pub type OidFilterExtensionInner<'a> = (u16, RepeatResult<OidFilter<'a>>);
+pub type EarlyDataIndicationNewSessionTicketInner = u32;
 
-pub type OidFilterExtensionInnerRef<'a> = (&'a u16, &'a RepeatResult<OidFilter<'a>>);
-impl<'a> From<&'a OidFilterExtension<'a>> for OidFilterExtensionInnerRef<'a> {
-    fn ex_from(m: &'a OidFilterExtension) -> OidFilterExtensionInnerRef<'a> {
-        (&m.l, &m.list)
+pub type EarlyDataIndicationNewSessionTicketInnerRef<'a> = &'a u32;
+impl<'a> From<&'a EarlyDataIndicationNewSessionTicket> for EarlyDataIndicationNewSessionTicketInnerRef<'a> {
+    fn ex_from(m: &'a EarlyDataIndicationNewSessionTicket) -> EarlyDataIndicationNewSessionTicketInnerRef<'a> {
+        &m.max_early_data_size
     }
 }
 
-impl<'a> From<OidFilterExtensionInner<'a>> for OidFilterExtension<'a> {
-    fn ex_from(m: OidFilterExtensionInner) -> OidFilterExtension {
-        let (l, list) = m;
-        OidFilterExtension { l, list }
+impl From<EarlyDataIndicationNewSessionTicketInner> for EarlyDataIndicationNewSessionTicket {
+    fn ex_from(m: EarlyDataIndicationNewSessionTicketInner) -> EarlyDataIndicationNewSessionTicket {
+        let max_early_data_size = m;
+        EarlyDataIndicationNewSessionTicket { max_early_data_size }
     }
 }
 
-pub struct OidFilterExtensionMapper;
-impl View for OidFilterExtensionMapper {
+pub struct EarlyDataIndicationNewSessionTicketMapper;
+impl View for EarlyDataIndicationNewSessionTicketMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for OidFilterExtensionMapper {
-    type Src = SpecOidFilterExtensionInner;
-    type Dst = SpecOidFilterExtension;
+impl SpecIso for EarlyDataIndicationNewSessionTicketMapper {
+    type Src = SpecEarlyDataIndicationNewSessionTicketInner;
+    type Dst = SpecEarlyDataIndicationNewSessionTicket;
 }
-impl SpecIsoProof for OidFilterExtensionMapper {
+impl SpecIsoProof for EarlyDataIndicationNewSessionTicketMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -16380,226 +15722,157 @@ impl SpecIsoProof for OidFilterExtensionMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for OidFilterExtensionMapper {
-    type Src = OidFilterExtensionInner<'a>;
-    type Dst = OidFilterExtension<'a>;
-    type RefSrc = OidFilterExtensionInnerRef<'a>;
+impl<'a> Iso<'a> for EarlyDataIndicationNewSessionTicketMapper {
+    type Src = EarlyDataIndicationNewSessionTicketInner;
+    type Dst = EarlyDataIndicationNewSessionTicket;
+    type RefSrc = EarlyDataIndicationNewSessionTicketInnerRef<'a>;
 }
 
-pub struct SpecOidFilterExtensionCombinator(pub SpecOidFilterExtensionCombinatorAlias);
+pub struct SpecEarlyDataIndicationNewSessionTicketCombinator(pub SpecEarlyDataIndicationNewSessionTicketCombinatorAlias);
 
-impl SpecCombinator for SpecOidFilterExtensionCombinator {
-    type Type = SpecOidFilterExtension;
+impl SpecCombinator for SpecEarlyDataIndicationNewSessionTicketCombinator {
+    type Type = SpecEarlyDataIndicationNewSessionTicket;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOidFilterExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOidFilterExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecEarlyDataIndicationNewSessionTicketCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEarlyDataIndicationNewSessionTicketCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOidFilterExtensionCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecOidFilterCombinator>>>, OidFilterExtensionMapper>;
+pub type SpecEarlyDataIndicationNewSessionTicketCombinatorAlias = Mapped<U32Be, EarlyDataIndicationNewSessionTicketMapper>;
 
-pub struct OidFilterExtensionCombinator(pub OidFilterExtensionCombinatorAlias);
+pub struct EarlyDataIndicationNewSessionTicketCombinator(pub EarlyDataIndicationNewSessionTicketCombinatorAlias);
 
-impl View for OidFilterExtensionCombinator {
-    type V = SpecOidFilterExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecOidFilterExtensionCombinator(self.0@) }
+impl View for EarlyDataIndicationNewSessionTicketCombinator {
+    type V = SpecEarlyDataIndicationNewSessionTicketCombinator;
+    open spec fn view(&self) -> Self::V { SpecEarlyDataIndicationNewSessionTicketCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OidFilterExtensionCombinator {
-    type Type = OidFilterExtension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EarlyDataIndicationNewSessionTicketCombinator {
+    type Type = EarlyDataIndicationNewSessionTicket;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type OidFilterExtensionCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<OidFilterCombinator>>, OidFilterExtensionCont0>, OidFilterExtensionMapper>;
+}
+pub type EarlyDataIndicationNewSessionTicketCombinatorAlias = Mapped<U32Be, EarlyDataIndicationNewSessionTicketMapper>;
 
 
-pub open spec fn spec_oid_filter_extension() -> SpecOidFilterExtensionCombinator {
-    SpecOidFilterExtensionCombinator(
+pub open spec fn spec_early_data_indication_new_session_ticket() -> SpecEarlyDataIndicationNewSessionTicketCombinator {
+    SpecEarlyDataIndicationNewSessionTicketCombinator(
     Mapped {
-        inner: Pair::spec_new(U16Be, |deps| spec_oid_filter_extension_cont0(deps)),
-        mapper: OidFilterExtensionMapper,
+        inner: U32Be,
+        mapper: EarlyDataIndicationNewSessionTicketMapper,
     })
 }
 
-pub open spec fn spec_oid_filter_extension_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecOidFilterCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_oid_filter()))
-}
-
-impl View for OidFilterExtensionCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecOidFilterCombinator>>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_oid_filter_extension_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn oid_filter_extension<'a>() -> (o: OidFilterExtensionCombinator)
-    ensures o@ == spec_oid_filter_extension(),
+pub fn early_data_indication_new_session_ticket<'a>() -> (o: EarlyDataIndicationNewSessionTicketCombinator)
+    ensures o@ == spec_early_data_indication_new_session_ticket(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = OidFilterExtensionCombinator(
+    let combinator = EarlyDataIndicationNewSessionTicketCombinator(
     Mapped {
-        inner: Pair::new(U16Be, OidFilterExtensionCont0),
-        mapper: OidFilterExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_oid_filter_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: U32Be,
+        mapper: EarlyDataIndicationNewSessionTicketMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_early_data_indication_new_session_ticket()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_oid_filter_extension<'a>(input: &'a [u8]) -> (res: PResult<<OidFilterExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_early_data_indication_new_session_ticket<'a>(input: &'a [u8]) -> (res: PResult<<EarlyDataIndicationNewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_oid_filter_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_oid_filter_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_early_data_indication_new_session_ticket().spec_parse(input@) == Some((n as int, v@)),
+        spec_early_data_indication_new_session_ticket().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_oid_filter_extension().spec_parse(input@) is None,
-        spec_oid_filter_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_early_data_indication_new_session_ticket().spec_parse(input@) is None,
+        spec_early_data_indication_new_session_ticket().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = oid_filter_extension();
+    let combinator = early_data_indication_new_session_ticket();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_oid_filter_extension<'a>(v: <OidFilterExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_early_data_indication_new_session_ticket<'a>(v: <EarlyDataIndicationNewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_oid_filter_extension().wf(v@),
+        spec_early_data_indication_new_session_ticket().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_oid_filter_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_oid_filter_extension().spec_serialize(v@))
+            &&& n == spec_early_data_indication_new_session_ticket().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_early_data_indication_new_session_ticket().spec_serialize(v@))
         },
 {
-    let combinator = oid_filter_extension();
+    let combinator = early_data_indication_new_session_ticket();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn oid_filter_extension_len<'a>(v: <OidFilterExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn early_data_indication_new_session_ticket_len<'a>(v: <EarlyDataIndicationNewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_oid_filter_extension().wf(v@),
-        spec_oid_filter_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_early_data_indication_new_session_ticket().wf(v@),
+        spec_early_data_indication_new_session_ticket().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_oid_filter_extension().spec_serialize(v@).len(),
+        serialize_len == spec_early_data_indication_new_session_ticket().spec_serialize(v@).len(),
 {
-    let combinator = oid_filter_extension();
+    let combinator = early_data_indication_new_session_ticket();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct OidFilterExtensionCont0;
-type OidFilterExtensionCont0Type<'a, 'b> = &'b u16;
-type OidFilterExtensionCont0SType<'a, 'x> = &'x u16;
-type OidFilterExtensionCont0Input<'a, 'b, 'x> = POrSType<OidFilterExtensionCont0Type<'a, 'b>, OidFilterExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<OidFilterExtensionCont0Input<'a, 'b, 'x>> for OidFilterExtensionCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<OidFilterCombinator>>;
-
-    open spec fn requires(&self, deps: OidFilterExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: OidFilterExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_oid_filter_extension_cont0(deps@)
-    }
-
-    fn apply(&self, deps: OidFilterExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(oid_filter()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(oid_filter()))
-            }
-        }
-    }
-}
                 
 
-pub enum SpecClientHelloExtensionRest {
-    MaxFragmentLength(u8),
-    Heartbeat(u8),
-    SignedCertificateTimeStamp(SpecSignedCertificateTimestampList),
-    ClientCertificateType(SpecClientCertTypeClientExtension),
-    ServerCertificateType(SpecServerCertTypeClientExtension),
-    Padding(Seq<u8>),
-    Cookie(SpecCookie),
-    CertificateAuthorities(SpecCertificateAuthoritiesExtension),
-    OidFilters(SpecOidFilterExtension),
-    SignatureAlgorithmsCert(SpecSignatureSchemeList),
+pub enum SpecNewSessionTicketExtensionExtensionData {
+    EarlyData(SpecEarlyDataIndicationNewSessionTicket),
     Unrecognized(Seq<u8>),
 }
 
-pub type SpecClientHelloExtensionRestInner = Either<u8, Either<u8, Either<SpecSignedCertificateTimestampList, Either<SpecClientCertTypeClientExtension, Either<SpecServerCertTypeClientExtension, Either<Seq<u8>, Either<SpecCookie, Either<SpecCertificateAuthoritiesExtension, Either<SpecOidFilterExtension, Either<SpecSignatureSchemeList, Seq<u8>>>>>>>>>>>;
+pub type SpecNewSessionTicketExtensionExtensionDataInner = Either<SpecEarlyDataIndicationNewSessionTicket, Seq<u8>>;
 
-impl SpecFrom<SpecClientHelloExtensionRest> for SpecClientHelloExtensionRestInner {
-    open spec fn spec_from(m: SpecClientHelloExtensionRest) -> SpecClientHelloExtensionRestInner {
+impl SpecFrom<SpecNewSessionTicketExtensionExtensionData> for SpecNewSessionTicketExtensionExtensionDataInner {
+    open spec fn spec_from(m: SpecNewSessionTicketExtensionExtensionData) -> SpecNewSessionTicketExtensionExtensionDataInner {
         match m {
-            SpecClientHelloExtensionRest::MaxFragmentLength(m) => Either::Left(m),
-            SpecClientHelloExtensionRest::Heartbeat(m) => Either::Right(Either::Left(m)),
-            SpecClientHelloExtensionRest::SignedCertificateTimeStamp(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecClientHelloExtensionRest::ClientCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            SpecClientHelloExtensionRest::ServerCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            SpecClientHelloExtensionRest::Padding(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            SpecClientHelloExtensionRest::Cookie(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
-            SpecClientHelloExtensionRest::CertificateAuthorities(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
-            SpecClientHelloExtensionRest::OidFilters(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
-            SpecClientHelloExtensionRest::SignatureAlgorithmsCert(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))),
-            SpecClientHelloExtensionRest::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))),
+            SpecNewSessionTicketExtensionExtensionData::EarlyData(m) => Either::Left(m),
+            SpecNewSessionTicketExtensionExtensionData::Unrecognized(m) => Either::Right(m),
         }
     }
 
 }
 
                 
-impl SpecFrom<SpecClientHelloExtensionRestInner> for SpecClientHelloExtensionRest {
-    open spec fn spec_from(m: SpecClientHelloExtensionRestInner) -> SpecClientHelloExtensionRest {
+impl SpecFrom<SpecNewSessionTicketExtensionExtensionDataInner> for SpecNewSessionTicketExtensionExtensionData {
+    open spec fn spec_from(m: SpecNewSessionTicketExtensionExtensionDataInner) -> SpecNewSessionTicketExtensionExtensionData {
         match m {
-            Either::Left(m) => SpecClientHelloExtensionRest::MaxFragmentLength(m),
-            Either::Right(Either::Left(m)) => SpecClientHelloExtensionRest::Heartbeat(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecClientHelloExtensionRest::SignedCertificateTimeStamp(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecClientHelloExtensionRest::ClientCertificateType(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecClientHelloExtensionRest::ServerCertificateType(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecClientHelloExtensionRest::Padding(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => SpecClientHelloExtensionRest::Cookie(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => SpecClientHelloExtensionRest::CertificateAuthorities(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => SpecClientHelloExtensionRest::OidFilters(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))) => SpecClientHelloExtensionRest::SignatureAlgorithmsCert(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))) => SpecClientHelloExtensionRest::Unrecognized(m),
+            Either::Left(m) => SpecNewSessionTicketExtensionExtensionData::EarlyData(m),
+            Either::Right(m) => SpecNewSessionTicketExtensionExtensionData::Unrecognized(m),
         }
     }
 
@@ -16608,96 +15881,60 @@ impl SpecFrom<SpecClientHelloExtensionRestInner> for SpecClientHelloExtensionRes
 
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ClientHelloExtensionRest<'a> {
-    MaxFragmentLength(u8),
-    Heartbeat(u8),
-    SignedCertificateTimeStamp(SignedCertificateTimestampList<'a>),
-    ClientCertificateType(ClientCertTypeClientExtension),
-    ServerCertificateType(ServerCertTypeClientExtension),
-    Padding(&'a [u8]),
-    Cookie(Cookie<'a>),
-    CertificateAuthorities(CertificateAuthoritiesExtension<'a>),
-    OidFilters(OidFilterExtension<'a>),
-    SignatureAlgorithmsCert(SignatureSchemeList),
+pub enum NewSessionTicketExtensionExtensionData<'a> {
+    EarlyData(EarlyDataIndicationNewSessionTicket),
     Unrecognized(&'a [u8]),
 }
 
-pub type ClientHelloExtensionRestInner<'a> = Either<u8, Either<u8, Either<SignedCertificateTimestampList<'a>, Either<ClientCertTypeClientExtension, Either<ServerCertTypeClientExtension, Either<&'a [u8], Either<Cookie<'a>, Either<CertificateAuthoritiesExtension<'a>, Either<OidFilterExtension<'a>, Either<SignatureSchemeList, &'a [u8]>>>>>>>>>>;
+pub type NewSessionTicketExtensionExtensionDataInner<'a> = Either<EarlyDataIndicationNewSessionTicket, &'a [u8]>;
 
-pub type ClientHelloExtensionRestInnerRef<'a> = Either<&'a u8, Either<&'a u8, Either<&'a SignedCertificateTimestampList<'a>, Either<&'a ClientCertTypeClientExtension, Either<&'a ServerCertTypeClientExtension, Either<&'a &'a [u8], Either<&'a Cookie<'a>, Either<&'a CertificateAuthoritiesExtension<'a>, Either<&'a OidFilterExtension<'a>, Either<&'a SignatureSchemeList, &'a &'a [u8]>>>>>>>>>>;
+pub type NewSessionTicketExtensionExtensionDataInnerRef<'a> = Either<&'a EarlyDataIndicationNewSessionTicket, &'a &'a [u8]>;
 
 
-impl<'a> View for ClientHelloExtensionRest<'a> {
-    type V = SpecClientHelloExtensionRest;
+impl<'a> View for NewSessionTicketExtensionExtensionData<'a> {
+    type V = SpecNewSessionTicketExtensionExtensionData;
     open spec fn view(&self) -> Self::V {
         match self {
-            ClientHelloExtensionRest::MaxFragmentLength(m) => SpecClientHelloExtensionRest::MaxFragmentLength(m@),
-            ClientHelloExtensionRest::Heartbeat(m) => SpecClientHelloExtensionRest::Heartbeat(m@),
-            ClientHelloExtensionRest::SignedCertificateTimeStamp(m) => SpecClientHelloExtensionRest::SignedCertificateTimeStamp(m@),
-            ClientHelloExtensionRest::ClientCertificateType(m) => SpecClientHelloExtensionRest::ClientCertificateType(m@),
-            ClientHelloExtensionRest::ServerCertificateType(m) => SpecClientHelloExtensionRest::ServerCertificateType(m@),
-            ClientHelloExtensionRest::Padding(m) => SpecClientHelloExtensionRest::Padding(m@),
-            ClientHelloExtensionRest::Cookie(m) => SpecClientHelloExtensionRest::Cookie(m@),
-            ClientHelloExtensionRest::CertificateAuthorities(m) => SpecClientHelloExtensionRest::CertificateAuthorities(m@),
-            ClientHelloExtensionRest::OidFilters(m) => SpecClientHelloExtensionRest::OidFilters(m@),
-            ClientHelloExtensionRest::SignatureAlgorithmsCert(m) => SpecClientHelloExtensionRest::SignatureAlgorithmsCert(m@),
-            ClientHelloExtensionRest::Unrecognized(m) => SpecClientHelloExtensionRest::Unrecognized(m@),
+            NewSessionTicketExtensionExtensionData::EarlyData(m) => SpecNewSessionTicketExtensionExtensionData::EarlyData(m@),
+            NewSessionTicketExtensionExtensionData::Unrecognized(m) => SpecNewSessionTicketExtensionExtensionData::Unrecognized(m@),
         }
     }
 }
 
 
-impl<'a> From<&'a ClientHelloExtensionRest<'a>> for ClientHelloExtensionRestInnerRef<'a> {
-    fn ex_from(m: &'a ClientHelloExtensionRest<'a>) -> ClientHelloExtensionRestInnerRef<'a> {
+impl<'a> From<&'a NewSessionTicketExtensionExtensionData<'a>> for NewSessionTicketExtensionExtensionDataInnerRef<'a> {
+    fn ex_from(m: &'a NewSessionTicketExtensionExtensionData<'a>) -> NewSessionTicketExtensionExtensionDataInnerRef<'a> {
         match m {
-            ClientHelloExtensionRest::MaxFragmentLength(m) => Either::Left(m),
-            ClientHelloExtensionRest::Heartbeat(m) => Either::Right(Either::Left(m)),
-            ClientHelloExtensionRest::SignedCertificateTimeStamp(m) => Either::Right(Either::Right(Either::Left(m))),
-            ClientHelloExtensionRest::ClientCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            ClientHelloExtensionRest::ServerCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            ClientHelloExtensionRest::Padding(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            ClientHelloExtensionRest::Cookie(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
-            ClientHelloExtensionRest::CertificateAuthorities(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
-            ClientHelloExtensionRest::OidFilters(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
-            ClientHelloExtensionRest::SignatureAlgorithmsCert(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))),
-            ClientHelloExtensionRest::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))),
+            NewSessionTicketExtensionExtensionData::EarlyData(m) => Either::Left(m),
+            NewSessionTicketExtensionExtensionData::Unrecognized(m) => Either::Right(m),
         }
     }
 
 }
 
-impl<'a> From<ClientHelloExtensionRestInner<'a>> for ClientHelloExtensionRest<'a> {
-    fn ex_from(m: ClientHelloExtensionRestInner<'a>) -> ClientHelloExtensionRest<'a> {
+impl<'a> From<NewSessionTicketExtensionExtensionDataInner<'a>> for NewSessionTicketExtensionExtensionData<'a> {
+    fn ex_from(m: NewSessionTicketExtensionExtensionDataInner<'a>) -> NewSessionTicketExtensionExtensionData<'a> {
         match m {
-            Either::Left(m) => ClientHelloExtensionRest::MaxFragmentLength(m),
-            Either::Right(Either::Left(m)) => ClientHelloExtensionRest::Heartbeat(m),
-            Either::Right(Either::Right(Either::Left(m))) => ClientHelloExtensionRest::SignedCertificateTimeStamp(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => ClientHelloExtensionRest::ClientCertificateType(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => ClientHelloExtensionRest::ServerCertificateType(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => ClientHelloExtensionRest::Padding(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => ClientHelloExtensionRest::Cookie(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => ClientHelloExtensionRest::CertificateAuthorities(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => ClientHelloExtensionRest::OidFilters(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))))) => ClientHelloExtensionRest::SignatureAlgorithmsCert(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))))) => ClientHelloExtensionRest::Unrecognized(m),
+            Either::Left(m) => NewSessionTicketExtensionExtensionData::EarlyData(m),
+            Either::Right(m) => NewSessionTicketExtensionExtensionData::Unrecognized(m),
         }
     }
     
 }
 
 
-pub struct ClientHelloExtensionRestMapper;
-impl View for ClientHelloExtensionRestMapper {
+pub struct NewSessionTicketExtensionExtensionDataMapper;
+impl View for NewSessionTicketExtensionExtensionDataMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ClientHelloExtensionRestMapper {
-    type Src = SpecClientHelloExtensionRestInner;
-    type Dst = SpecClientHelloExtensionRest;
+impl SpecIso for NewSessionTicketExtensionExtensionDataMapper {
+    type Src = SpecNewSessionTicketExtensionExtensionDataInner;
+    type Dst = SpecNewSessionTicketExtensionExtensionData;
 }
-impl SpecIsoProof for ClientHelloExtensionRestMapper {
+impl SpecIsoProof for NewSessionTicketExtensionExtensionDataMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -16705,354 +15942,209 @@ impl SpecIsoProof for ClientHelloExtensionRestMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ClientHelloExtensionRestMapper {
-    type Src = ClientHelloExtensionRestInner<'a>;
-    type Dst = ClientHelloExtensionRest<'a>;
-    type RefSrc = ClientHelloExtensionRestInnerRef<'a>;
+impl<'a> Iso<'a> for NewSessionTicketExtensionExtensionDataMapper {
+    type Src = NewSessionTicketExtensionExtensionDataInner<'a>;
+    type Dst = NewSessionTicketExtensionExtensionData<'a>;
+    type RefSrc = NewSessionTicketExtensionExtensionDataInnerRef<'a>;
 }
 
-type SpecClientHelloExtensionRestCombinatorAlias1 = Choice<Cond<SpecSignatureSchemeListCombinator>, Cond<bytes::Variable>>;
-type SpecClientHelloExtensionRestCombinatorAlias2 = Choice<Cond<SpecOidFilterExtensionCombinator>, SpecClientHelloExtensionRestCombinatorAlias1>;
-type SpecClientHelloExtensionRestCombinatorAlias3 = Choice<Cond<SpecCertificateAuthoritiesExtensionCombinator>, SpecClientHelloExtensionRestCombinatorAlias2>;
-type SpecClientHelloExtensionRestCombinatorAlias4 = Choice<Cond<SpecCookieCombinator>, SpecClientHelloExtensionRestCombinatorAlias3>;
-type SpecClientHelloExtensionRestCombinatorAlias5 = Choice<Cond<bytes::Variable>, SpecClientHelloExtensionRestCombinatorAlias4>;
-type SpecClientHelloExtensionRestCombinatorAlias6 = Choice<Cond<SpecServerCertTypeClientExtensionCombinator>, SpecClientHelloExtensionRestCombinatorAlias5>;
-type SpecClientHelloExtensionRestCombinatorAlias7 = Choice<Cond<SpecClientCertTypeClientExtensionCombinator>, SpecClientHelloExtensionRestCombinatorAlias6>;
-type SpecClientHelloExtensionRestCombinatorAlias8 = Choice<Cond<SpecSignedCertificateTimestampListCombinator>, SpecClientHelloExtensionRestCombinatorAlias7>;
-type SpecClientHelloExtensionRestCombinatorAlias9 = Choice<Cond<SpecHeartbeatModeCombinator>, SpecClientHelloExtensionRestCombinatorAlias8>;
-type SpecClientHelloExtensionRestCombinatorAlias10 = Choice<Cond<SpecMaxFragmentLengthCombinator>, SpecClientHelloExtensionRestCombinatorAlias9>;
-pub struct SpecClientHelloExtensionRestCombinator(pub SpecClientHelloExtensionRestCombinatorAlias);
+type SpecNewSessionTicketExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecEarlyDataIndicationNewSessionTicketCombinator>, Cond<bytes::Variable>>;
+pub struct SpecNewSessionTicketExtensionExtensionDataCombinator(pub SpecNewSessionTicketExtensionExtensionDataCombinatorAlias);
 
-impl SpecCombinator for SpecClientHelloExtensionRestCombinator {
-    type Type = SpecClientHelloExtensionRest;
+impl SpecCombinator for SpecNewSessionTicketExtensionExtensionDataCombinator {
+    type Type = SpecNewSessionTicketExtensionExtensionData;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecClientHelloExtensionRestCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecClientHelloExtensionRestCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecNewSessionTicketExtensionExtensionDataCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNewSessionTicketExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecClientHelloExtensionRestCombinatorAlias = Mapped<SpecClientHelloExtensionRestCombinatorAlias10, ClientHelloExtensionRestMapper>;
-type ClientHelloExtensionRestCombinatorAlias1 = Choice<Cond<SignatureSchemeListCombinator>, Cond<bytes::Variable>>;
-type ClientHelloExtensionRestCombinatorAlias2 = Choice<Cond<OidFilterExtensionCombinator>, ClientHelloExtensionRestCombinator1>;
-type ClientHelloExtensionRestCombinatorAlias3 = Choice<Cond<CertificateAuthoritiesExtensionCombinator>, ClientHelloExtensionRestCombinator2>;
-type ClientHelloExtensionRestCombinatorAlias4 = Choice<Cond<CookieCombinator>, ClientHelloExtensionRestCombinator3>;
-type ClientHelloExtensionRestCombinatorAlias5 = Choice<Cond<bytes::Variable>, ClientHelloExtensionRestCombinator4>;
-type ClientHelloExtensionRestCombinatorAlias6 = Choice<Cond<ServerCertTypeClientExtensionCombinator>, ClientHelloExtensionRestCombinator5>;
-type ClientHelloExtensionRestCombinatorAlias7 = Choice<Cond<ClientCertTypeClientExtensionCombinator>, ClientHelloExtensionRestCombinator6>;
-type ClientHelloExtensionRestCombinatorAlias8 = Choice<Cond<SignedCertificateTimestampListCombinator>, ClientHelloExtensionRestCombinator7>;
-type ClientHelloExtensionRestCombinatorAlias9 = Choice<Cond<HeartbeatModeCombinator>, ClientHelloExtensionRestCombinator8>;
-type ClientHelloExtensionRestCombinatorAlias10 = Choice<Cond<MaxFragmentLengthCombinator>, ClientHelloExtensionRestCombinator9>;
-pub struct ClientHelloExtensionRestCombinator1(pub ClientHelloExtensionRestCombinatorAlias1);
-impl View for ClientHelloExtensionRestCombinator1 {
-    type V = SpecClientHelloExtensionRestCombinatorAlias1;
+pub type SpecNewSessionTicketExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecNewSessionTicketExtensionExtensionDataCombinatorAlias1, NewSessionTicketExtensionExtensionDataMapper>>;
+type NewSessionTicketExtensionExtensionDataCombinatorAlias1 = Choice<Cond<EarlyDataIndicationNewSessionTicketCombinator>, Cond<bytes::Variable>>;
+pub struct NewSessionTicketExtensionExtensionDataCombinator1(pub NewSessionTicketExtensionExtensionDataCombinatorAlias1);
+impl View for NewSessionTicketExtensionExtensionDataCombinator1 {
+    type V = SpecNewSessionTicketExtensionExtensionDataCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ClientHelloExtensionRestCombinator1, ClientHelloExtensionRestCombinatorAlias1);
+impl_wrapper_combinator!(NewSessionTicketExtensionExtensionDataCombinator1, NewSessionTicketExtensionExtensionDataCombinatorAlias1);
 
-pub struct ClientHelloExtensionRestCombinator2(pub ClientHelloExtensionRestCombinatorAlias2);
-impl View for ClientHelloExtensionRestCombinator2 {
-    type V = SpecClientHelloExtensionRestCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ClientHelloExtensionRestCombinator2, ClientHelloExtensionRestCombinatorAlias2);
+pub struct NewSessionTicketExtensionExtensionDataCombinator(pub NewSessionTicketExtensionExtensionDataCombinatorAlias);
 
-pub struct ClientHelloExtensionRestCombinator3(pub ClientHelloExtensionRestCombinatorAlias3);
-impl View for ClientHelloExtensionRestCombinator3 {
-    type V = SpecClientHelloExtensionRestCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
+impl View for NewSessionTicketExtensionExtensionDataCombinator {
+    type V = SpecNewSessionTicketExtensionExtensionDataCombinator;
+    open spec fn view(&self) -> Self::V { SpecNewSessionTicketExtensionExtensionDataCombinator(self.0@) }
 }
-impl_wrapper_combinator!(ClientHelloExtensionRestCombinator3, ClientHelloExtensionRestCombinatorAlias3);
-
-pub struct ClientHelloExtensionRestCombinator4(pub ClientHelloExtensionRestCombinatorAlias4);
-impl View for ClientHelloExtensionRestCombinator4 {
-    type V = SpecClientHelloExtensionRestCombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NewSessionTicketExtensionExtensionDataCombinator {
+    type Type = NewSessionTicketExtensionExtensionData<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl_wrapper_combinator!(ClientHelloExtensionRestCombinator4, ClientHelloExtensionRestCombinatorAlias4);
+pub type NewSessionTicketExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<NewSessionTicketExtensionExtensionDataCombinator1, NewSessionTicketExtensionExtensionDataMapper>>;
 
-pub struct ClientHelloExtensionRestCombinator5(pub ClientHelloExtensionRestCombinatorAlias5);
-impl View for ClientHelloExtensionRestCombinator5 {
-    type V = SpecClientHelloExtensionRestCombinatorAlias5;
-    open spec fn view(&self) -> Self::V { self.0@ }
+
+pub open spec fn spec_new_session_ticket_extension_extension_data(extension_type: u16, ext_len: u16) -> SpecNewSessionTicketExtensionExtensionDataCombinator {
+    SpecNewSessionTicketExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::spec_from(ext_len)) as usize), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_EarlyData, inner: spec_early_data_indication_new_session_ticket() }, Cond { cond: !(extension_type == ExtensionType::SPEC_EarlyData), inner: bytes::Variable((usize::spec_from(ext_len)) as usize) }), mapper: NewSessionTicketExtensionExtensionDataMapper }))
 }
-impl_wrapper_combinator!(ClientHelloExtensionRestCombinator5, ClientHelloExtensionRestCombinatorAlias5);
 
-pub struct ClientHelloExtensionRestCombinator6(pub ClientHelloExtensionRestCombinatorAlias6);
-impl View for ClientHelloExtensionRestCombinator6 {
-    type V = SpecClientHelloExtensionRestCombinatorAlias6;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ClientHelloExtensionRestCombinator6, ClientHelloExtensionRestCombinatorAlias6);
-
-pub struct ClientHelloExtensionRestCombinator7(pub ClientHelloExtensionRestCombinatorAlias7);
-impl View for ClientHelloExtensionRestCombinator7 {
-    type V = SpecClientHelloExtensionRestCombinatorAlias7;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ClientHelloExtensionRestCombinator7, ClientHelloExtensionRestCombinatorAlias7);
-
-pub struct ClientHelloExtensionRestCombinator8(pub ClientHelloExtensionRestCombinatorAlias8);
-impl View for ClientHelloExtensionRestCombinator8 {
-    type V = SpecClientHelloExtensionRestCombinatorAlias8;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ClientHelloExtensionRestCombinator8, ClientHelloExtensionRestCombinatorAlias8);
-
-pub struct ClientHelloExtensionRestCombinator9(pub ClientHelloExtensionRestCombinatorAlias9);
-impl View for ClientHelloExtensionRestCombinator9 {
-    type V = SpecClientHelloExtensionRestCombinatorAlias9;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ClientHelloExtensionRestCombinator9, ClientHelloExtensionRestCombinatorAlias9);
-
-pub struct ClientHelloExtensionRestCombinator10(pub ClientHelloExtensionRestCombinatorAlias10);
-impl View for ClientHelloExtensionRestCombinator10 {
-    type V = SpecClientHelloExtensionRestCombinatorAlias10;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ClientHelloExtensionRestCombinator10, ClientHelloExtensionRestCombinatorAlias10);
-
-pub struct ClientHelloExtensionRestCombinator(pub ClientHelloExtensionRestCombinatorAlias);
-
-impl View for ClientHelloExtensionRestCombinator {
-    type V = SpecClientHelloExtensionRestCombinator;
-    open spec fn view(&self) -> Self::V { SpecClientHelloExtensionRestCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientHelloExtensionRestCombinator {
-    type Type = ClientHelloExtensionRest<'a>;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ClientHelloExtensionRestCombinatorAlias = Mapped<ClientHelloExtensionRestCombinator10, ClientHelloExtensionRestMapper>;
-
-
-pub open spec fn spec_client_hello_extension_rest(ext_len: u16, extension_type: u16) -> SpecClientHelloExtensionRestCombinator {
-    SpecClientHelloExtensionRestCombinator(Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_MaxFragmentLength, inner: spec_max_fragment_length() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_Heartbeat, inner: spec_heartbeat_mode() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp, inner: spec_signed_certificate_timestamp_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ClientCertificateType, inner: spec_client_cert_type_client_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ServerCertificateType, inner: spec_server_cert_type_client_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_Padding, inner: bytes::Variable(ext_len.spec_into()) }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_Cookie, inner: spec_cookie() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_CertificateAuthorities, inner: spec_certificate_authorities_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_OidFilters, inner: spec_oid_filter_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignatureAlgorithmsCert, inner: spec_signature_scheme_list() }, Cond { cond: !(extension_type == ExtensionType::SPEC_MaxFragmentLength || extension_type == ExtensionType::SPEC_Heartbeat || extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp || extension_type == ExtensionType::SPEC_ClientCertificateType || extension_type == ExtensionType::SPEC_ServerCertificateType || extension_type == ExtensionType::SPEC_Padding || extension_type == ExtensionType::SPEC_Cookie || extension_type == ExtensionType::SPEC_CertificateAuthorities || extension_type == ExtensionType::SPEC_OidFilters || extension_type == ExtensionType::SPEC_SignatureAlgorithmsCert), inner: bytes::Variable(ext_len.spec_into()) })))))))))), mapper: ClientHelloExtensionRestMapper })
-}
+pub fn new_session_ticket_extension_extension_data<'a>(extension_type: u16, ext_len: u16) -> (o: NewSessionTicketExtensionExtensionDataCombinator)
+    requires
+        spec_extension_type().wf(extension_type@),
 
-pub fn client_hello_extension_rest<'a>(ext_len: u16, extension_type: u16) -> (o: ClientHelloExtensionRestCombinator)
-    ensures o@ == spec_client_hello_extension_rest(ext_len@, extension_type@),
+    ensures o@ == spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ClientHelloExtensionRestCombinator(Mapped { inner: ClientHelloExtensionRestCombinator10(Choice::new(Cond { cond: extension_type == ExtensionType::MaxFragmentLength, inner: max_fragment_length() }, ClientHelloExtensionRestCombinator9(Choice::new(Cond { cond: extension_type == ExtensionType::Heartbeat, inner: heartbeat_mode() }, ClientHelloExtensionRestCombinator8(Choice::new(Cond { cond: extension_type == ExtensionType::SignedCertificateTimeStamp, inner: signed_certificate_timestamp_list() }, ClientHelloExtensionRestCombinator7(Choice::new(Cond { cond: extension_type == ExtensionType::ClientCertificateType, inner: client_cert_type_client_extension() }, ClientHelloExtensionRestCombinator6(Choice::new(Cond { cond: extension_type == ExtensionType::ServerCertificateType, inner: server_cert_type_client_extension() }, ClientHelloExtensionRestCombinator5(Choice::new(Cond { cond: extension_type == ExtensionType::Padding, inner: bytes::Variable(ext_len.ex_into()) }, ClientHelloExtensionRestCombinator4(Choice::new(Cond { cond: extension_type == ExtensionType::Cookie, inner: cookie() }, ClientHelloExtensionRestCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::CertificateAuthorities, inner: certificate_authorities_extension() }, ClientHelloExtensionRestCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::OidFilters, inner: oid_filter_extension() }, ClientHelloExtensionRestCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::SignatureAlgorithmsCert, inner: signature_scheme_list() }, Cond { cond: !(extension_type == ExtensionType::MaxFragmentLength || extension_type == ExtensionType::Heartbeat || extension_type == ExtensionType::SignedCertificateTimeStamp || extension_type == ExtensionType::ClientCertificateType || extension_type == ExtensionType::ServerCertificateType || extension_type == ExtensionType::Padding || extension_type == ExtensionType::Cookie || extension_type == ExtensionType::CertificateAuthorities || extension_type == ExtensionType::OidFilters || extension_type == ExtensionType::SignatureAlgorithmsCert), inner: bytes::Variable(ext_len.ex_into()) })))))))))))))))))))), mapper: ClientHelloExtensionRestMapper });
-    assert({
-        &&& combinator@ == spec_client_hello_extension_rest(ext_len@, extension_type@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = NewSessionTicketExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::ex_from(ext_len)) as usize), Mapped { inner: NewSessionTicketExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::EarlyData, inner: early_data_indication_new_session_ticket() }, Cond { cond: !(extension_type == ExtensionType::EarlyData), inner: bytes::Variable((usize::ex_from(ext_len)) as usize) })), mapper: NewSessionTicketExtensionExtensionDataMapper }));
+    // assert({
+    //     &&& combinator@ == spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_client_hello_extension_rest<'a>(input: &'a [u8], ext_len: u16, extension_type: u16) -> (res: PResult<<ClientHelloExtensionRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_new_session_ticket_extension_extension_data<'a>(input: &'a [u8], extension_type: u16, ext_len: u16) -> (res: PResult<<NewSessionTicketExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_client_hello_extension_rest(ext_len@, extension_type@).spec_parse(input@) == Some((n as int, v@)),
-        spec_client_hello_extension_rest(ext_len@, extension_type@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) == Some((n as int, v@)),
+        spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_client_hello_extension_rest(ext_len@, extension_type@).spec_parse(input@) is None,
-        spec_client_hello_extension_rest(ext_len@, extension_type@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None,
+        spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = client_hello_extension_rest( ext_len, extension_type );
+    let combinator = new_session_ticket_extension_extension_data( extension_type, ext_len );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_client_hello_extension_rest<'a>(v: <ClientHelloExtensionRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16, extension_type: u16) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_new_session_ticket_extension_extension_data<'a>(v: <NewSessionTicketExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, extension_type: u16, ext_len: u16) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_client_hello_extension_rest(ext_len@, extension_type@).wf(v@),
+        spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).wf(v@),
+        spec_extension_type().wf(extension_type@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_client_hello_extension_rest(ext_len@, extension_type@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_client_hello_extension_rest(ext_len@, extension_type@).spec_serialize(v@))
+            &&& n == spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@))
         },
 {
-    let combinator = client_hello_extension_rest( ext_len, extension_type );
+    let combinator = new_session_ticket_extension_extension_data( extension_type, ext_len );
     combinator.serialize(v, data, pos)
 }
 
-pub fn client_hello_extension_rest_len<'a>(v: <ClientHelloExtensionRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16, extension_type: u16) -> (serialize_len: usize)
+pub fn new_session_ticket_extension_extension_data_len<'a>(v: <NewSessionTicketExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, extension_type: u16, ext_len: u16) -> (serialize_len: usize)
     requires
-        spec_client_hello_extension_rest(ext_len@, extension_type@).wf(v@),
-        spec_client_hello_extension_rest(ext_len@, extension_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).wf(v@),
+        spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        serialize_len == spec_client_hello_extension_rest(ext_len@, extension_type@).spec_serialize(v@).len(),
+        serialize_len == spec_new_session_ticket_extension_extension_data(extension_type@, ext_len@).spec_serialize(v@).len(),
 {
-    let combinator = client_hello_extension_rest( ext_len, extension_type );
+    let combinator = new_session_ticket_extension_extension_data( extension_type, ext_len );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
 
-pub enum SpecClientHelloExtensionExtensionData {
-    ServerName(SpecServerNameList),
-    SignatureAlgorithms(SpecSignatureSchemeList),
-    SupportedGroups(SpecNamedGroupList),
-    StatusRequest(SpecCertificateStatusRequest),
-    ApplicationLayerProtocolNegotiation(SpecProtocolNameList),
-    SupportedVersions(SpecSupportedVersionsClient),
-    KeyShare(SpecKeyShareClientHello),
-    PskKeyExchangeModes(SpecPskKeyExchangeModes),
-    PreSharedKey(SpecPreSharedKeyClientExtension),
-    Unrecognized(SpecClientHelloExtensionRest),
+pub struct SpecNewSessionTicketExtension {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: SpecNewSessionTicketExtensionExtensionData,
 }
 
-pub type SpecClientHelloExtensionExtensionDataInner = Either<SpecServerNameList, Either<SpecSignatureSchemeList, Either<SpecNamedGroupList, Either<SpecCertificateStatusRequest, Either<SpecProtocolNameList, Either<SpecSupportedVersionsClient, Either<SpecKeyShareClientHello, Either<SpecPskKeyExchangeModes, Either<SpecPreSharedKeyClientExtension, SpecClientHelloExtensionRest>>>>>>>>>;
+pub type SpecNewSessionTicketExtensionInner = ((u16, u16), SpecNewSessionTicketExtensionExtensionData);
 
-impl SpecFrom<SpecClientHelloExtensionExtensionData> for SpecClientHelloExtensionExtensionDataInner {
-    open spec fn spec_from(m: SpecClientHelloExtensionExtensionData) -> SpecClientHelloExtensionExtensionDataInner {
-        match m {
-            SpecClientHelloExtensionExtensionData::ServerName(m) => Either::Left(m),
-            SpecClientHelloExtensionExtensionData::SignatureAlgorithms(m) => Either::Right(Either::Left(m)),
-            SpecClientHelloExtensionExtensionData::SupportedGroups(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecClientHelloExtensionExtensionData::StatusRequest(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            SpecClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            SpecClientHelloExtensionExtensionData::SupportedVersions(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            SpecClientHelloExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
-            SpecClientHelloExtensionExtensionData::PskKeyExchangeModes(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
-            SpecClientHelloExtensionExtensionData::PreSharedKey(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
-            SpecClientHelloExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))),
-        }
-    }
 
+impl SpecFrom<SpecNewSessionTicketExtension> for SpecNewSessionTicketExtensionInner {
+    open spec fn spec_from(m: SpecNewSessionTicketExtension) -> SpecNewSessionTicketExtensionInner {
+        ((m.extension_type, m.ext_len), m.extension_data)
+    }
 }
 
-                
-impl SpecFrom<SpecClientHelloExtensionExtensionDataInner> for SpecClientHelloExtensionExtensionData {
-    open spec fn spec_from(m: SpecClientHelloExtensionExtensionDataInner) -> SpecClientHelloExtensionExtensionData {
-        match m {
-            Either::Left(m) => SpecClientHelloExtensionExtensionData::ServerName(m),
-            Either::Right(Either::Left(m)) => SpecClientHelloExtensionExtensionData::SignatureAlgorithms(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecClientHelloExtensionExtensionData::SupportedGroups(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecClientHelloExtensionExtensionData::StatusRequest(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecClientHelloExtensionExtensionData::SupportedVersions(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => SpecClientHelloExtensionExtensionData::KeyShare(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => SpecClientHelloExtensionExtensionData::PskKeyExchangeModes(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => SpecClientHelloExtensionExtensionData::PreSharedKey(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))) => SpecClientHelloExtensionExtensionData::Unrecognized(m),
-        }
+impl SpecFrom<SpecNewSessionTicketExtensionInner> for SpecNewSessionTicketExtension {
+    open spec fn spec_from(m: SpecNewSessionTicketExtensionInner) -> SpecNewSessionTicketExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        SpecNewSessionTicketExtension { extension_type, ext_len, extension_data }
     }
-
 }
-
-
-
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ClientHelloExtensionExtensionData<'a> {
-    ServerName(ServerNameList<'a>),
-    SignatureAlgorithms(SignatureSchemeList),
-    SupportedGroups(NamedGroupList),
-    StatusRequest(CertificateStatusRequest<'a>),
-    ApplicationLayerProtocolNegotiation(ProtocolNameList<'a>),
-    SupportedVersions(SupportedVersionsClient),
-    KeyShare(KeyShareClientHello<'a>),
-    PskKeyExchangeModes(PskKeyExchangeModes),
-    PreSharedKey(PreSharedKeyClientExtension<'a>),
-    Unrecognized(ClientHelloExtensionRest<'a>),
-}
-
-pub type ClientHelloExtensionExtensionDataInner<'a> = Either<ServerNameList<'a>, Either<SignatureSchemeList, Either<NamedGroupList, Either<CertificateStatusRequest<'a>, Either<ProtocolNameList<'a>, Either<SupportedVersionsClient, Either<KeyShareClientHello<'a>, Either<PskKeyExchangeModes, Either<PreSharedKeyClientExtension<'a>, ClientHelloExtensionRest<'a>>>>>>>>>>;
 
-pub type ClientHelloExtensionExtensionDataInnerRef<'a> = Either<&'a ServerNameList<'a>, Either<&'a SignatureSchemeList, Either<&'a NamedGroupList, Either<&'a CertificateStatusRequest<'a>, Either<&'a ProtocolNameList<'a>, Either<&'a SupportedVersionsClient, Either<&'a KeyShareClientHello<'a>, Either<&'a PskKeyExchangeModes, Either<&'a PreSharedKeyClientExtension<'a>, &'a ClientHelloExtensionRest<'a>>>>>>>>>>;
+pub struct NewSessionTicketExtension<'a> {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: NewSessionTicketExtensionExtensionData<'a>,
+}
 
+impl View for NewSessionTicketExtension<'_> {
+    type V = SpecNewSessionTicketExtension;
 
-impl<'a> View for ClientHelloExtensionExtensionData<'a> {
-    type V = SpecClientHelloExtensionExtensionData;
     open spec fn view(&self) -> Self::V {
-        match self {
-            ClientHelloExtensionExtensionData::ServerName(m) => SpecClientHelloExtensionExtensionData::ServerName(m@),
-            ClientHelloExtensionExtensionData::SignatureAlgorithms(m) => SpecClientHelloExtensionExtensionData::SignatureAlgorithms(m@),
-            ClientHelloExtensionExtensionData::SupportedGroups(m) => SpecClientHelloExtensionExtensionData::SupportedGroups(m@),
-            ClientHelloExtensionExtensionData::StatusRequest(m) => SpecClientHelloExtensionExtensionData::StatusRequest(m@),
-            ClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => SpecClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m@),
-            ClientHelloExtensionExtensionData::SupportedVersions(m) => SpecClientHelloExtensionExtensionData::SupportedVersions(m@),
-            ClientHelloExtensionExtensionData::KeyShare(m) => SpecClientHelloExtensionExtensionData::KeyShare(m@),
-            ClientHelloExtensionExtensionData::PskKeyExchangeModes(m) => SpecClientHelloExtensionExtensionData::PskKeyExchangeModes(m@),
-            ClientHelloExtensionExtensionData::PreSharedKey(m) => SpecClientHelloExtensionExtensionData::PreSharedKey(m@),
-            ClientHelloExtensionExtensionData::Unrecognized(m) => SpecClientHelloExtensionExtensionData::Unrecognized(m@),
+        SpecNewSessionTicketExtension {
+            extension_type: self.extension_type@,
+            ext_len: self.ext_len@,
+            extension_data: self.extension_data@,
         }
     }
 }
+pub type NewSessionTicketExtensionInner<'a> = ((u16, u16), NewSessionTicketExtensionExtensionData<'a>);
 
-
-impl<'a> From<&'a ClientHelloExtensionExtensionData<'a>> for ClientHelloExtensionExtensionDataInnerRef<'a> {
-    fn ex_from(m: &'a ClientHelloExtensionExtensionData<'a>) -> ClientHelloExtensionExtensionDataInnerRef<'a> {
-        match m {
-            ClientHelloExtensionExtensionData::ServerName(m) => Either::Left(m),
-            ClientHelloExtensionExtensionData::SignatureAlgorithms(m) => Either::Right(Either::Left(m)),
-            ClientHelloExtensionExtensionData::SupportedGroups(m) => Either::Right(Either::Right(Either::Left(m))),
-            ClientHelloExtensionExtensionData::StatusRequest(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            ClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            ClientHelloExtensionExtensionData::SupportedVersions(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            ClientHelloExtensionExtensionData::KeyShare(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
-            ClientHelloExtensionExtensionData::PskKeyExchangeModes(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
-            ClientHelloExtensionExtensionData::PreSharedKey(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
-            ClientHelloExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))),
-        }
+pub type NewSessionTicketExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a NewSessionTicketExtensionExtensionData<'a>);
+impl<'a> From<&'a NewSessionTicketExtension<'a>> for NewSessionTicketExtensionInnerRef<'a> {
+    fn ex_from(m: &'a NewSessionTicketExtension) -> NewSessionTicketExtensionInnerRef<'a> {
+        ((&m.extension_type, &m.ext_len), &m.extension_data)
     }
-
 }
 
-impl<'a> From<ClientHelloExtensionExtensionDataInner<'a>> for ClientHelloExtensionExtensionData<'a> {
-    fn ex_from(m: ClientHelloExtensionExtensionDataInner<'a>) -> ClientHelloExtensionExtensionData<'a> {
-        match m {
-            Either::Left(m) => ClientHelloExtensionExtensionData::ServerName(m),
-            Either::Right(Either::Left(m)) => ClientHelloExtensionExtensionData::SignatureAlgorithms(m),
-            Either::Right(Either::Right(Either::Left(m))) => ClientHelloExtensionExtensionData::SupportedGroups(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => ClientHelloExtensionExtensionData::StatusRequest(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => ClientHelloExtensionExtensionData::ApplicationLayerProtocolNegotiation(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => ClientHelloExtensionExtensionData::SupportedVersions(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => ClientHelloExtensionExtensionData::KeyShare(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => ClientHelloExtensionExtensionData::PskKeyExchangeModes(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => ClientHelloExtensionExtensionData::PreSharedKey(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))) => ClientHelloExtensionExtensionData::Unrecognized(m),
-        }
+impl<'a> From<NewSessionTicketExtensionInner<'a>> for NewSessionTicketExtension<'a> {
+    fn ex_from(m: NewSessionTicketExtensionInner) -> NewSessionTicketExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        NewSessionTicketExtension { extension_type, ext_len, extension_data }
     }
-    
 }
 
-
-pub struct ClientHelloExtensionExtensionDataMapper;
-impl View for ClientHelloExtensionExtensionDataMapper {
+pub struct NewSessionTicketExtensionMapper;
+impl View for NewSessionTicketExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ClientHelloExtensionExtensionDataMapper {
-    type Src = SpecClientHelloExtensionExtensionDataInner;
-    type Dst = SpecClientHelloExtensionExtensionData;
+impl SpecIso for NewSessionTicketExtensionMapper {
+    type Src = SpecNewSessionTicketExtensionInner;
+    type Dst = SpecNewSessionTicketExtension;
 }
-impl SpecIsoProof for ClientHelloExtensionExtensionDataMapper {
+impl SpecIsoProof for NewSessionTicketExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -17060,272 +16152,293 @@ impl SpecIsoProof for ClientHelloExtensionExtensionDataMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ClientHelloExtensionExtensionDataMapper {
-    type Src = ClientHelloExtensionExtensionDataInner<'a>;
-    type Dst = ClientHelloExtensionExtensionData<'a>;
-    type RefSrc = ClientHelloExtensionExtensionDataInnerRef<'a>;
+impl<'a> Iso<'a> for NewSessionTicketExtensionMapper {
+    type Src = NewSessionTicketExtensionInner<'a>;
+    type Dst = NewSessionTicketExtension<'a>;
+    type RefSrc = NewSessionTicketExtensionInnerRef<'a>;
 }
 
-type SpecClientHelloExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecPreSharedKeyClientExtensionCombinator>, Cond<SpecClientHelloExtensionRestCombinator>>;
-type SpecClientHelloExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecPskKeyExchangeModesCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias1>;
-type SpecClientHelloExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SpecKeyShareClientHelloCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias2>;
-type SpecClientHelloExtensionExtensionDataCombinatorAlias4 = Choice<Cond<SpecSupportedVersionsClientCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias3>;
-type SpecClientHelloExtensionExtensionDataCombinatorAlias5 = Choice<Cond<SpecProtocolNameListCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias4>;
-type SpecClientHelloExtensionExtensionDataCombinatorAlias6 = Choice<Cond<SpecCertificateStatusRequestCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias5>;
-type SpecClientHelloExtensionExtensionDataCombinatorAlias7 = Choice<Cond<SpecNamedGroupListCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias6>;
-type SpecClientHelloExtensionExtensionDataCombinatorAlias8 = Choice<Cond<SpecSignatureSchemeListCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias7>;
-type SpecClientHelloExtensionExtensionDataCombinatorAlias9 = Choice<Cond<SpecServerNameListCombinator>, SpecClientHelloExtensionExtensionDataCombinatorAlias8>;
-pub struct SpecClientHelloExtensionExtensionDataCombinator(pub SpecClientHelloExtensionExtensionDataCombinatorAlias);
+pub struct SpecNewSessionTicketExtensionCombinator(pub SpecNewSessionTicketExtensionCombinatorAlias);
 
-impl SpecCombinator for SpecClientHelloExtensionExtensionDataCombinator {
-    type Type = SpecClientHelloExtensionExtensionData;
+impl SpecCombinator for SpecNewSessionTicketExtensionCombinator {
+    type Type = SpecNewSessionTicketExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecClientHelloExtensionExtensionDataCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecClientHelloExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecNewSessionTicketExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNewSessionTicketExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecClientHelloExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecClientHelloExtensionExtensionDataCombinatorAlias9, ClientHelloExtensionExtensionDataMapper>>;
-type ClientHelloExtensionExtensionDataCombinatorAlias1 = Choice<Cond<PreSharedKeyClientExtensionCombinator>, Cond<ClientHelloExtensionRestCombinator>>;
-type ClientHelloExtensionExtensionDataCombinatorAlias2 = Choice<Cond<PskKeyExchangeModesCombinator>, ClientHelloExtensionExtensionDataCombinator1>;
-type ClientHelloExtensionExtensionDataCombinatorAlias3 = Choice<Cond<KeyShareClientHelloCombinator>, ClientHelloExtensionExtensionDataCombinator2>;
-type ClientHelloExtensionExtensionDataCombinatorAlias4 = Choice<Cond<SupportedVersionsClientCombinator>, ClientHelloExtensionExtensionDataCombinator3>;
-type ClientHelloExtensionExtensionDataCombinatorAlias5 = Choice<Cond<ProtocolNameListCombinator>, ClientHelloExtensionExtensionDataCombinator4>;
-type ClientHelloExtensionExtensionDataCombinatorAlias6 = Choice<Cond<CertificateStatusRequestCombinator>, ClientHelloExtensionExtensionDataCombinator5>;
-type ClientHelloExtensionExtensionDataCombinatorAlias7 = Choice<Cond<NamedGroupListCombinator>, ClientHelloExtensionExtensionDataCombinator6>;
-type ClientHelloExtensionExtensionDataCombinatorAlias8 = Choice<Cond<SignatureSchemeListCombinator>, ClientHelloExtensionExtensionDataCombinator7>;
-type ClientHelloExtensionExtensionDataCombinatorAlias9 = Choice<Cond<ServerNameListCombinator>, ClientHelloExtensionExtensionDataCombinator8>;
-pub struct ClientHelloExtensionExtensionDataCombinator1(pub ClientHelloExtensionExtensionDataCombinatorAlias1);
-impl View for ClientHelloExtensionExtensionDataCombinator1 {
-    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator1, ClientHelloExtensionExtensionDataCombinatorAlias1);
+pub type SpecNewSessionTicketExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecNewSessionTicketExtensionExtensionDataCombinator>, NewSessionTicketExtensionMapper>;
 
-pub struct ClientHelloExtensionExtensionDataCombinator2(pub ClientHelloExtensionExtensionDataCombinatorAlias2);
-impl View for ClientHelloExtensionExtensionDataCombinator2 {
-    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator2, ClientHelloExtensionExtensionDataCombinatorAlias2);
+pub struct NewSessionTicketExtensionCombinator(pub NewSessionTicketExtensionCombinatorAlias);
 
-pub struct ClientHelloExtensionExtensionDataCombinator3(pub ClientHelloExtensionExtensionDataCombinatorAlias3);
-impl View for ClientHelloExtensionExtensionDataCombinator3 {
-    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
+impl View for NewSessionTicketExtensionCombinator {
+    type V = SpecNewSessionTicketExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecNewSessionTicketExtensionCombinator(self.0@) }
 }
-impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator3, ClientHelloExtensionExtensionDataCombinatorAlias3);
-
-pub struct ClientHelloExtensionExtensionDataCombinator4(pub ClientHelloExtensionExtensionDataCombinatorAlias4);
-impl View for ClientHelloExtensionExtensionDataCombinator4 {
-    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NewSessionTicketExtensionCombinator {
+    type Type = NewSessionTicketExtension<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
-impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator4, ClientHelloExtensionExtensionDataCombinatorAlias4);
+pub type NewSessionTicketExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, NewSessionTicketExtensionCont1>, NewSessionTicketExtensionExtensionDataCombinator, NewSessionTicketExtensionCont0>, NewSessionTicketExtensionMapper>;
 
-pub struct ClientHelloExtensionExtensionDataCombinator5(pub ClientHelloExtensionExtensionDataCombinatorAlias5);
-impl View for ClientHelloExtensionExtensionDataCombinator5 {
-    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias5;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator5, ClientHelloExtensionExtensionDataCombinatorAlias5);
 
-pub struct ClientHelloExtensionExtensionDataCombinator6(pub ClientHelloExtensionExtensionDataCombinatorAlias6);
-impl View for ClientHelloExtensionExtensionDataCombinator6 {
-    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias6;
-    open spec fn view(&self) -> Self::V { self.0@ }
+pub open spec fn spec_new_session_ticket_extension() -> SpecNewSessionTicketExtensionCombinator {
+    SpecNewSessionTicketExtensionCombinator(
+    Mapped {
+        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_new_session_ticket_extension_cont1(deps)), |deps| spec_new_session_ticket_extension_cont0(deps)),
+        mapper: NewSessionTicketExtensionMapper,
+    })
 }
-impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator6, ClientHelloExtensionExtensionDataCombinatorAlias6);
 
-pub struct ClientHelloExtensionExtensionDataCombinator7(pub ClientHelloExtensionExtensionDataCombinatorAlias7);
-impl View for ClientHelloExtensionExtensionDataCombinator7 {
-    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias7;
-    open spec fn view(&self) -> Self::V { self.0@ }
+pub open spec fn spec_new_session_ticket_extension_cont1(deps: u16) -> U16Be {
+    let extension_type = deps;
+    U16Be
 }
-impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator7, ClientHelloExtensionExtensionDataCombinatorAlias7);
 
-pub struct ClientHelloExtensionExtensionDataCombinator8(pub ClientHelloExtensionExtensionDataCombinatorAlias8);
-impl View for ClientHelloExtensionExtensionDataCombinator8 {
-    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias8;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator8, ClientHelloExtensionExtensionDataCombinatorAlias8);
+impl View for NewSessionTicketExtensionCont1 {
+    type V = spec_fn(u16) -> U16Be;
 
-pub struct ClientHelloExtensionExtensionDataCombinator9(pub ClientHelloExtensionExtensionDataCombinatorAlias9);
-impl View for ClientHelloExtensionExtensionDataCombinator9 {
-    type V = SpecClientHelloExtensionExtensionDataCombinatorAlias9;
-    open spec fn view(&self) -> Self::V { self.0@ }
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_new_session_ticket_extension_cont1(deps)
+        }
+    }
 }
-impl_wrapper_combinator!(ClientHelloExtensionExtensionDataCombinator9, ClientHelloExtensionExtensionDataCombinatorAlias9);
 
-pub struct ClientHelloExtensionExtensionDataCombinator(pub ClientHelloExtensionExtensionDataCombinatorAlias);
-
-impl View for ClientHelloExtensionExtensionDataCombinator {
-    type V = SpecClientHelloExtensionExtensionDataCombinator;
-    open spec fn view(&self) -> Self::V { SpecClientHelloExtensionExtensionDataCombinator(self.0@) }
+pub open spec fn spec_new_session_ticket_extension_cont0(deps: (u16, u16)) -> SpecNewSessionTicketExtensionExtensionDataCombinator {
+    let (extension_type, ext_len) = deps;
+    spec_new_session_ticket_extension_extension_data(extension_type, ext_len)
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientHelloExtensionExtensionDataCombinator {
-    type Type = ClientHelloExtensionExtensionData<'a>;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ClientHelloExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<ClientHelloExtensionExtensionDataCombinator9, ClientHelloExtensionExtensionDataMapper>>;
 
+impl View for NewSessionTicketExtensionCont0 {
+    type V = spec_fn((u16, u16)) -> SpecNewSessionTicketExtensionExtensionDataCombinator;
 
-pub open spec fn spec_client_hello_extension_extension_data(ext_len: u16, extension_type: u16) -> SpecClientHelloExtensionExtensionDataCombinator {
-    SpecClientHelloExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.spec_into()), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_ServerName, inner: spec_server_name_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignatureAlgorithms, inner: spec_signature_scheme_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SupportedGroups, inner: spec_named_group_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_StatusRequest, inner: spec_certificate_status_request() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ApplicationLayerProtocolNegotiation, inner: spec_protocol_name_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SupportedVersions, inner: spec_supported_versions_client() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_KeyShare, inner: spec_key_share_client_hello() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_PskKeyExchangeModes, inner: spec_psk_key_exchange_modes() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_PreSharedKey, inner: spec_pre_shared_key_client_extension() }, Cond { cond: !(extension_type == ExtensionType::SPEC_ServerName || extension_type == ExtensionType::SPEC_SignatureAlgorithms || extension_type == ExtensionType::SPEC_SupportedGroups || extension_type == ExtensionType::SPEC_StatusRequest || extension_type == ExtensionType::SPEC_ApplicationLayerProtocolNegotiation || extension_type == ExtensionType::SPEC_SupportedVersions || extension_type == ExtensionType::SPEC_KeyShare || extension_type == ExtensionType::SPEC_PskKeyExchangeModes || extension_type == ExtensionType::SPEC_PreSharedKey), inner: spec_client_hello_extension_rest(ext_len, extension_type) }))))))))), mapper: ClientHelloExtensionExtensionDataMapper }))
+    open spec fn view(&self) -> Self::V {
+        |deps: (u16, u16)| {
+            spec_new_session_ticket_extension_cont0(deps)
+        }
+    }
 }
 
-pub fn client_hello_extension_extension_data<'a>(ext_len: u16, extension_type: u16) -> (o: ClientHelloExtensionExtensionDataCombinator)
-    ensures o@ == spec_client_hello_extension_extension_data(ext_len@, extension_type@),
+                
+pub fn new_session_ticket_extension<'a>() -> (o: NewSessionTicketExtensionCombinator)
+    ensures o@ == spec_new_session_ticket_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ClientHelloExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.ex_into()), Mapped { inner: ClientHelloExtensionExtensionDataCombinator9(Choice::new(Cond { cond: extension_type == ExtensionType::ServerName, inner: server_name_list() }, ClientHelloExtensionExtensionDataCombinator8(Choice::new(Cond { cond: extension_type == ExtensionType::SignatureAlgorithms, inner: signature_scheme_list() }, ClientHelloExtensionExtensionDataCombinator7(Choice::new(Cond { cond: extension_type == ExtensionType::SupportedGroups, inner: named_group_list() }, ClientHelloExtensionExtensionDataCombinator6(Choice::new(Cond { cond: extension_type == ExtensionType::StatusRequest, inner: certificate_status_request() }, ClientHelloExtensionExtensionDataCombinator5(Choice::new(Cond { cond: extension_type == ExtensionType::ApplicationLayerProtocolNegotiation, inner: protocol_name_list() }, ClientHelloExtensionExtensionDataCombinator4(Choice::new(Cond { cond: extension_type == ExtensionType::SupportedVersions, inner: supported_versions_client() }, ClientHelloExtensionExtensionDataCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::KeyShare, inner: key_share_client_hello() }, ClientHelloExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::PskKeyExchangeModes, inner: psk_key_exchange_modes() }, ClientHelloExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::PreSharedKey, inner: pre_shared_key_client_extension() }, Cond { cond: !(extension_type == ExtensionType::ServerName || extension_type == ExtensionType::SignatureAlgorithms || extension_type == ExtensionType::SupportedGroups || extension_type == ExtensionType::StatusRequest || extension_type == ExtensionType::ApplicationLayerProtocolNegotiation || extension_type == ExtensionType::SupportedVersions || extension_type == ExtensionType::KeyShare || extension_type == ExtensionType::PskKeyExchangeModes || extension_type == ExtensionType::PreSharedKey), inner: client_hello_extension_rest(ext_len, extension_type) })))))))))))))))))), mapper: ClientHelloExtensionExtensionDataMapper }));
-    assert({
-        &&& combinator@ == spec_client_hello_extension_extension_data(ext_len@, extension_type@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = NewSessionTicketExtensionCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(extension_type(), NewSessionTicketExtensionCont1), NewSessionTicketExtensionCont0),
+        mapper: NewSessionTicketExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_new_session_ticket_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_client_hello_extension_extension_data<'a>(input: &'a [u8], ext_len: u16, extension_type: u16) -> (res: PResult<<ClientHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_new_session_ticket_extension<'a>(input: &'a [u8]) -> (res: PResult<<NewSessionTicketExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_client_hello_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) == Some((n as int, v@)),
-        spec_client_hello_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_new_session_ticket_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_new_session_ticket_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_client_hello_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None,
-        spec_client_hello_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_new_session_ticket_extension().spec_parse(input@) is None,
+        spec_new_session_ticket_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = client_hello_extension_extension_data( ext_len, extension_type );
+    let combinator = new_session_ticket_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_client_hello_extension_extension_data<'a>(v: <ClientHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16, extension_type: u16) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_new_session_ticket_extension<'a>(v: <NewSessionTicketExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_client_hello_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_new_session_ticket_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_client_hello_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_client_hello_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@))
+            &&& n == spec_new_session_ticket_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_new_session_ticket_extension().spec_serialize(v@))
         },
 {
-    let combinator = client_hello_extension_extension_data( ext_len, extension_type );
-    combinator.serialize(v, data, pos)
+    let combinator = new_session_ticket_extension();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn client_hello_extension_extension_data_len<'a>(v: <ClientHelloExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16, extension_type: u16) -> (serialize_len: usize)
+pub fn new_session_ticket_extension_len<'a>(v: <NewSessionTicketExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_client_hello_extension_extension_data(ext_len@, extension_type@).wf(v@),
-        spec_client_hello_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_new_session_ticket_extension().wf(v@),
+        spec_new_session_ticket_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_client_hello_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len(),
+        serialize_len == spec_new_session_ticket_extension().spec_serialize(v@).len(),
 {
-    let combinator = client_hello_extension_extension_data( ext_len, extension_type );
+    let combinator = new_session_ticket_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct NewSessionTicketExtensionCont1;
+type NewSessionTicketExtensionCont1Type<'a, 'b> = &'b u16;
+type NewSessionTicketExtensionCont1SType<'a, 'x> = &'x u16;
+type NewSessionTicketExtensionCont1Input<'a, 'b, 'x> = POrSType<NewSessionTicketExtensionCont1Type<'a, 'b>, NewSessionTicketExtensionCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<NewSessionTicketExtensionCont1Input<'a, 'b, 'x>> for NewSessionTicketExtensionCont1 {
+    type Output = U16Be;
+
+    open spec fn requires(&self, deps: NewSessionTicketExtensionCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_extension_type()).wf(deps@)
+        }
 
-pub struct SpecClientHelloExtension {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: SpecClientHelloExtensionExtensionData,
+    open spec fn ensures(&self, deps: NewSessionTicketExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_new_session_ticket_extension_cont1(deps@)
+    }
+
+    fn apply(&self, deps: NewSessionTicketExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
+            }
+            POrSType::S(deps) => {
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
+            }
+        }
+    }
+}
+pub struct NewSessionTicketExtensionCont0;
+type NewSessionTicketExtensionCont0Type<'a, 'b> = &'b (u16, u16);
+type NewSessionTicketExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
+type NewSessionTicketExtensionCont0Input<'a, 'b, 'x> = POrSType<NewSessionTicketExtensionCont0Type<'a, 'b>, NewSessionTicketExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<NewSessionTicketExtensionCont0Input<'a, 'b, 'x>> for NewSessionTicketExtensionCont0 {
+    type Output = NewSessionTicketExtensionExtensionDataCombinator;
+
+    open spec fn requires(&self, deps: NewSessionTicketExtensionCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_extension_type(), |deps| spec_new_session_ticket_extension_cont1(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: NewSessionTicketExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_new_session_ticket_extension_cont0(deps@)
+    }
+
+    fn apply(&self, deps: NewSessionTicketExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                new_session_ticket_extension_extension_data(extension_type, ext_len)
+            }
+            POrSType::S(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                new_session_ticket_extension_extension_data(extension_type, ext_len)
+            }
+        }
+    }
 }
+                
 
-pub type SpecClientHelloExtensionInner = ((u16, u16), SpecClientHelloExtensionExtensionData);
+pub struct SpecNewSessionTicketExtensions {
+    pub l: u16,
+    pub list: Seq<SpecNewSessionTicketExtension>,
+}
 
+pub type SpecNewSessionTicketExtensionsInner = (u16, Seq<SpecNewSessionTicketExtension>);
 
-impl SpecFrom<SpecClientHelloExtension> for SpecClientHelloExtensionInner {
-    open spec fn spec_from(m: SpecClientHelloExtension) -> SpecClientHelloExtensionInner {
-        ((m.extension_type, m.ext_len), m.extension_data)
+
+impl SpecFrom<SpecNewSessionTicketExtensions> for SpecNewSessionTicketExtensionsInner {
+    open spec fn spec_from(m: SpecNewSessionTicketExtensions) -> SpecNewSessionTicketExtensionsInner {
+        (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecClientHelloExtensionInner> for SpecClientHelloExtension {
-    open spec fn spec_from(m: SpecClientHelloExtensionInner) -> SpecClientHelloExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        SpecClientHelloExtension { extension_type, ext_len, extension_data }
+impl SpecFrom<SpecNewSessionTicketExtensionsInner> for SpecNewSessionTicketExtensions {
+    open spec fn spec_from(m: SpecNewSessionTicketExtensionsInner) -> SpecNewSessionTicketExtensions {
+        let (l, list) = m;
+        SpecNewSessionTicketExtensions { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ClientHelloExtension<'a> {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: ClientHelloExtensionExtensionData<'a>,
+pub struct NewSessionTicketExtensions<'a> {
+    pub l: u16,
+    pub list: RepeatResult<NewSessionTicketExtension<'a>>,
 }
 
-impl View for ClientHelloExtension<'_> {
-    type V = SpecClientHelloExtension;
+impl View for NewSessionTicketExtensions<'_> {
+    type V = SpecNewSessionTicketExtensions;
 
     open spec fn view(&self) -> Self::V {
-        SpecClientHelloExtension {
-            extension_type: self.extension_type@,
-            ext_len: self.ext_len@,
-            extension_data: self.extension_data@,
+        SpecNewSessionTicketExtensions {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
-pub type ClientHelloExtensionInner<'a> = ((u16, u16), ClientHelloExtensionExtensionData<'a>);
+pub type NewSessionTicketExtensionsInner<'a> = (u16, RepeatResult<NewSessionTicketExtension<'a>>);
 
-pub type ClientHelloExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a ClientHelloExtensionExtensionData<'a>);
-impl<'a> From<&'a ClientHelloExtension<'a>> for ClientHelloExtensionInnerRef<'a> {
-    fn ex_from(m: &'a ClientHelloExtension) -> ClientHelloExtensionInnerRef<'a> {
-        ((&m.extension_type, &m.ext_len), &m.extension_data)
+pub type NewSessionTicketExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<NewSessionTicketExtension<'a>>);
+impl<'a> From<&'a NewSessionTicketExtensions<'a>> for NewSessionTicketExtensionsInnerRef<'a> {
+    fn ex_from(m: &'a NewSessionTicketExtensions) -> NewSessionTicketExtensionsInnerRef<'a> {
+        (&m.l, &m.list)
     }
 }
 
-impl<'a> From<ClientHelloExtensionInner<'a>> for ClientHelloExtension<'a> {
-    fn ex_from(m: ClientHelloExtensionInner) -> ClientHelloExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        ClientHelloExtension { extension_type, ext_len, extension_data }
+impl<'a> From<NewSessionTicketExtensionsInner<'a>> for NewSessionTicketExtensions<'a> {
+    fn ex_from(m: NewSessionTicketExtensionsInner) -> NewSessionTicketExtensions {
+        let (l, list) = m;
+        NewSessionTicketExtensions { l, list }
     }
 }
 
-pub struct ClientHelloExtensionMapper;
-impl View for ClientHelloExtensionMapper {
+pub struct NewSessionTicketExtensionsMapper;
+impl View for NewSessionTicketExtensionsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ClientHelloExtensionMapper {
-    type Src = SpecClientHelloExtensionInner;
-    type Dst = SpecClientHelloExtension;
+impl SpecIso for NewSessionTicketExtensionsMapper {
+    type Src = SpecNewSessionTicketExtensionsInner;
+    type Dst = SpecNewSessionTicketExtensions;
 }
-impl SpecIsoProof for ClientHelloExtensionMapper {
+impl SpecIsoProof for NewSessionTicketExtensionsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -17333,283 +16446,274 @@ impl SpecIsoProof for ClientHelloExtensionMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ClientHelloExtensionMapper {
-    type Src = ClientHelloExtensionInner<'a>;
-    type Dst = ClientHelloExtension<'a>;
-    type RefSrc = ClientHelloExtensionInnerRef<'a>;
+impl<'a> Iso<'a> for NewSessionTicketExtensionsMapper {
+    type Src = NewSessionTicketExtensionsInner<'a>;
+    type Dst = NewSessionTicketExtensions<'a>;
+    type RefSrc = NewSessionTicketExtensionsInnerRef<'a>;
 }
 
-pub struct SpecClientHelloExtensionCombinator(pub SpecClientHelloExtensionCombinatorAlias);
+pub struct SpecNewSessionTicketExtensionsCombinator(pub SpecNewSessionTicketExtensionsCombinatorAlias);
 
-impl SpecCombinator for SpecClientHelloExtensionCombinator {
-    type Type = SpecClientHelloExtension;
+impl SpecCombinator for SpecNewSessionTicketExtensionsCombinator {
+    type Type = SpecNewSessionTicketExtensions;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecClientHelloExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecClientHelloExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecNewSessionTicketExtensionsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNewSessionTicketExtensionsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecClientHelloExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecClientHelloExtensionExtensionDataCombinator>, ClientHelloExtensionMapper>;
+pub type SpecNewSessionTicketExtensionsCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate14514213152276180162>, AndThen<bytes::Variable, Repeat<SpecNewSessionTicketExtensionCombinator>>>, NewSessionTicketExtensionsMapper>;
+pub struct Predicate14514213152276180162;
+impl View for Predicate14514213152276180162 {
+    type V = Self;
 
-pub struct ClientHelloExtensionCombinator(pub ClientHelloExtensionCombinatorAlias);
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate14514213152276180162 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 0 && i <= 65534)
+    }
+}
+impl SpecPred<u16> for Predicate14514213152276180162 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 0 && i <= 65534)
+    }
+}
 
-impl View for ClientHelloExtensionCombinator {
-    type V = SpecClientHelloExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecClientHelloExtensionCombinator(self.0@) }
+pub struct NewSessionTicketExtensionsCombinator(pub NewSessionTicketExtensionsCombinatorAlias);
+
+impl View for NewSessionTicketExtensionsCombinator {
+    type V = SpecNewSessionTicketExtensionsCombinator;
+    open spec fn view(&self) -> Self::V { SpecNewSessionTicketExtensionsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientHelloExtensionCombinator {
-    type Type = ClientHelloExtension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NewSessionTicketExtensionsCombinator {
+    type Type = NewSessionTicketExtensions<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ClientHelloExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, ClientHelloExtensionCont1>, ClientHelloExtensionExtensionDataCombinator, ClientHelloExtensionCont0>, ClientHelloExtensionMapper>;
+}
+pub type NewSessionTicketExtensionsCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate14514213152276180162>, AndThen<bytes::Variable, Repeat<NewSessionTicketExtensionCombinator>>, NewSessionTicketExtensionsCont0>, NewSessionTicketExtensionsMapper>;
 
 
-pub open spec fn spec_client_hello_extension() -> SpecClientHelloExtensionCombinator {
-    SpecClientHelloExtensionCombinator(
+pub open spec fn spec_new_session_ticket_extensions() -> SpecNewSessionTicketExtensionsCombinator {
+    SpecNewSessionTicketExtensionsCombinator(
     Mapped {
-        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_client_hello_extension_cont1(deps)), |deps| spec_client_hello_extension_cont0(deps)),
-        mapper: ClientHelloExtensionMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate14514213152276180162 }, |deps| spec_new_session_ticket_extensions_cont0(deps)),
+        mapper: NewSessionTicketExtensionsMapper,
     })
 }
 
-pub open spec fn spec_client_hello_extension_cont1(deps: u16) -> U16Be {
-    let extension_type = deps;
-    U16Be
+pub open spec fn spec_new_session_ticket_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecNewSessionTicketExtensionCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_new_session_ticket_extension()))
 }
 
-impl View for ClientHelloExtensionCont1 {
-    type V = spec_fn(u16) -> U16Be;
+impl View for NewSessionTicketExtensionsCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecNewSessionTicketExtensionCombinator>>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u16| {
-            spec_client_hello_extension_cont1(deps)
-        }
-    }
-}
-
-pub open spec fn spec_client_hello_extension_cont0(deps: (u16, u16)) -> SpecClientHelloExtensionExtensionDataCombinator {
-    let (extension_type, ext_len) = deps;
-    spec_client_hello_extension_extension_data(ext_len, extension_type)
-}
-
-impl View for ClientHelloExtensionCont0 {
-    type V = spec_fn((u16, u16)) -> SpecClientHelloExtensionExtensionDataCombinator;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: (u16, u16)| {
-            spec_client_hello_extension_cont0(deps)
+            spec_new_session_ticket_extensions_cont0(deps)
         }
     }
 }
 
                 
-pub fn client_hello_extension<'a>() -> (o: ClientHelloExtensionCombinator)
-    ensures o@ == spec_client_hello_extension(),
+pub fn new_session_ticket_extensions<'a>() -> (o: NewSessionTicketExtensionsCombinator)
+    ensures o@ == spec_new_session_ticket_extensions(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ClientHelloExtensionCombinator(
+    let combinator = NewSessionTicketExtensionsCombinator(
     Mapped {
-        inner: Pair::new(Pair::new(extension_type(), ClientHelloExtensionCont1), ClientHelloExtensionCont0),
-        mapper: ClientHelloExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_client_hello_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate14514213152276180162 }, NewSessionTicketExtensionsCont0),
+        mapper: NewSessionTicketExtensionsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_new_session_ticket_extensions()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_client_hello_extension<'a>(input: &'a [u8]) -> (res: PResult<<ClientHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_new_session_ticket_extensions<'a>(input: &'a [u8]) -> (res: PResult<<NewSessionTicketExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_client_hello_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_client_hello_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_new_session_ticket_extensions().spec_parse(input@) == Some((n as int, v@)),
+        spec_new_session_ticket_extensions().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_client_hello_extension().spec_parse(input@) is None,
-        spec_client_hello_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_new_session_ticket_extensions().spec_parse(input@) is None,
+        spec_new_session_ticket_extensions().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = client_hello_extension();
+    let combinator = new_session_ticket_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_client_hello_extension<'a>(v: <ClientHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_new_session_ticket_extensions<'a>(v: <NewSessionTicketExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_client_hello_extension().wf(v@),
+        spec_new_session_ticket_extensions().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_client_hello_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_client_hello_extension().spec_serialize(v@))
+            &&& n == spec_new_session_ticket_extensions().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_new_session_ticket_extensions().spec_serialize(v@))
         },
 {
-    let combinator = client_hello_extension();
+    let combinator = new_session_ticket_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn client_hello_extension_len<'a>(v: <ClientHelloExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn new_session_ticket_extensions_len<'a>(v: <NewSessionTicketExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_client_hello_extension().wf(v@),
-        spec_client_hello_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_new_session_ticket_extensions().wf(v@),
+        spec_new_session_ticket_extensions().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_client_hello_extension().spec_serialize(v@).len(),
+        serialize_len == spec_new_session_ticket_extensions().spec_serialize(v@).len(),
 {
-    let combinator = client_hello_extension();
+    let combinator = new_session_ticket_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ClientHelloExtensionCont1;
-type ClientHelloExtensionCont1Type<'a, 'b> = &'b u16;
-type ClientHelloExtensionCont1SType<'a, 'x> = &'x u16;
-type ClientHelloExtensionCont1Input<'a, 'b, 'x> = POrSType<ClientHelloExtensionCont1Type<'a, 'b>, ClientHelloExtensionCont1SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ClientHelloExtensionCont1Input<'a, 'b, 'x>> for ClientHelloExtensionCont1 {
-    type Output = U16Be;
-
-    open spec fn requires(&self, deps: ClientHelloExtensionCont1Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: ClientHelloExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_client_hello_extension_cont1(deps@)
-    }
+pub struct NewSessionTicketExtensionsCont0;
+type NewSessionTicketExtensionsCont0Type<'a, 'b> = &'b u16;
+type NewSessionTicketExtensionsCont0SType<'a, 'x> = &'x u16;
+type NewSessionTicketExtensionsCont0Input<'a, 'b, 'x> = POrSType<NewSessionTicketExtensionsCont0Type<'a, 'b>, NewSessionTicketExtensionsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<NewSessionTicketExtensionsCont0Input<'a, 'b, 'x>> for NewSessionTicketExtensionsCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<NewSessionTicketExtensionCombinator>>;
 
-    fn apply(&self, deps: ClientHelloExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let extension_type = *deps;
-                U16Be
-            }
-            POrSType::S(deps) => {
-                let extension_type = deps;
-                let extension_type = *extension_type;
-                U16Be
-            }
+    open spec fn requires(&self, deps: NewSessionTicketExtensionsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate14514213152276180162 }).wf(deps@)
         }
-    }
-}
-pub struct ClientHelloExtensionCont0;
-type ClientHelloExtensionCont0Type<'a, 'b> = &'b (u16, u16);
-type ClientHelloExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
-type ClientHelloExtensionCont0Input<'a, 'b, 'x> = POrSType<ClientHelloExtensionCont0Type<'a, 'b>, ClientHelloExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ClientHelloExtensionCont0Input<'a, 'b, 'x>> for ClientHelloExtensionCont0 {
-    type Output = ClientHelloExtensionExtensionDataCombinator;
-
-    open spec fn requires(&self, deps: ClientHelloExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
 
-    open spec fn ensures(&self, deps: ClientHelloExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_client_hello_extension_cont0(deps@)
+    open spec fn ensures(&self, deps: NewSessionTicketExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_new_session_ticket_extensions_cont0(deps@)
     }
 
-    fn apply(&self, deps: ClientHelloExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: NewSessionTicketExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let (extension_type, ext_len) = *deps;
-                client_hello_extension_extension_data(ext_len, extension_type)
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(new_session_ticket_extension()))
             }
             POrSType::S(deps) => {
-                let (extension_type, ext_len) = deps;
-                let (extension_type, ext_len) = (*extension_type, *ext_len);
-                client_hello_extension_extension_data(ext_len, extension_type)
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(new_session_ticket_extension()))
             }
         }
     }
 }
                 
 
-pub struct SpecClientExtensions {
-    pub l: u16,
-    pub list: Seq<SpecClientHelloExtension>,
+pub struct SpecNewSessionTicket {
+    pub ticket_lifetime: u32,
+    pub ticket_age_add: u32,
+    pub ticket_nonce: SpecOpaque0Ff,
+    pub ticket: SpecOpaque1Ffff,
+    pub extensions: SpecNewSessionTicketExtensions,
 }
 
-pub type SpecClientExtensionsInner = (u16, Seq<SpecClientHelloExtension>);
+pub type SpecNewSessionTicketInner = (u32, (u32, (SpecOpaque0Ff, (SpecOpaque1Ffff, SpecNewSessionTicketExtensions))));
 
 
-impl SpecFrom<SpecClientExtensions> for SpecClientExtensionsInner {
-    open spec fn spec_from(m: SpecClientExtensions) -> SpecClientExtensionsInner {
-        (m.l, m.list)
+impl SpecFrom<SpecNewSessionTicket> for SpecNewSessionTicketInner {
+    open spec fn spec_from(m: SpecNewSessionTicket) -> SpecNewSessionTicketInner {
+        (m.ticket_lifetime, (m.ticket_age_add, (m.ticket_nonce, (m.ticket, m.extensions))))
     }
 }
 
-impl SpecFrom<SpecClientExtensionsInner> for SpecClientExtensions {
-    open spec fn spec_from(m: SpecClientExtensionsInner) -> SpecClientExtensions {
-        let (l, list) = m;
-        SpecClientExtensions { l, list }
+impl SpecFrom<SpecNewSessionTicketInner> for SpecNewSessionTicket {
+    open spec fn spec_from(m: SpecNewSessionTicketInner) -> SpecNewSessionTicket {
+        let (ticket_lifetime, (ticket_age_add, (ticket_nonce, (ticket, extensions)))) = m;
+        SpecNewSessionTicket { ticket_lifetime, ticket_age_add, ticket_nonce, ticket, extensions }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ClientExtensions<'a> {
-    pub l: u16,
-    pub list: RepeatResult<ClientHelloExtension<'a>>,
+pub struct NewSessionTicket<'a> {
+    pub ticket_lifetime: u32,
+    pub ticket_age_add: u32,
+    pub ticket_nonce: Opaque0Ff<'a>,
+    pub ticket: Opaque1Ffff<'a>,
+    pub extensions: NewSessionTicketExtensions<'a>,
 }
 
-impl View for ClientExtensions<'_> {
-    type V = SpecClientExtensions;
+impl View for NewSessionTicket<'_> {
+    type V = SpecNewSessionTicket;
 
     open spec fn view(&self) -> Self::V {
-        SpecClientExtensions {
-            l: self.l@,
-            list: self.list@,
+        SpecNewSessionTicket {
+            ticket_lifetime: self.ticket_lifetime@,
+            ticket_age_add: self.ticket_age_add@,
+            ticket_nonce: self.ticket_nonce@,
+            ticket: self.ticket@,
+            extensions: self.extensions@,
         }
     }
 }
-pub type ClientExtensionsInner<'a> = (u16, RepeatResult<ClientHelloExtension<'a>>);
+pub type NewSessionTicketInner<'a> = (u32, (u32, (Opaque0Ff<'a>, (Opaque1Ffff<'a>, NewSessionTicketExtensions<'a>))));
 
-pub type ClientExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<ClientHelloExtension<'a>>);
-impl<'a> From<&'a ClientExtensions<'a>> for ClientExtensionsInnerRef<'a> {
-    fn ex_from(m: &'a ClientExtensions) -> ClientExtensionsInnerRef<'a> {
-        (&m.l, &m.list)
+pub type NewSessionTicketInnerRef<'a> = (&'a u32, (&'a u32, (&'a Opaque0Ff<'a>, (&'a Opaque1Ffff<'a>, &'a NewSessionTicketExtensions<'a>))));
+impl<'a> From<&'a NewSessionTicket<'a>> for NewSessionTicketInnerRef<'a> {
+    fn ex_from(m: &'a NewSessionTicket) -> NewSessionTicketInnerRef<'a> {
+        (&m.ticket_lifetime, (&m.ticket_age_add, (&m.ticket_nonce, (&m.ticket, &m.extensions))))
     }
 }
 
-impl<'a> From<ClientExtensionsInner<'a>> for ClientExtensions<'a> {
-    fn ex_from(m: ClientExtensionsInner) -> ClientExtensions {
-        let (l, list) = m;
-        ClientExtensions { l, list }
+impl<'a> From<NewSessionTicketInner<'a>> for NewSessionTicket<'a> {
+    fn ex_from(m: NewSessionTicketInner) -> NewSessionTicket {
+        let (ticket_lifetime, (ticket_age_add, (ticket_nonce, (ticket, extensions)))) = m;
+        NewSessionTicket { ticket_lifetime, ticket_age_add, ticket_nonce, ticket, extensions }
     }
 }
 
-pub struct ClientExtensionsMapper;
-impl View for ClientExtensionsMapper {
+pub struct NewSessionTicketMapper;
+impl View for NewSessionTicketMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ClientExtensionsMapper {
-    type Src = SpecClientExtensionsInner;
-    type Dst = SpecClientExtensions;
+impl SpecIso for NewSessionTicketMapper {
+    type Src = SpecNewSessionTicketInner;
+    type Dst = SpecNewSessionTicket;
 }
-impl SpecIsoProof for ClientExtensionsMapper {
+impl SpecIsoProof for NewSessionTicketMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -17617,273 +16721,302 @@ impl SpecIsoProof for ClientExtensionsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ClientExtensionsMapper {
-    type Src = ClientExtensionsInner<'a>;
-    type Dst = ClientExtensions<'a>;
-    type RefSrc = ClientExtensionsInnerRef<'a>;
+impl<'a> Iso<'a> for NewSessionTicketMapper {
+    type Src = NewSessionTicketInner<'a>;
+    type Dst = NewSessionTicket<'a>;
+    type RefSrc = NewSessionTicketInnerRef<'a>;
 }
+type SpecNewSessionTicketCombinatorAlias1 = (SpecOpaque1FfffCombinator, SpecNewSessionTicketExtensionsCombinator);
+type SpecNewSessionTicketCombinatorAlias2 = (SpecOpaque0FfCombinator, SpecNewSessionTicketCombinatorAlias1);
+type SpecNewSessionTicketCombinatorAlias3 = (U32Be, SpecNewSessionTicketCombinatorAlias2);
+type SpecNewSessionTicketCombinatorAlias4 = (U32Be, SpecNewSessionTicketCombinatorAlias3);
+pub struct SpecNewSessionTicketCombinator(pub SpecNewSessionTicketCombinatorAlias);
 
-pub struct SpecClientExtensionsCombinator(pub SpecClientExtensionsCombinatorAlias);
-
-impl SpecCombinator for SpecClientExtensionsCombinator {
-    type Type = SpecClientExtensions;
+impl SpecCombinator for SpecNewSessionTicketCombinator {
+    type Type = SpecNewSessionTicket;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecClientExtensionsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecClientExtensionsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecNewSessionTicketCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNewSessionTicketCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecClientExtensionsCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate9952414989822543135>, AndThen<bytes::Variable, Repeat<SpecClientHelloExtensionCombinator>>>, ClientExtensionsMapper>;
-pub struct Predicate9952414989822543135;
-impl View for Predicate9952414989822543135 {
-    type V = Self;
+pub type SpecNewSessionTicketCombinatorAlias = Mapped<SpecNewSessionTicketCombinatorAlias4, NewSessionTicketMapper>;
+type NewSessionTicketCombinatorAlias1 = (Opaque1FfffCombinator, NewSessionTicketExtensionsCombinator);
+type NewSessionTicketCombinatorAlias2 = (Opaque0FfCombinator, NewSessionTicketCombinator1);
+type NewSessionTicketCombinatorAlias3 = (U32Be, NewSessionTicketCombinator2);
+type NewSessionTicketCombinatorAlias4 = (U32Be, NewSessionTicketCombinator3);
+pub struct NewSessionTicketCombinator1(pub NewSessionTicketCombinatorAlias1);
+impl View for NewSessionTicketCombinator1 {
+    type V = SpecNewSessionTicketCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(NewSessionTicketCombinator1, NewSessionTicketCombinatorAlias1);
 
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
+pub struct NewSessionTicketCombinator2(pub NewSessionTicketCombinatorAlias2);
+impl View for NewSessionTicketCombinator2 {
+    type V = SpecNewSessionTicketCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl Pred<u16> for Predicate9952414989822543135 {
-    fn apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 8 && i <= 65535)
-    }
+impl_wrapper_combinator!(NewSessionTicketCombinator2, NewSessionTicketCombinatorAlias2);
+
+pub struct NewSessionTicketCombinator3(pub NewSessionTicketCombinatorAlias3);
+impl View for NewSessionTicketCombinator3 {
+    type V = SpecNewSessionTicketCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl SpecPred<u16> for Predicate9952414989822543135 {
-    open spec fn spec_apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 8 && i <= 65535)
-    }
+impl_wrapper_combinator!(NewSessionTicketCombinator3, NewSessionTicketCombinatorAlias3);
+
+pub struct NewSessionTicketCombinator4(pub NewSessionTicketCombinatorAlias4);
+impl View for NewSessionTicketCombinator4 {
+    type V = SpecNewSessionTicketCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(NewSessionTicketCombinator4, NewSessionTicketCombinatorAlias4);
 
-pub struct ClientExtensionsCombinator(pub ClientExtensionsCombinatorAlias);
+pub struct NewSessionTicketCombinator(pub NewSessionTicketCombinatorAlias);
 
-impl View for ClientExtensionsCombinator {
-    type V = SpecClientExtensionsCombinator;
-    open spec fn view(&self) -> Self::V { SpecClientExtensionsCombinator(self.0@) }
+impl View for NewSessionTicketCombinator {
+    type V = SpecNewSessionTicketCombinator;
+    open spec fn view(&self) -> Self::V { SpecNewSessionTicketCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientExtensionsCombinator {
-    type Type = ClientExtensions<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NewSessionTicketCombinator {
+    type Type = NewSessionTicket<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ClientExtensionsCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate9952414989822543135>, AndThen<bytes::Variable, Repeat<ClientHelloExtensionCombinator>>, ClientExtensionsCont0>, ClientExtensionsMapper>;
+}
+pub type NewSessionTicketCombinatorAlias = Mapped<NewSessionTicketCombinator4, NewSessionTicketMapper>;
 
 
-pub open spec fn spec_client_extensions() -> SpecClientExtensionsCombinator {
-    SpecClientExtensionsCombinator(
+pub open spec fn spec_new_session_ticket() -> SpecNewSessionTicketCombinator {
+    SpecNewSessionTicketCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate9952414989822543135 }, |deps| spec_client_extensions_cont0(deps)),
-        mapper: ClientExtensionsMapper,
+        inner: (U32Be, (U32Be, (spec_opaque_0_ff(), (spec_opaque_1_ffff(), spec_new_session_ticket_extensions())))),
+        mapper: NewSessionTicketMapper,
     })
 }
 
-pub open spec fn spec_client_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecClientHelloExtensionCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_client_hello_extension()))
-}
-
-impl View for ClientExtensionsCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecClientHelloExtensionCombinator>>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_client_extensions_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn client_extensions<'a>() -> (o: ClientExtensionsCombinator)
-    ensures o@ == spec_client_extensions(),
+pub fn new_session_ticket<'a>() -> (o: NewSessionTicketCombinator)
+    ensures o@ == spec_new_session_ticket(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ClientExtensionsCombinator(
+    let combinator = NewSessionTicketCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate9952414989822543135 }, ClientExtensionsCont0),
-        mapper: ClientExtensionsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_client_extensions()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: NewSessionTicketCombinator4((U32Be, NewSessionTicketCombinator3((U32Be, NewSessionTicketCombinator2((opaque_0_ff(), NewSessionTicketCombinator1((opaque_1_ffff(), new_session_ticket_extensions())))))))),
+        mapper: NewSessionTicketMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_new_session_ticket()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_client_extensions<'a>(input: &'a [u8]) -> (res: PResult<<ClientExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_new_session_ticket<'a>(input: &'a [u8]) -> (res: PResult<<NewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_client_extensions().spec_parse(input@) == Some((n as int, v@)),
-        spec_client_extensions().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_new_session_ticket().spec_parse(input@) == Some((n as int, v@)),
+        spec_new_session_ticket().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_client_extensions().spec_parse(input@) is None,
-        spec_client_extensions().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_new_session_ticket().spec_parse(input@) is None,
+        spec_new_session_ticket().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = client_extensions();
+    let combinator = new_session_ticket();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_client_extensions<'a>(v: <ClientExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_new_session_ticket<'a>(v: <NewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_client_extensions().wf(v@),
+        spec_new_session_ticket().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_client_extensions().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_client_extensions().spec_serialize(v@))
+            &&& n == spec_new_session_ticket().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_new_session_ticket().spec_serialize(v@))
         },
 {
-    let combinator = client_extensions();
+    let combinator = new_session_ticket();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn client_extensions_len<'a>(v: <ClientExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn new_session_ticket_len<'a>(v: <NewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_client_extensions().wf(v@),
-        spec_client_extensions().spec_serialize(v@).len() <= usize::MAX,
+        spec_new_session_ticket().wf(v@),
+        spec_new_session_ticket().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_client_extensions().spec_serialize(v@).len(),
+        serialize_len == spec_new_session_ticket().spec_serialize(v@).len(),
 {
-    let combinator = client_extensions();
+    let combinator = new_session_ticket();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ClientExtensionsCont0;
-type ClientExtensionsCont0Type<'a, 'b> = &'b u16;
-type ClientExtensionsCont0SType<'a, 'x> = &'x u16;
-type ClientExtensionsCont0Input<'a, 'b, 'x> = POrSType<ClientExtensionsCont0Type<'a, 'b>, ClientExtensionsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ClientExtensionsCont0Input<'a, 'b, 'x>> for ClientExtensionsCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<ClientHelloExtensionCombinator>>;
+                
 
-    open spec fn requires(&self, deps: ClientExtensionsCont0Input<'a, 'b, 'x>) -> bool { true }
+pub enum SpecEncryptedExtensionExtensionData {
+    ServerName(SpecEmpty),
+    MaxFragmentLength(u8),
+    SupportedGroups(SpecNamedGroupList),
+    Heartbeat(u8),
+    ApplicationLayerProtocolNegotiation(SpecProtocolNameList),
+    ClientCertificateType(SpecClientCertTypeClientExtension),
+    ServerCertificateType(SpecServerCertTypeClientExtension),
+    EarlyData(SpecEmpty),
+    Unrecognized(Seq<u8>),
+}
 
-    open spec fn ensures(&self, deps: ClientExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_client_extensions_cont0(deps@)
-    }
+pub type SpecEncryptedExtensionExtensionDataInner = Either<SpecEmpty, Either<u8, Either<SpecNamedGroupList, Either<u8, Either<SpecProtocolNameList, Either<SpecClientCertTypeClientExtension, Either<SpecServerCertTypeClientExtension, Either<SpecEmpty, Seq<u8>>>>>>>>>;
 
-    fn apply(&self, deps: ClientExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(client_hello_extension()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(client_hello_extension()))
-            }
+impl SpecFrom<SpecEncryptedExtensionExtensionData> for SpecEncryptedExtensionExtensionDataInner {
+    open spec fn spec_from(m: SpecEncryptedExtensionExtensionData) -> SpecEncryptedExtensionExtensionDataInner {
+        match m {
+            SpecEncryptedExtensionExtensionData::ServerName(m) => Either::Left(m),
+            SpecEncryptedExtensionExtensionData::MaxFragmentLength(m) => Either::Right(Either::Left(m)),
+            SpecEncryptedExtensionExtensionData::SupportedGroups(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecEncryptedExtensionExtensionData::Heartbeat(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecEncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecEncryptedExtensionExtensionData::ClientCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            SpecEncryptedExtensionExtensionData::ServerCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            SpecEncryptedExtensionExtensionData::EarlyData(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
+            SpecEncryptedExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))),
         }
     }
+
 }
+
                 
+impl SpecFrom<SpecEncryptedExtensionExtensionDataInner> for SpecEncryptedExtensionExtensionData {
+    open spec fn spec_from(m: SpecEncryptedExtensionExtensionDataInner) -> SpecEncryptedExtensionExtensionData {
+        match m {
+            Either::Left(m) => SpecEncryptedExtensionExtensionData::ServerName(m),
+            Either::Right(Either::Left(m)) => SpecEncryptedExtensionExtensionData::MaxFragmentLength(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecEncryptedExtensionExtensionData::SupportedGroups(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecEncryptedExtensionExtensionData::Heartbeat(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecEncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecEncryptedExtensionExtensionData::ClientCertificateType(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => SpecEncryptedExtensionExtensionData::ServerCertificateType(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => SpecEncryptedExtensionExtensionData::EarlyData(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))) => SpecEncryptedExtensionExtensionData::Unrecognized(m),
+        }
+    }
 
-pub struct SpecClientHello {
-    pub legacy_version: u16,
-    pub random: Seq<u8>,
-    pub legacy_session_id: SpecSessionId,
-    pub cipher_suites: SpecCipherSuiteList,
-    pub legacy_compression_methods: SpecOpaque1Ff,
-    pub extensions: SpecClientExtensions,
 }
 
-pub type SpecClientHelloInner = (u16, (Seq<u8>, (SpecSessionId, (SpecCipherSuiteList, (SpecOpaque1Ff, SpecClientExtensions)))));
 
 
-impl SpecFrom<SpecClientHello> for SpecClientHelloInner {
-    open spec fn spec_from(m: SpecClientHello) -> SpecClientHelloInner {
-        (m.legacy_version, (m.random, (m.legacy_session_id, (m.cipher_suites, (m.legacy_compression_methods, m.extensions)))))
-    }
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EncryptedExtensionExtensionData<'a> {
+    ServerName(Empty<'a>),
+    MaxFragmentLength(u8),
+    SupportedGroups(NamedGroupList),
+    Heartbeat(u8),
+    ApplicationLayerProtocolNegotiation(ProtocolNameList<'a>),
+    ClientCertificateType(ClientCertTypeClientExtension),
+    ServerCertificateType(ServerCertTypeClientExtension),
+    EarlyData(Empty<'a>),
+    Unrecognized(&'a [u8]),
 }
 
-impl SpecFrom<SpecClientHelloInner> for SpecClientHello {
-    open spec fn spec_from(m: SpecClientHelloInner) -> SpecClientHello {
-        let (legacy_version, (random, (legacy_session_id, (cipher_suites, (legacy_compression_methods, extensions))))) = m;
-        SpecClientHello { legacy_version, random, legacy_session_id, cipher_suites, legacy_compression_methods, extensions }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
+pub type EncryptedExtensionExtensionDataInner<'a> = Either<Empty<'a>, Either<u8, Either<NamedGroupList, Either<u8, Either<ProtocolNameList<'a>, Either<ClientCertTypeClientExtension, Either<ServerCertTypeClientExtension, Either<Empty<'a>, &'a [u8]>>>>>>>>;
 
-pub struct ClientHello<'a> {
-    pub legacy_version: u16,
-    pub random: &'a [u8],
-    pub legacy_session_id: SessionId<'a>,
-    pub cipher_suites: CipherSuiteList,
-    pub legacy_compression_methods: Opaque1Ff<'a>,
-    pub extensions: ClientExtensions<'a>,
-}
+pub type EncryptedExtensionExtensionDataInnerRef<'a> = Either<&'a Empty<'a>, Either<&'a u8, Either<&'a NamedGroupList, Either<&'a u8, Either<&'a ProtocolNameList<'a>, Either<&'a ClientCertTypeClientExtension, Either<&'a ServerCertTypeClientExtension, Either<&'a Empty<'a>, &'a &'a [u8]>>>>>>>>;
 
-impl View for ClientHello<'_> {
-    type V = SpecClientHello;
 
+impl<'a> View for EncryptedExtensionExtensionData<'a> {
+    type V = SpecEncryptedExtensionExtensionData;
     open spec fn view(&self) -> Self::V {
-        SpecClientHello {
-            legacy_version: self.legacy_version@,
-            random: self.random@,
-            legacy_session_id: self.legacy_session_id@,
-            cipher_suites: self.cipher_suites@,
-            legacy_compression_methods: self.legacy_compression_methods@,
-            extensions: self.extensions@,
+        match self {
+            EncryptedExtensionExtensionData::ServerName(m) => SpecEncryptedExtensionExtensionData::ServerName(m@),
+            EncryptedExtensionExtensionData::MaxFragmentLength(m) => SpecEncryptedExtensionExtensionData::MaxFragmentLength(m@),
+            EncryptedExtensionExtensionData::SupportedGroups(m) => SpecEncryptedExtensionExtensionData::SupportedGroups(m@),
+            EncryptedExtensionExtensionData::Heartbeat(m) => SpecEncryptedExtensionExtensionData::Heartbeat(m@),
+            EncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => SpecEncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m@),
+            EncryptedExtensionExtensionData::ClientCertificateType(m) => SpecEncryptedExtensionExtensionData::ClientCertificateType(m@),
+            EncryptedExtensionExtensionData::ServerCertificateType(m) => SpecEncryptedExtensionExtensionData::ServerCertificateType(m@),
+            EncryptedExtensionExtensionData::EarlyData(m) => SpecEncryptedExtensionExtensionData::EarlyData(m@),
+            EncryptedExtensionExtensionData::Unrecognized(m) => SpecEncryptedExtensionExtensionData::Unrecognized(m@),
         }
     }
 }
-pub type ClientHelloInner<'a> = (u16, (&'a [u8], (SessionId<'a>, (CipherSuiteList, (Opaque1Ff<'a>, ClientExtensions<'a>)))));
 
-pub type ClientHelloInnerRef<'a> = (&'a u16, (&'a &'a [u8], (&'a SessionId<'a>, (&'a CipherSuiteList, (&'a Opaque1Ff<'a>, &'a ClientExtensions<'a>)))));
-impl<'a> From<&'a ClientHello<'a>> for ClientHelloInnerRef<'a> {
-    fn ex_from(m: &'a ClientHello) -> ClientHelloInnerRef<'a> {
-        (&m.legacy_version, (&m.random, (&m.legacy_session_id, (&m.cipher_suites, (&m.legacy_compression_methods, &m.extensions)))))
+
+impl<'a> From<&'a EncryptedExtensionExtensionData<'a>> for EncryptedExtensionExtensionDataInnerRef<'a> {
+    fn ex_from(m: &'a EncryptedExtensionExtensionData<'a>) -> EncryptedExtensionExtensionDataInnerRef<'a> {
+        match m {
+            EncryptedExtensionExtensionData::ServerName(m) => Either::Left(m),
+            EncryptedExtensionExtensionData::MaxFragmentLength(m) => Either::Right(Either::Left(m)),
+            EncryptedExtensionExtensionData::SupportedGroups(m) => Either::Right(Either::Right(Either::Left(m))),
+            EncryptedExtensionExtensionData::Heartbeat(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            EncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            EncryptedExtensionExtensionData::ClientCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            EncryptedExtensionExtensionData::ServerCertificateType(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            EncryptedExtensionExtensionData::EarlyData(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
+            EncryptedExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))),
+        }
     }
+
 }
 
-impl<'a> From<ClientHelloInner<'a>> for ClientHello<'a> {
-    fn ex_from(m: ClientHelloInner) -> ClientHello {
-        let (legacy_version, (random, (legacy_session_id, (cipher_suites, (legacy_compression_methods, extensions))))) = m;
-        ClientHello { legacy_version, random, legacy_session_id, cipher_suites, legacy_compression_methods, extensions }
+impl<'a> From<EncryptedExtensionExtensionDataInner<'a>> for EncryptedExtensionExtensionData<'a> {
+    fn ex_from(m: EncryptedExtensionExtensionDataInner<'a>) -> EncryptedExtensionExtensionData<'a> {
+        match m {
+            Either::Left(m) => EncryptedExtensionExtensionData::ServerName(m),
+            Either::Right(Either::Left(m)) => EncryptedExtensionExtensionData::MaxFragmentLength(m),
+            Either::Right(Either::Right(Either::Left(m))) => EncryptedExtensionExtensionData::SupportedGroups(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => EncryptedExtensionExtensionData::Heartbeat(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => EncryptedExtensionExtensionData::ApplicationLayerProtocolNegotiation(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => EncryptedExtensionExtensionData::ClientCertificateType(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => EncryptedExtensionExtensionData::ServerCertificateType(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => EncryptedExtensionExtensionData::EarlyData(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))))) => EncryptedExtensionExtensionData::Unrecognized(m),
+        }
     }
+    
 }
 
-pub struct ClientHelloMapper;
-impl View for ClientHelloMapper {
+
+pub struct EncryptedExtensionExtensionDataMapper;
+impl View for EncryptedExtensionExtensionDataMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ClientHelloMapper {
-    type Src = SpecClientHelloInner;
-    type Dst = SpecClientHello;
+impl SpecIso for EncryptedExtensionExtensionDataMapper {
+    type Src = SpecEncryptedExtensionExtensionDataInner;
+    type Dst = SpecEncryptedExtensionExtensionData;
 }
-impl SpecIsoProof for ClientHelloMapper {
+impl SpecIsoProof for EncryptedExtensionExtensionDataMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -17891,243 +17024,272 @@ impl SpecIsoProof for ClientHelloMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ClientHelloMapper {
-    type Src = ClientHelloInner<'a>;
-    type Dst = ClientHello<'a>;
-    type RefSrc = ClientHelloInnerRef<'a>;
+impl<'a> Iso<'a> for EncryptedExtensionExtensionDataMapper {
+    type Src = EncryptedExtensionExtensionDataInner<'a>;
+    type Dst = EncryptedExtensionExtensionData<'a>;
+    type RefSrc = EncryptedExtensionExtensionDataInnerRef<'a>;
 }
-pub const CLIENTHELLOLEGACY_VERSION_CONST: u16 = 771;
-type SpecClientHelloCombinatorAlias1 = (SpecOpaque1FfCombinator, SpecClientExtensionsCombinator);
-type SpecClientHelloCombinatorAlias2 = (SpecCipherSuiteListCombinator, SpecClientHelloCombinatorAlias1);
-type SpecClientHelloCombinatorAlias3 = (SpecSessionIdCombinator, SpecClientHelloCombinatorAlias2);
-type SpecClientHelloCombinatorAlias4 = (bytes::Fixed<32>, SpecClientHelloCombinatorAlias3);
-type SpecClientHelloCombinatorAlias5 = (Refined<U16Be, TagPred<u16>>, SpecClientHelloCombinatorAlias4);
-pub struct SpecClientHelloCombinator(pub SpecClientHelloCombinatorAlias);
 
-impl SpecCombinator for SpecClientHelloCombinator {
-    type Type = SpecClientHello;
+type SpecEncryptedExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecEmptyCombinator>, Cond<bytes::Variable>>;
+type SpecEncryptedExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecServerCertTypeClientExtensionCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias1>;
+type SpecEncryptedExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SpecClientCertTypeClientExtensionCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias2>;
+type SpecEncryptedExtensionExtensionDataCombinatorAlias4 = Choice<Cond<SpecProtocolNameListCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias3>;
+type SpecEncryptedExtensionExtensionDataCombinatorAlias5 = Choice<Cond<SpecHeartbeatModeCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias4>;
+type SpecEncryptedExtensionExtensionDataCombinatorAlias6 = Choice<Cond<SpecNamedGroupListCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias5>;
+type SpecEncryptedExtensionExtensionDataCombinatorAlias7 = Choice<Cond<SpecMaxFragmentLengthCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias6>;
+type SpecEncryptedExtensionExtensionDataCombinatorAlias8 = Choice<Cond<SpecEmptyCombinator>, SpecEncryptedExtensionExtensionDataCombinatorAlias7>;
+pub struct SpecEncryptedExtensionExtensionDataCombinator(pub SpecEncryptedExtensionExtensionDataCombinatorAlias);
+
+impl SpecCombinator for SpecEncryptedExtensionExtensionDataCombinator {
+    type Type = SpecEncryptedExtensionExtensionData;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecClientHelloCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecClientHelloCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecEncryptedExtensionExtensionDataCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEncryptedExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecClientHelloCombinatorAlias = Mapped<SpecClientHelloCombinatorAlias5, ClientHelloMapper>;
-type ClientHelloCombinatorAlias1 = (Opaque1FfCombinator, ClientExtensionsCombinator);
-type ClientHelloCombinatorAlias2 = (CipherSuiteListCombinator, ClientHelloCombinator1);
-type ClientHelloCombinatorAlias3 = (SessionIdCombinator, ClientHelloCombinator2);
-type ClientHelloCombinatorAlias4 = (bytes::Fixed<32>, ClientHelloCombinator3);
-type ClientHelloCombinatorAlias5 = (Refined<U16Be, TagPred<u16>>, ClientHelloCombinator4);
-pub struct ClientHelloCombinator1(pub ClientHelloCombinatorAlias1);
-impl View for ClientHelloCombinator1 {
-    type V = SpecClientHelloCombinatorAlias1;
+pub type SpecEncryptedExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecEncryptedExtensionExtensionDataCombinatorAlias8, EncryptedExtensionExtensionDataMapper>>;
+type EncryptedExtensionExtensionDataCombinatorAlias1 = Choice<Cond<EmptyCombinator>, Cond<bytes::Variable>>;
+type EncryptedExtensionExtensionDataCombinatorAlias2 = Choice<Cond<ServerCertTypeClientExtensionCombinator>, EncryptedExtensionExtensionDataCombinator1>;
+type EncryptedExtensionExtensionDataCombinatorAlias3 = Choice<Cond<ClientCertTypeClientExtensionCombinator>, EncryptedExtensionExtensionDataCombinator2>;
+type EncryptedExtensionExtensionDataCombinatorAlias4 = Choice<Cond<ProtocolNameListCombinator>, EncryptedExtensionExtensionDataCombinator3>;
+type EncryptedExtensionExtensionDataCombinatorAlias5 = Choice<Cond<HeartbeatModeCombinator>, EncryptedExtensionExtensionDataCombinator4>;
+type EncryptedExtensionExtensionDataCombinatorAlias6 = Choice<Cond<NamedGroupListCombinator>, EncryptedExtensionExtensionDataCombinator5>;
+type EncryptedExtensionExtensionDataCombinatorAlias7 = Choice<Cond<MaxFragmentLengthCombinator>, EncryptedExtensionExtensionDataCombinator6>;
+type EncryptedExtensionExtensionDataCombinatorAlias8 = Choice<Cond<EmptyCombinator>, EncryptedExtensionExtensionDataCombinator7>;
+pub struct EncryptedExtensionExtensionDataCombinator1(pub EncryptedExtensionExtensionDataCombinatorAlias1);
+impl View for EncryptedExtensionExtensionDataCombinator1 {
+    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ClientHelloCombinator1, ClientHelloCombinatorAlias1);
+impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator1, EncryptedExtensionExtensionDataCombinatorAlias1);
 
-pub struct ClientHelloCombinator2(pub ClientHelloCombinatorAlias2);
-impl View for ClientHelloCombinator2 {
-    type V = SpecClientHelloCombinatorAlias2;
+pub struct EncryptedExtensionExtensionDataCombinator2(pub EncryptedExtensionExtensionDataCombinatorAlias2);
+impl View for EncryptedExtensionExtensionDataCombinator2 {
+    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias2;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ClientHelloCombinator2, ClientHelloCombinatorAlias2);
+impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator2, EncryptedExtensionExtensionDataCombinatorAlias2);
 
-pub struct ClientHelloCombinator3(pub ClientHelloCombinatorAlias3);
-impl View for ClientHelloCombinator3 {
-    type V = SpecClientHelloCombinatorAlias3;
+pub struct EncryptedExtensionExtensionDataCombinator3(pub EncryptedExtensionExtensionDataCombinatorAlias3);
+impl View for EncryptedExtensionExtensionDataCombinator3 {
+    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias3;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ClientHelloCombinator3, ClientHelloCombinatorAlias3);
+impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator3, EncryptedExtensionExtensionDataCombinatorAlias3);
 
-pub struct ClientHelloCombinator4(pub ClientHelloCombinatorAlias4);
-impl View for ClientHelloCombinator4 {
-    type V = SpecClientHelloCombinatorAlias4;
+pub struct EncryptedExtensionExtensionDataCombinator4(pub EncryptedExtensionExtensionDataCombinatorAlias4);
+impl View for EncryptedExtensionExtensionDataCombinator4 {
+    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias4;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ClientHelloCombinator4, ClientHelloCombinatorAlias4);
+impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator4, EncryptedExtensionExtensionDataCombinatorAlias4);
 
-pub struct ClientHelloCombinator5(pub ClientHelloCombinatorAlias5);
-impl View for ClientHelloCombinator5 {
-    type V = SpecClientHelloCombinatorAlias5;
+pub struct EncryptedExtensionExtensionDataCombinator5(pub EncryptedExtensionExtensionDataCombinatorAlias5);
+impl View for EncryptedExtensionExtensionDataCombinator5 {
+    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias5;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ClientHelloCombinator5, ClientHelloCombinatorAlias5);
+impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator5, EncryptedExtensionExtensionDataCombinatorAlias5);
 
-pub struct ClientHelloCombinator(pub ClientHelloCombinatorAlias);
+pub struct EncryptedExtensionExtensionDataCombinator6(pub EncryptedExtensionExtensionDataCombinatorAlias6);
+impl View for EncryptedExtensionExtensionDataCombinator6 {
+    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator6, EncryptedExtensionExtensionDataCombinatorAlias6);
 
-impl View for ClientHelloCombinator {
-    type V = SpecClientHelloCombinator;
-    open spec fn view(&self) -> Self::V { SpecClientHelloCombinator(self.0@) }
+pub struct EncryptedExtensionExtensionDataCombinator7(pub EncryptedExtensionExtensionDataCombinatorAlias7);
+impl View for EncryptedExtensionExtensionDataCombinator7 {
+    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias7;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientHelloCombinator {
-    type Type = ClientHello<'a>;
+impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator7, EncryptedExtensionExtensionDataCombinatorAlias7);
+
+pub struct EncryptedExtensionExtensionDataCombinator8(pub EncryptedExtensionExtensionDataCombinatorAlias8);
+impl View for EncryptedExtensionExtensionDataCombinator8 {
+    type V = SpecEncryptedExtensionExtensionDataCombinatorAlias8;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(EncryptedExtensionExtensionDataCombinator8, EncryptedExtensionExtensionDataCombinatorAlias8);
+
+pub struct EncryptedExtensionExtensionDataCombinator(pub EncryptedExtensionExtensionDataCombinatorAlias);
+
+impl View for EncryptedExtensionExtensionDataCombinator {
+    type V = SpecEncryptedExtensionExtensionDataCombinator;
+    open spec fn view(&self) -> Self::V { SpecEncryptedExtensionExtensionDataCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EncryptedExtensionExtensionDataCombinator {
+    type Type = EncryptedExtensionExtensionData<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ClientHelloCombinatorAlias = Mapped<ClientHelloCombinator5, ClientHelloMapper>;
+}
+pub type EncryptedExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<EncryptedExtensionExtensionDataCombinator8, EncryptedExtensionExtensionDataMapper>>;
 
 
-pub open spec fn spec_client_hello() -> SpecClientHelloCombinator {
-    SpecClientHelloCombinator(
-    Mapped {
-        inner: (Refined { inner: U16Be, predicate: TagPred(CLIENTHELLOLEGACY_VERSION_CONST) }, (bytes::Fixed::<32>, (spec_session_id(), (spec_cipher_suite_list(), (spec_opaque_1_ff(), spec_client_extensions()))))),
-        mapper: ClientHelloMapper,
-    })
+pub open spec fn spec_encrypted_extension_extension_data(ext_len: u16, extension_type: u16) -> SpecEncryptedExtensionExtensionDataCombinator {
+    SpecEncryptedExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::spec_from(ext_len)) as usize), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_ServerName, inner: spec_empty() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_MaxFragmentLength, inner: spec_max_fragment_length() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SupportedGroups, inner: spec_named_group_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_Heartbeat, inner: spec_heartbeat_mode() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ApplicationLayerProtocolNegotiation, inner: spec_protocol_name_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ClientCertificateType, inner: spec_client_cert_type_client_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_ServerCertificateType, inner: spec_server_cert_type_client_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_EarlyData, inner: spec_empty() }, Cond { cond: !(extension_type == ExtensionType::SPEC_ServerName || extension_type == ExtensionType::SPEC_MaxFragmentLength || extension_type == ExtensionType::SPEC_SupportedGroups || extension_type == ExtensionType::SPEC_Heartbeat || extension_type == ExtensionType::SPEC_ApplicationLayerProtocolNegotiation || extension_type == ExtensionType::SPEC_ClientCertificateType || extension_type == ExtensionType::SPEC_ServerCertificateType || extension_type == ExtensionType::SPEC_EarlyData), inner: bytes::Variable((usize::spec_from(ext_len)) as usize) })))))))), mapper: EncryptedExtensionExtensionDataMapper }))
 }
 
-                
-pub fn client_hello<'a>() -> (o: ClientHelloCombinator)
-    ensures o@ == spec_client_hello(),
+pub fn encrypted_extension_extension_data<'a>(ext_len: u16, extension_type: u16) -> (o: EncryptedExtensionExtensionDataCombinator)
+    requires
+        spec_extension_type().wf(extension_type@),
+
+    ensures o@ == spec_encrypted_extension_extension_data(ext_len@, extension_type@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ClientHelloCombinator(
-    Mapped {
-        inner: ClientHelloCombinator5((Refined { inner: U16Be, predicate: TagPred(CLIENTHELLOLEGACY_VERSION_CONST) }, ClientHelloCombinator4((bytes::Fixed::<32>, ClientHelloCombinator3((session_id(), ClientHelloCombinator2((cipher_suite_list(), ClientHelloCombinator1((opaque_1_ff(), client_extensions())))))))))),
-        mapper: ClientHelloMapper,
-    });
-    assert({
-        &&& combinator@ == spec_client_hello()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = EncryptedExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::ex_from(ext_len)) as usize), Mapped { inner: EncryptedExtensionExtensionDataCombinator8(Choice::new(Cond { cond: extension_type == ExtensionType::ServerName, inner: empty() }, EncryptedExtensionExtensionDataCombinator7(Choice::new(Cond { cond: extension_type == ExtensionType::MaxFragmentLength, inner: max_fragment_length() }, EncryptedExtensionExtensionDataCombinator6(Choice::new(Cond { cond: extension_type == ExtensionType::SupportedGroups, inner: named_group_list() }, EncryptedExtensionExtensionDataCombinator5(Choice::new(Cond { cond: extension_type == ExtensionType::Heartbeat, inner: heartbeat_mode() }, EncryptedExtensionExtensionDataCombinator4(Choice::new(Cond { cond: extension_type == ExtensionType::ApplicationLayerProtocolNegotiation, inner: protocol_name_list() }, EncryptedExtensionExtensionDataCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::ClientCertificateType, inner: client_cert_type_client_extension() }, EncryptedExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::ServerCertificateType, inner: server_cert_type_client_extension() }, EncryptedExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::EarlyData, inner: empty() }, Cond { cond: !(extension_type == ExtensionType::ServerName || extension_type == ExtensionType::MaxFragmentLength || extension_type == ExtensionType::SupportedGroups || extension_type == ExtensionType::Heartbeat || extension_type == ExtensionType::ApplicationLayerProtocolNegotiation || extension_type == ExtensionType::ClientCertificateType || extension_type == ExtensionType::ServerCertificateType || extension_type == ExtensionType::EarlyData), inner: bytes::Variable((usize::ex_from(ext_len)) as usize) })))))))))))))))), mapper: EncryptedExtensionExtensionDataMapper }));
+    // assert({
+    //     &&& combinator@ == spec_encrypted_extension_extension_data(ext_len@, extension_type@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_client_hello<'a>(input: &'a [u8]) -> (res: PResult<<ClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_encrypted_extension_extension_data<'a>(input: &'a [u8], ext_len: u16, extension_type: u16) -> (res: PResult<<EncryptedExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_client_hello().spec_parse(input@) == Some((n as int, v@)),
-        spec_client_hello().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) == Some((n as int, v@)),
+        spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_client_hello().spec_parse(input@) is None,
-        spec_client_hello().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None,
+        spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = client_hello();
+    let combinator = encrypted_extension_extension_data( ext_len, extension_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_client_hello<'a>(v: <ClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_encrypted_extension_extension_data<'a>(v: <EncryptedExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16, extension_type: u16) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_client_hello().wf(v@),
+        spec_encrypted_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_extension_type().wf(extension_type@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_client_hello().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_client_hello().spec_serialize(v@))
+            &&& n == spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@))
         },
 {
-    let combinator = client_hello();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = encrypted_extension_extension_data( ext_len, extension_type );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn client_hello_len<'a>(v: <ClientHelloCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn encrypted_extension_extension_data_len<'a>(v: <EncryptedExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16, extension_type: u16) -> (serialize_len: usize)
     requires
-        spec_client_hello().wf(v@),
-        spec_client_hello().spec_serialize(v@).len() <= usize::MAX,
+        spec_encrypted_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        serialize_len == spec_client_hello().spec_serialize(v@).len(),
+        serialize_len == spec_encrypted_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len(),
 {
-    let combinator = client_hello();
+    let combinator = encrypted_extension_extension_data( ext_len, extension_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
 
-pub struct SpecOpaque0Ff {
-    pub l: u8,
-    pub data: Seq<u8>,
+pub struct SpecEncryptedExtension {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: SpecEncryptedExtensionExtensionData,
 }
 
-pub type SpecOpaque0FfInner = (u8, Seq<u8>);
+pub type SpecEncryptedExtensionInner = ((u16, u16), SpecEncryptedExtensionExtensionData);
 
 
-impl SpecFrom<SpecOpaque0Ff> for SpecOpaque0FfInner {
-    open spec fn spec_from(m: SpecOpaque0Ff) -> SpecOpaque0FfInner {
-        (m.l, m.data)
+impl SpecFrom<SpecEncryptedExtension> for SpecEncryptedExtensionInner {
+    open spec fn spec_from(m: SpecEncryptedExtension) -> SpecEncryptedExtensionInner {
+        ((m.extension_type, m.ext_len), m.extension_data)
     }
 }
 
-impl SpecFrom<SpecOpaque0FfInner> for SpecOpaque0Ff {
-    open spec fn spec_from(m: SpecOpaque0FfInner) -> SpecOpaque0Ff {
-        let (l, data) = m;
-        SpecOpaque0Ff { l, data }
+impl SpecFrom<SpecEncryptedExtensionInner> for SpecEncryptedExtension {
+    open spec fn spec_from(m: SpecEncryptedExtensionInner) -> SpecEncryptedExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        SpecEncryptedExtension { extension_type, ext_len, extension_data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Opaque0Ff<'a> {
-    pub l: u8,
-    pub data: &'a [u8],
+pub struct EncryptedExtension<'a> {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: EncryptedExtensionExtensionData<'a>,
 }
 
-impl View for Opaque0Ff<'_> {
-    type V = SpecOpaque0Ff;
+impl View for EncryptedExtension<'_> {
+    type V = SpecEncryptedExtension;
 
     open spec fn view(&self) -> Self::V {
-        SpecOpaque0Ff {
-            l: self.l@,
-            data: self.data@,
+        SpecEncryptedExtension {
+            extension_type: self.extension_type@,
+            ext_len: self.ext_len@,
+            extension_data: self.extension_data@,
         }
     }
 }
-pub type Opaque0FfInner<'a> = (u8, &'a [u8]);
+pub type EncryptedExtensionInner<'a> = ((u16, u16), EncryptedExtensionExtensionData<'a>);
 
-pub type Opaque0FfInnerRef<'a> = (&'a u8, &'a &'a [u8]);
-impl<'a> From<&'a Opaque0Ff<'a>> for Opaque0FfInnerRef<'a> {
-    fn ex_from(m: &'a Opaque0Ff) -> Opaque0FfInnerRef<'a> {
-        (&m.l, &m.data)
+pub type EncryptedExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a EncryptedExtensionExtensionData<'a>);
+impl<'a> From<&'a EncryptedExtension<'a>> for EncryptedExtensionInnerRef<'a> {
+    fn ex_from(m: &'a EncryptedExtension) -> EncryptedExtensionInnerRef<'a> {
+        ((&m.extension_type, &m.ext_len), &m.extension_data)
     }
 }
 
-impl<'a> From<Opaque0FfInner<'a>> for Opaque0Ff<'a> {
-    fn ex_from(m: Opaque0FfInner) -> Opaque0Ff {
-        let (l, data) = m;
-        Opaque0Ff { l, data }
+impl<'a> From<EncryptedExtensionInner<'a>> for EncryptedExtension<'a> {
+    fn ex_from(m: EncryptedExtensionInner) -> EncryptedExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        EncryptedExtension { extension_type, ext_len, extension_data }
     }
 }
 
-pub struct Opaque0FfMapper;
-impl View for Opaque0FfMapper {
+pub struct EncryptedExtensionMapper;
+impl View for EncryptedExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for Opaque0FfMapper {
-    type Src = SpecOpaque0FfInner;
-    type Dst = SpecOpaque0Ff;
+impl SpecIso for EncryptedExtensionMapper {
+    type Src = SpecEncryptedExtensionInner;
+    type Dst = SpecEncryptedExtension;
 }
-impl SpecIsoProof for Opaque0FfMapper {
+impl SpecIsoProof for EncryptedExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -18135,296 +17297,293 @@ impl SpecIsoProof for Opaque0FfMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for Opaque0FfMapper {
-    type Src = Opaque0FfInner<'a>;
-    type Dst = Opaque0Ff<'a>;
-    type RefSrc = Opaque0FfInnerRef<'a>;
+impl<'a> Iso<'a> for EncryptedExtensionMapper {
+    type Src = EncryptedExtensionInner<'a>;
+    type Dst = EncryptedExtension<'a>;
+    type RefSrc = EncryptedExtensionInnerRef<'a>;
 }
 
-pub struct SpecOpaque0FfCombinator(pub SpecOpaque0FfCombinatorAlias);
+pub struct SpecEncryptedExtensionCombinator(pub SpecEncryptedExtensionCombinatorAlias);
 
-impl SpecCombinator for SpecOpaque0FfCombinator {
-    type Type = SpecOpaque0Ff;
+impl SpecCombinator for SpecEncryptedExtensionCombinator {
+    type Type = SpecEncryptedExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOpaque0FfCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOpaque0FfCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecEncryptedExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEncryptedExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOpaque0FfCombinatorAlias = Mapped<SpecPair<U8, bytes::Variable>, Opaque0FfMapper>;
+pub type SpecEncryptedExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecEncryptedExtensionExtensionDataCombinator>, EncryptedExtensionMapper>;
 
-pub struct Opaque0FfCombinator(pub Opaque0FfCombinatorAlias);
+pub struct EncryptedExtensionCombinator(pub EncryptedExtensionCombinatorAlias);
 
-impl View for Opaque0FfCombinator {
-    type V = SpecOpaque0FfCombinator;
-    open spec fn view(&self) -> Self::V { SpecOpaque0FfCombinator(self.0@) }
+impl View for EncryptedExtensionCombinator {
+    type V = SpecEncryptedExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecEncryptedExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque0FfCombinator {
-    type Type = Opaque0Ff<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EncryptedExtensionCombinator {
+    type Type = EncryptedExtension<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type Opaque0FfCombinatorAlias = Mapped<Pair<U8, bytes::Variable, Opaque0FfCont0>, Opaque0FfMapper>;
+}
+pub type EncryptedExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, EncryptedExtensionCont1>, EncryptedExtensionExtensionDataCombinator, EncryptedExtensionCont0>, EncryptedExtensionMapper>;
 
 
-pub open spec fn spec_opaque_0_ff() -> SpecOpaque0FfCombinator {
-    SpecOpaque0FfCombinator(
+pub open spec fn spec_encrypted_extension() -> SpecEncryptedExtensionCombinator {
+    SpecEncryptedExtensionCombinator(
     Mapped {
-        inner: Pair::spec_new(U8, |deps| spec_opaque0_ff_cont0(deps)),
-        mapper: Opaque0FfMapper,
+        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_encrypted_extension_cont1(deps)), |deps| spec_encrypted_extension_cont0(deps)),
+        mapper: EncryptedExtensionMapper,
     })
 }
 
-pub open spec fn spec_opaque0_ff_cont0(deps: u8) -> bytes::Variable {
-    let l = deps;
-    bytes::Variable(l.spec_into())
+pub open spec fn spec_encrypted_extension_cont1(deps: u16) -> U16Be {
+    let extension_type = deps;
+    U16Be
 }
 
-impl View for Opaque0FfCont0 {
-    type V = spec_fn(u8) -> bytes::Variable;
+impl View for EncryptedExtensionCont1 {
+    type V = spec_fn(u16) -> U16Be;
 
     open spec fn view(&self) -> Self::V {
-        |deps: u8| {
-            spec_opaque0_ff_cont0(deps)
+        |deps: u16| {
+            spec_encrypted_extension_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_encrypted_extension_cont0(deps: (u16, u16)) -> SpecEncryptedExtensionExtensionDataCombinator {
+    let (extension_type, ext_len) = deps;
+    spec_encrypted_extension_extension_data(ext_len, extension_type)
+}
+
+impl View for EncryptedExtensionCont0 {
+    type V = spec_fn((u16, u16)) -> SpecEncryptedExtensionExtensionDataCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u16, u16)| {
+            spec_encrypted_extension_cont0(deps)
         }
     }
 }
 
                 
-pub fn opaque_0_ff<'a>() -> (o: Opaque0FfCombinator)
-    ensures o@ == spec_opaque_0_ff(),
+pub fn encrypted_extension<'a>() -> (o: EncryptedExtensionCombinator)
+    ensures o@ == spec_encrypted_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = Opaque0FfCombinator(
+    let combinator = EncryptedExtensionCombinator(
     Mapped {
-        inner: Pair::new(U8, Opaque0FfCont0),
-        mapper: Opaque0FfMapper,
-    });
-    assert({
-        &&& combinator@ == spec_opaque_0_ff()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Pair::new(extension_type(), EncryptedExtensionCont1), EncryptedExtensionCont0),
+        mapper: EncryptedExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_encrypted_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_opaque_0_ff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque0FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_encrypted_extension<'a>(input: &'a [u8]) -> (res: PResult<<EncryptedExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_opaque_0_ff().spec_parse(input@) == Some((n as int, v@)),
-        spec_opaque_0_ff().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_encrypted_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_encrypted_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_opaque_0_ff().spec_parse(input@) is None,
-        spec_opaque_0_ff().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_encrypted_extension().spec_parse(input@) is None,
+        spec_encrypted_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = opaque_0_ff();
+    let combinator = encrypted_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_opaque_0_ff<'a>(v: <Opaque0FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_encrypted_extension<'a>(v: <EncryptedExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_opaque_0_ff().wf(v@),
+        spec_encrypted_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_opaque_0_ff().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_0_ff().spec_serialize(v@))
+            &&& n == spec_encrypted_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_encrypted_extension().spec_serialize(v@))
         },
 {
-    let combinator = opaque_0_ff();
+    let combinator = encrypted_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn opaque_0_ff_len<'a>(v: <Opaque0FfCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn encrypted_extension_len<'a>(v: <EncryptedExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_opaque_0_ff().wf(v@),
-        spec_opaque_0_ff().spec_serialize(v@).len() <= usize::MAX,
+        spec_encrypted_extension().wf(v@),
+        spec_encrypted_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_opaque_0_ff().spec_serialize(v@).len(),
+        serialize_len == spec_encrypted_extension().spec_serialize(v@).len(),
 {
-    let combinator = opaque_0_ff();
+    let combinator = encrypted_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct Opaque0FfCont0;
-type Opaque0FfCont0Type<'a, 'b> = &'b u8;
-type Opaque0FfCont0SType<'a, 'x> = &'x u8;
-type Opaque0FfCont0Input<'a, 'b, 'x> = POrSType<Opaque0FfCont0Type<'a, 'b>, Opaque0FfCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<Opaque0FfCont0Input<'a, 'b, 'x>> for Opaque0FfCont0 {
-    type Output = bytes::Variable;
+pub struct EncryptedExtensionCont1;
+type EncryptedExtensionCont1Type<'a, 'b> = &'b u16;
+type EncryptedExtensionCont1SType<'a, 'x> = &'x u16;
+type EncryptedExtensionCont1Input<'a, 'b, 'x> = POrSType<EncryptedExtensionCont1Type<'a, 'b>, EncryptedExtensionCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<EncryptedExtensionCont1Input<'a, 'b, 'x>> for EncryptedExtensionCont1 {
+    type Output = U16Be;
 
-    open spec fn requires(&self, deps: Opaque0FfCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: EncryptedExtensionCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_extension_type()).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: Opaque0FfCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_opaque0_ff_cont0(deps@)
+    open spec fn ensures(&self, deps: EncryptedExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_encrypted_extension_cont1(deps@)
     }
 
-    fn apply(&self, deps: Opaque0FfCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: EncryptedExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
             }
             POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                bytes::Variable(l.ex_into())
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
             }
         }
     }
 }
-                
-
-pub enum SpecCertificateRequestExtensionExtensionData {
-    SignatureAlgorithms(SpecSignatureSchemeList),
-    CertificateAuthorities(SpecCertificateAuthoritiesExtension),
-    SignatureAlgorithmsCert(SpecSignatureSchemeList),
-    StatusRequest(SpecCertificateStatusRequest),
-    SignedCertificateTimeStamp(SpecSignedCertificateTimestampList),
-    OidFilters(SpecOidFilterExtension),
-    Unrecognized(Seq<u8>),
-}
-
-pub type SpecCertificateRequestExtensionExtensionDataInner = Either<SpecSignatureSchemeList, Either<SpecCertificateAuthoritiesExtension, Either<SpecSignatureSchemeList, Either<SpecCertificateStatusRequest, Either<SpecSignedCertificateTimestampList, Either<SpecOidFilterExtension, Seq<u8>>>>>>>;
+pub struct EncryptedExtensionCont0;
+type EncryptedExtensionCont0Type<'a, 'b> = &'b (u16, u16);
+type EncryptedExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
+type EncryptedExtensionCont0Input<'a, 'b, 'x> = POrSType<EncryptedExtensionCont0Type<'a, 'b>, EncryptedExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<EncryptedExtensionCont0Input<'a, 'b, 'x>> for EncryptedExtensionCont0 {
+    type Output = EncryptedExtensionExtensionDataCombinator;
 
-impl SpecFrom<SpecCertificateRequestExtensionExtensionData> for SpecCertificateRequestExtensionExtensionDataInner {
-    open spec fn spec_from(m: SpecCertificateRequestExtensionExtensionData) -> SpecCertificateRequestExtensionExtensionDataInner {
-        match m {
-            SpecCertificateRequestExtensionExtensionData::SignatureAlgorithms(m) => Either::Left(m),
-            SpecCertificateRequestExtensionExtensionData::CertificateAuthorities(m) => Either::Right(Either::Left(m)),
-            SpecCertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecCertificateRequestExtensionExtensionData::StatusRequest(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            SpecCertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            SpecCertificateRequestExtensionExtensionData::OidFilters(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            SpecCertificateRequestExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
+    open spec fn requires(&self, deps: EncryptedExtensionCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_extension_type(), |deps| spec_encrypted_extension_cont1(deps))).wf(deps@)
         }
-    }
 
-}
+    open spec fn ensures(&self, deps: EncryptedExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_encrypted_extension_cont0(deps@)
+    }
 
-                
-impl SpecFrom<SpecCertificateRequestExtensionExtensionDataInner> for SpecCertificateRequestExtensionExtensionData {
-    open spec fn spec_from(m: SpecCertificateRequestExtensionExtensionDataInner) -> SpecCertificateRequestExtensionExtensionData {
-        match m {
-            Either::Left(m) => SpecCertificateRequestExtensionExtensionData::SignatureAlgorithms(m),
-            Either::Right(Either::Left(m)) => SpecCertificateRequestExtensionExtensionData::CertificateAuthorities(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecCertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecCertificateRequestExtensionExtensionData::StatusRequest(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecCertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecCertificateRequestExtensionExtensionData::OidFilters(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => SpecCertificateRequestExtensionExtensionData::Unrecognized(m),
+    fn apply(&self, deps: EncryptedExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                encrypted_extension_extension_data(ext_len, extension_type)
+            }
+            POrSType::S(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                encrypted_extension_extension_data(ext_len, extension_type)
+            }
         }
     }
+}
+                
 
+pub struct SpecEncryptedExtensions {
+    pub l: u16,
+    pub list: Seq<SpecEncryptedExtension>,
 }
 
+pub type SpecEncryptedExtensionsInner = (u16, Seq<SpecEncryptedExtension>);
 
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum CertificateRequestExtensionExtensionData<'a> {
-    SignatureAlgorithms(SignatureSchemeList),
-    CertificateAuthorities(CertificateAuthoritiesExtension<'a>),
-    SignatureAlgorithmsCert(SignatureSchemeList),
-    StatusRequest(CertificateStatusRequest<'a>),
-    SignedCertificateTimeStamp(SignedCertificateTimestampList<'a>),
-    OidFilters(OidFilterExtension<'a>),
-    Unrecognized(&'a [u8]),
+impl SpecFrom<SpecEncryptedExtensions> for SpecEncryptedExtensionsInner {
+    open spec fn spec_from(m: SpecEncryptedExtensions) -> SpecEncryptedExtensionsInner {
+        (m.l, m.list)
+    }
 }
 
-pub type CertificateRequestExtensionExtensionDataInner<'a> = Either<SignatureSchemeList, Either<CertificateAuthoritiesExtension<'a>, Either<SignatureSchemeList, Either<CertificateStatusRequest<'a>, Either<SignedCertificateTimestampList<'a>, Either<OidFilterExtension<'a>, &'a [u8]>>>>>>;
+impl SpecFrom<SpecEncryptedExtensionsInner> for SpecEncryptedExtensions {
+    open spec fn spec_from(m: SpecEncryptedExtensionsInner) -> SpecEncryptedExtensions {
+        let (l, list) = m;
+        SpecEncryptedExtensions { l, list }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub type CertificateRequestExtensionExtensionDataInnerRef<'a> = Either<&'a SignatureSchemeList, Either<&'a CertificateAuthoritiesExtension<'a>, Either<&'a SignatureSchemeList, Either<&'a CertificateStatusRequest<'a>, Either<&'a SignedCertificateTimestampList<'a>, Either<&'a OidFilterExtension<'a>, &'a &'a [u8]>>>>>>;
+pub struct EncryptedExtensions<'a> {
+    pub l: u16,
+    pub list: RepeatResult<EncryptedExtension<'a>>,
+}
 
+impl View for EncryptedExtensions<'_> {
+    type V = SpecEncryptedExtensions;
 
-impl<'a> View for CertificateRequestExtensionExtensionData<'a> {
-    type V = SpecCertificateRequestExtensionExtensionData;
     open spec fn view(&self) -> Self::V {
-        match self {
-            CertificateRequestExtensionExtensionData::SignatureAlgorithms(m) => SpecCertificateRequestExtensionExtensionData::SignatureAlgorithms(m@),
-            CertificateRequestExtensionExtensionData::CertificateAuthorities(m) => SpecCertificateRequestExtensionExtensionData::CertificateAuthorities(m@),
-            CertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m) => SpecCertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m@),
-            CertificateRequestExtensionExtensionData::StatusRequest(m) => SpecCertificateRequestExtensionExtensionData::StatusRequest(m@),
-            CertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m) => SpecCertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m@),
-            CertificateRequestExtensionExtensionData::OidFilters(m) => SpecCertificateRequestExtensionExtensionData::OidFilters(m@),
-            CertificateRequestExtensionExtensionData::Unrecognized(m) => SpecCertificateRequestExtensionExtensionData::Unrecognized(m@),
+        SpecEncryptedExtensions {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
+pub type EncryptedExtensionsInner<'a> = (u16, RepeatResult<EncryptedExtension<'a>>);
 
-
-impl<'a> From<&'a CertificateRequestExtensionExtensionData<'a>> for CertificateRequestExtensionExtensionDataInnerRef<'a> {
-    fn ex_from(m: &'a CertificateRequestExtensionExtensionData<'a>) -> CertificateRequestExtensionExtensionDataInnerRef<'a> {
-        match m {
-            CertificateRequestExtensionExtensionData::SignatureAlgorithms(m) => Either::Left(m),
-            CertificateRequestExtensionExtensionData::CertificateAuthorities(m) => Either::Right(Either::Left(m)),
-            CertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m) => Either::Right(Either::Right(Either::Left(m))),
-            CertificateRequestExtensionExtensionData::StatusRequest(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            CertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            CertificateRequestExtensionExtensionData::OidFilters(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            CertificateRequestExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
-        }
+pub type EncryptedExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<EncryptedExtension<'a>>);
+impl<'a> From<&'a EncryptedExtensions<'a>> for EncryptedExtensionsInnerRef<'a> {
+    fn ex_from(m: &'a EncryptedExtensions) -> EncryptedExtensionsInnerRef<'a> {
+        (&m.l, &m.list)
     }
-
 }
 
-impl<'a> From<CertificateRequestExtensionExtensionDataInner<'a>> for CertificateRequestExtensionExtensionData<'a> {
-    fn ex_from(m: CertificateRequestExtensionExtensionDataInner<'a>) -> CertificateRequestExtensionExtensionData<'a> {
-        match m {
-            Either::Left(m) => CertificateRequestExtensionExtensionData::SignatureAlgorithms(m),
-            Either::Right(Either::Left(m)) => CertificateRequestExtensionExtensionData::CertificateAuthorities(m),
-            Either::Right(Either::Right(Either::Left(m))) => CertificateRequestExtensionExtensionData::SignatureAlgorithmsCert(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => CertificateRequestExtensionExtensionData::StatusRequest(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => CertificateRequestExtensionExtensionData::SignedCertificateTimeStamp(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => CertificateRequestExtensionExtensionData::OidFilters(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => CertificateRequestExtensionExtensionData::Unrecognized(m),
-        }
+impl<'a> From<EncryptedExtensionsInner<'a>> for EncryptedExtensions<'a> {
+    fn ex_from(m: EncryptedExtensionsInner) -> EncryptedExtensions {
+        let (l, list) = m;
+        EncryptedExtensions { l, list }
     }
-    
 }
 
-
-pub struct CertificateRequestExtensionExtensionDataMapper;
-impl View for CertificateRequestExtensionExtensionDataMapper {
+pub struct EncryptedExtensionsMapper;
+impl View for EncryptedExtensionsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateRequestExtensionExtensionDataMapper {
-    type Src = SpecCertificateRequestExtensionExtensionDataInner;
-    type Dst = SpecCertificateRequestExtensionExtensionData;
+impl SpecIso for EncryptedExtensionsMapper {
+    type Src = SpecEncryptedExtensionsInner;
+    type Dst = SpecEncryptedExtensions;
 }
-impl SpecIsoProof for CertificateRequestExtensionExtensionDataMapper {
+impl SpecIsoProof for EncryptedExtensionsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -18432,245 +17591,245 @@ impl SpecIsoProof for CertificateRequestExtensionExtensionDataMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateRequestExtensionExtensionDataMapper {
-    type Src = CertificateRequestExtensionExtensionDataInner<'a>;
-    type Dst = CertificateRequestExtensionExtensionData<'a>;
-    type RefSrc = CertificateRequestExtensionExtensionDataInnerRef<'a>;
+impl<'a> Iso<'a> for EncryptedExtensionsMapper {
+    type Src = EncryptedExtensionsInner<'a>;
+    type Dst = EncryptedExtensions<'a>;
+    type RefSrc = EncryptedExtensionsInnerRef<'a>;
 }
 
-type SpecCertificateRequestExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecOidFilterExtensionCombinator>, Cond<bytes::Variable>>;
-type SpecCertificateRequestExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecSignedCertificateTimestampListCombinator>, SpecCertificateRequestExtensionExtensionDataCombinatorAlias1>;
-type SpecCertificateRequestExtensionExtensionDataCombinatorAlias3 = Choice<Cond<SpecCertificateStatusRequestCombinator>, SpecCertificateRequestExtensionExtensionDataCombinatorAlias2>;
-type SpecCertificateRequestExtensionExtensionDataCombinatorAlias4 = Choice<Cond<SpecSignatureSchemeListCombinator>, SpecCertificateRequestExtensionExtensionDataCombinatorAlias3>;
-type SpecCertificateRequestExtensionExtensionDataCombinatorAlias5 = Choice<Cond<SpecCertificateAuthoritiesExtensionCombinator>, SpecCertificateRequestExtensionExtensionDataCombinatorAlias4>;
-type SpecCertificateRequestExtensionExtensionDataCombinatorAlias6 = Choice<Cond<SpecSignatureSchemeListCombinator>, SpecCertificateRequestExtensionExtensionDataCombinatorAlias5>;
-pub struct SpecCertificateRequestExtensionExtensionDataCombinator(pub SpecCertificateRequestExtensionExtensionDataCombinatorAlias);
+pub struct SpecEncryptedExtensionsCombinator(pub SpecEncryptedExtensionsCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateRequestExtensionExtensionDataCombinator {
-    type Type = SpecCertificateRequestExtensionExtensionData;
+impl SpecCombinator for SpecEncryptedExtensionsCombinator {
+    type Type = SpecEncryptedExtensions;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateRequestExtensionExtensionDataCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateRequestExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecEncryptedExtensionsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEncryptedExtensionsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateRequestExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecCertificateRequestExtensionExtensionDataCombinatorAlias6, CertificateRequestExtensionExtensionDataMapper>>;
-type CertificateRequestExtensionExtensionDataCombinatorAlias1 = Choice<Cond<OidFilterExtensionCombinator>, Cond<bytes::Variable>>;
-type CertificateRequestExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SignedCertificateTimestampListCombinator>, CertificateRequestExtensionExtensionDataCombinator1>;
-type CertificateRequestExtensionExtensionDataCombinatorAlias3 = Choice<Cond<CertificateStatusRequestCombinator>, CertificateRequestExtensionExtensionDataCombinator2>;
-type CertificateRequestExtensionExtensionDataCombinatorAlias4 = Choice<Cond<SignatureSchemeListCombinator>, CertificateRequestExtensionExtensionDataCombinator3>;
-type CertificateRequestExtensionExtensionDataCombinatorAlias5 = Choice<Cond<CertificateAuthoritiesExtensionCombinator>, CertificateRequestExtensionExtensionDataCombinator4>;
-type CertificateRequestExtensionExtensionDataCombinatorAlias6 = Choice<Cond<SignatureSchemeListCombinator>, CertificateRequestExtensionExtensionDataCombinator5>;
-pub struct CertificateRequestExtensionExtensionDataCombinator1(pub CertificateRequestExtensionExtensionDataCombinatorAlias1);
-impl View for CertificateRequestExtensionExtensionDataCombinator1 {
-    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator1, CertificateRequestExtensionExtensionDataCombinatorAlias1);
-
-pub struct CertificateRequestExtensionExtensionDataCombinator2(pub CertificateRequestExtensionExtensionDataCombinatorAlias2);
-impl View for CertificateRequestExtensionExtensionDataCombinator2 {
-    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator2, CertificateRequestExtensionExtensionDataCombinatorAlias2);
-
-pub struct CertificateRequestExtensionExtensionDataCombinator3(pub CertificateRequestExtensionExtensionDataCombinatorAlias3);
-impl View for CertificateRequestExtensionExtensionDataCombinator3 {
-    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator3, CertificateRequestExtensionExtensionDataCombinatorAlias3);
-
-pub struct CertificateRequestExtensionExtensionDataCombinator4(pub CertificateRequestExtensionExtensionDataCombinatorAlias4);
-impl View for CertificateRequestExtensionExtensionDataCombinator4 {
-    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator4, CertificateRequestExtensionExtensionDataCombinatorAlias4);
-
-pub struct CertificateRequestExtensionExtensionDataCombinator5(pub CertificateRequestExtensionExtensionDataCombinatorAlias5);
-impl View for CertificateRequestExtensionExtensionDataCombinator5 {
-    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias5;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator5, CertificateRequestExtensionExtensionDataCombinatorAlias5);
-
-pub struct CertificateRequestExtensionExtensionDataCombinator6(pub CertificateRequestExtensionExtensionDataCombinatorAlias6);
-impl View for CertificateRequestExtensionExtensionDataCombinator6 {
-    type V = SpecCertificateRequestExtensionExtensionDataCombinatorAlias6;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateRequestExtensionExtensionDataCombinator6, CertificateRequestExtensionExtensionDataCombinatorAlias6);
+pub type SpecEncryptedExtensionsCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecEncryptedExtensionCombinator>>>, EncryptedExtensionsMapper>;
 
-pub struct CertificateRequestExtensionExtensionDataCombinator(pub CertificateRequestExtensionExtensionDataCombinatorAlias);
+pub struct EncryptedExtensionsCombinator(pub EncryptedExtensionsCombinatorAlias);
 
-impl View for CertificateRequestExtensionExtensionDataCombinator {
-    type V = SpecCertificateRequestExtensionExtensionDataCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateRequestExtensionExtensionDataCombinator(self.0@) }
+impl View for EncryptedExtensionsCombinator {
+    type V = SpecEncryptedExtensionsCombinator;
+    open spec fn view(&self) -> Self::V { SpecEncryptedExtensionsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateRequestExtensionExtensionDataCombinator {
-    type Type = CertificateRequestExtensionExtensionData<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EncryptedExtensionsCombinator {
+    type Type = EncryptedExtensions<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateRequestExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<CertificateRequestExtensionExtensionDataCombinator6, CertificateRequestExtensionExtensionDataMapper>>;
+}
+pub type EncryptedExtensionsCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<EncryptedExtensionCombinator>>, EncryptedExtensionsCont0>, EncryptedExtensionsMapper>;
 
 
-pub open spec fn spec_certificate_request_extension_extension_data(ext_len: u16, extension_type: u16) -> SpecCertificateRequestExtensionExtensionDataCombinator {
-    SpecCertificateRequestExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.spec_into()), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignatureAlgorithms, inner: spec_signature_scheme_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_CertificateAuthorities, inner: spec_certificate_authorities_extension() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignatureAlgorithmsCert, inner: spec_signature_scheme_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_StatusRequest, inner: spec_certificate_status_request() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp, inner: spec_signed_certificate_timestamp_list() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_OidFilters, inner: spec_oid_filter_extension() }, Cond { cond: !(extension_type == ExtensionType::SPEC_SignatureAlgorithms || extension_type == ExtensionType::SPEC_CertificateAuthorities || extension_type == ExtensionType::SPEC_SignatureAlgorithmsCert || extension_type == ExtensionType::SPEC_StatusRequest || extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp || extension_type == ExtensionType::SPEC_OidFilters), inner: bytes::Variable(ext_len.spec_into()) })))))), mapper: CertificateRequestExtensionExtensionDataMapper }))
+pub open spec fn spec_encrypted_extensions() -> SpecEncryptedExtensionsCombinator {
+    SpecEncryptedExtensionsCombinator(
+    Mapped {
+        inner: Pair::spec_new(U16Be, |deps| spec_encrypted_extensions_cont0(deps)),
+        mapper: EncryptedExtensionsMapper,
+    })
 }
 
-pub fn certificate_request_extension_extension_data<'a>(ext_len: u16, extension_type: u16) -> (o: CertificateRequestExtensionExtensionDataCombinator)
-    ensures o@ == spec_certificate_request_extension_extension_data(ext_len@, extension_type@),
+pub open spec fn spec_encrypted_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecEncryptedExtensionCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_encrypted_extension()))
+}
+
+impl View for EncryptedExtensionsCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecEncryptedExtensionCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_encrypted_extensions_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn encrypted_extensions<'a>() -> (o: EncryptedExtensionsCombinator)
+    ensures o@ == spec_encrypted_extensions(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateRequestExtensionExtensionDataCombinator(AndThen(bytes::Variable(ext_len.ex_into()), Mapped { inner: CertificateRequestExtensionExtensionDataCombinator6(Choice::new(Cond { cond: extension_type == ExtensionType::SignatureAlgorithms, inner: signature_scheme_list() }, CertificateRequestExtensionExtensionDataCombinator5(Choice::new(Cond { cond: extension_type == ExtensionType::CertificateAuthorities, inner: certificate_authorities_extension() }, CertificateRequestExtensionExtensionDataCombinator4(Choice::new(Cond { cond: extension_type == ExtensionType::SignatureAlgorithmsCert, inner: signature_scheme_list() }, CertificateRequestExtensionExtensionDataCombinator3(Choice::new(Cond { cond: extension_type == ExtensionType::StatusRequest, inner: certificate_status_request() }, CertificateRequestExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::SignedCertificateTimeStamp, inner: signed_certificate_timestamp_list() }, CertificateRequestExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::OidFilters, inner: oid_filter_extension() }, Cond { cond: !(extension_type == ExtensionType::SignatureAlgorithms || extension_type == ExtensionType::CertificateAuthorities || extension_type == ExtensionType::SignatureAlgorithmsCert || extension_type == ExtensionType::StatusRequest || extension_type == ExtensionType::SignedCertificateTimeStamp || extension_type == ExtensionType::OidFilters), inner: bytes::Variable(ext_len.ex_into()) })))))))))))), mapper: CertificateRequestExtensionExtensionDataMapper }));
-    assert({
-        &&& combinator@ == spec_certificate_request_extension_extension_data(ext_len@, extension_type@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = EncryptedExtensionsCombinator(
+    Mapped {
+        inner: Pair::new(U16Be, EncryptedExtensionsCont0),
+        mapper: EncryptedExtensionsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_encrypted_extensions()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_request_extension_extension_data<'a>(input: &'a [u8], ext_len: u16, extension_type: u16) -> (res: PResult<<CertificateRequestExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_encrypted_extensions<'a>(input: &'a [u8]) -> (res: PResult<<EncryptedExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_encrypted_extensions().spec_parse(input@) == Some((n as int, v@)),
+        spec_encrypted_extensions().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None,
-        spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_encrypted_extensions().spec_parse(input@) is None,
+        spec_encrypted_extensions().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_request_extension_extension_data( ext_len, extension_type );
+    let combinator = encrypted_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_request_extension_extension_data<'a>(v: <CertificateRequestExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16, extension_type: u16) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_encrypted_extensions<'a>(v: <EncryptedExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_request_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_encrypted_extensions().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@))
+            &&& n == spec_encrypted_extensions().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_encrypted_extensions().spec_serialize(v@))
         },
 {
-    let combinator = certificate_request_extension_extension_data( ext_len, extension_type );
-    combinator.serialize(v, data, pos)
-}
+    let combinator = encrypted_extensions();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
 
-pub fn certificate_request_extension_extension_data_len<'a>(v: <CertificateRequestExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16, extension_type: u16) -> (serialize_len: usize)
+pub fn encrypted_extensions_len<'a>(v: <EncryptedExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_request_extension_extension_data(ext_len@, extension_type@).wf(v@),
-        spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_encrypted_extensions().wf(v@),
+        spec_encrypted_extensions().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_request_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len(),
+        serialize_len == spec_encrypted_extensions().spec_serialize(v@).len(),
 {
-    let combinator = certificate_request_extension_extension_data( ext_len, extension_type );
+    let combinator = encrypted_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct EncryptedExtensionsCont0;
+type EncryptedExtensionsCont0Type<'a, 'b> = &'b u16;
+type EncryptedExtensionsCont0SType<'a, 'x> = &'x u16;
+type EncryptedExtensionsCont0Input<'a, 'b, 'x> = POrSType<EncryptedExtensionsCont0Type<'a, 'b>, EncryptedExtensionsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<EncryptedExtensionsCont0Input<'a, 'b, 'x>> for EncryptedExtensionsCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<EncryptedExtensionCombinator>>;
+
+    open spec fn requires(&self, deps: EncryptedExtensionsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U16Be).wf(deps@)
+        }
 
-pub struct SpecCertificateRequestExtension {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: SpecCertificateRequestExtensionExtensionData,
+    open spec fn ensures(&self, deps: EncryptedExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_encrypted_extensions_cont0(deps@)
+    }
+
+    fn apply(&self, deps: EncryptedExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(encrypted_extension()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(encrypted_extension()))
+            }
+        }
+    }
 }
+                
 
-pub type SpecCertificateRequestExtensionInner = ((u16, u16), SpecCertificateRequestExtensionExtensionData);
+pub struct SpecOpaque1Ffffff {
+    pub l: u24,
+    pub data: Seq<u8>,
+}
 
+pub type SpecOpaque1FfffffInner = (u24, Seq<u8>);
 
-impl SpecFrom<SpecCertificateRequestExtension> for SpecCertificateRequestExtensionInner {
-    open spec fn spec_from(m: SpecCertificateRequestExtension) -> SpecCertificateRequestExtensionInner {
-        ((m.extension_type, m.ext_len), m.extension_data)
+
+impl SpecFrom<SpecOpaque1Ffffff> for SpecOpaque1FfffffInner {
+    open spec fn spec_from(m: SpecOpaque1Ffffff) -> SpecOpaque1FfffffInner {
+        (m.l, m.data)
     }
 }
 
-impl SpecFrom<SpecCertificateRequestExtensionInner> for SpecCertificateRequestExtension {
-    open spec fn spec_from(m: SpecCertificateRequestExtensionInner) -> SpecCertificateRequestExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        SpecCertificateRequestExtension { extension_type, ext_len, extension_data }
+impl SpecFrom<SpecOpaque1FfffffInner> for SpecOpaque1Ffffff {
+    open spec fn spec_from(m: SpecOpaque1FfffffInner) -> SpecOpaque1Ffffff {
+        let (l, data) = m;
+        SpecOpaque1Ffffff { l, data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CertificateRequestExtension<'a> {
-    pub extension_type: u16,
-    pub ext_len: u16,
-    pub extension_data: CertificateRequestExtensionExtensionData<'a>,
+pub struct Opaque1Ffffff<'a> {
+    pub l: u24,
+    pub data: &'a [u8],
 }
 
-impl View for CertificateRequestExtension<'_> {
-    type V = SpecCertificateRequestExtension;
+impl View for Opaque1Ffffff<'_> {
+    type V = SpecOpaque1Ffffff;
 
     open spec fn view(&self) -> Self::V {
-        SpecCertificateRequestExtension {
-            extension_type: self.extension_type@,
-            ext_len: self.ext_len@,
-            extension_data: self.extension_data@,
+        SpecOpaque1Ffffff {
+            l: self.l@,
+            data: self.data@,
         }
     }
 }
-pub type CertificateRequestExtensionInner<'a> = ((u16, u16), CertificateRequestExtensionExtensionData<'a>);
+pub type Opaque1FfffffInner<'a> = (u24, &'a [u8]);
 
-pub type CertificateRequestExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a CertificateRequestExtensionExtensionData<'a>);
-impl<'a> From<&'a CertificateRequestExtension<'a>> for CertificateRequestExtensionInnerRef<'a> {
-    fn ex_from(m: &'a CertificateRequestExtension) -> CertificateRequestExtensionInnerRef<'a> {
-        ((&m.extension_type, &m.ext_len), &m.extension_data)
+pub type Opaque1FfffffInnerRef<'a> = (&'a u24, &'a &'a [u8]);
+impl<'a> From<&'a Opaque1Ffffff<'a>> for Opaque1FfffffInnerRef<'a> {
+    fn ex_from(m: &'a Opaque1Ffffff) -> Opaque1FfffffInnerRef<'a> {
+        (&m.l, &m.data)
     }
 }
 
-impl<'a> From<CertificateRequestExtensionInner<'a>> for CertificateRequestExtension<'a> {
-    fn ex_from(m: CertificateRequestExtensionInner) -> CertificateRequestExtension {
-        let ((extension_type, ext_len), extension_data) = m;
-        CertificateRequestExtension { extension_type, ext_len, extension_data }
+impl<'a> From<Opaque1FfffffInner<'a>> for Opaque1Ffffff<'a> {
+    fn ex_from(m: Opaque1FfffffInner) -> Opaque1Ffffff {
+        let (l, data) = m;
+        Opaque1Ffffff { l, data }
     }
 }
 
-pub struct CertificateRequestExtensionMapper;
-impl View for CertificateRequestExtensionMapper {
+pub struct Opaque1FfffffMapper;
+impl View for Opaque1FfffffMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateRequestExtensionMapper {
-    type Src = SpecCertificateRequestExtensionInner;
-    type Dst = SpecCertificateRequestExtension;
+impl SpecIso for Opaque1FfffffMapper {
+    type Src = SpecOpaque1FfffffInner;
+    type Dst = SpecOpaque1Ffffff;
 }
-impl SpecIsoProof for CertificateRequestExtensionMapper {
+impl SpecIsoProof for Opaque1FfffffMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -18678,525 +17837,383 @@ impl SpecIsoProof for CertificateRequestExtensionMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateRequestExtensionMapper {
-    type Src = CertificateRequestExtensionInner<'a>;
-    type Dst = CertificateRequestExtension<'a>;
-    type RefSrc = CertificateRequestExtensionInnerRef<'a>;
+impl<'a> Iso<'a> for Opaque1FfffffMapper {
+    type Src = Opaque1FfffffInner<'a>;
+    type Dst = Opaque1Ffffff<'a>;
+    type RefSrc = Opaque1FfffffInnerRef<'a>;
 }
 
-pub struct SpecCertificateRequestExtensionCombinator(pub SpecCertificateRequestExtensionCombinatorAlias);
+pub struct SpecOpaque1FfffffCombinator(pub SpecOpaque1FfffffCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateRequestExtensionCombinator {
-    type Type = SpecCertificateRequestExtension;
+impl SpecCombinator for SpecOpaque1FfffffCombinator {
+    type Type = SpecOpaque1Ffffff;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateRequestExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateRequestExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOpaque1FfffffCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOpaque1FfffffCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateRequestExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecCertificateRequestExtensionExtensionDataCombinator>, CertificateRequestExtensionMapper>;
+pub type SpecOpaque1FfffffCombinatorAlias = Mapped<SpecPair<Refined<U24Be, Predicate15036445817960576151>, bytes::Variable>, Opaque1FfffffMapper>;
+pub struct Predicate15036445817960576151;
+impl View for Predicate15036445817960576151 {
+    type V = Self;
 
-pub struct CertificateRequestExtensionCombinator(pub CertificateRequestExtensionCombinatorAlias);
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u24> for Predicate15036445817960576151 {
+    fn apply(&self, i: &u24) -> bool {
+        let i = (*i).as_u32();
+        (i >= 1 && i <= 16777215)
+    }
+}
+impl SpecPred<u24> for Predicate15036445817960576151 {
+    open spec fn spec_apply(&self, i: &u24) -> bool {
+        let i = (*i).spec_as_u32();
+        (i >= 1 && i <= 16777215)
+    }
+}
 
-impl View for CertificateRequestExtensionCombinator {
-    type V = SpecCertificateRequestExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateRequestExtensionCombinator(self.0@) }
+pub struct Opaque1FfffffCombinator(pub Opaque1FfffffCombinatorAlias);
+
+impl View for Opaque1FfffffCombinator {
+    type V = SpecOpaque1FfffffCombinator;
+    open spec fn view(&self) -> Self::V { SpecOpaque1FfffffCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateRequestExtensionCombinator {
-    type Type = CertificateRequestExtension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque1FfffffCombinator {
+    type Type = Opaque1Ffffff<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateRequestExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, CertificateRequestExtensionCont1>, CertificateRequestExtensionExtensionDataCombinator, CertificateRequestExtensionCont0>, CertificateRequestExtensionMapper>;
+}
+pub type Opaque1FfffffCombinatorAlias = Mapped<Pair<Refined<U24Be, Predicate15036445817960576151>, bytes::Variable, Opaque1FfffffCont0>, Opaque1FfffffMapper>;
 
 
-pub open spec fn spec_certificate_request_extension() -> SpecCertificateRequestExtensionCombinator {
-    SpecCertificateRequestExtensionCombinator(
+pub open spec fn spec_opaque_1_ffffff() -> SpecOpaque1FfffffCombinator {
+    SpecOpaque1FfffffCombinator(
     Mapped {
-        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_certificate_request_extension_cont1(deps)), |deps| spec_certificate_request_extension_cont0(deps)),
-        mapper: CertificateRequestExtensionMapper,
+        inner: Pair::spec_new(Refined { inner: U24Be, predicate: Predicate15036445817960576151 }, |deps| spec_opaque1_ffffff_cont0(deps)),
+        mapper: Opaque1FfffffMapper,
     })
 }
 
-pub open spec fn spec_certificate_request_extension_cont1(deps: u16) -> U16Be {
-    let extension_type = deps;
-    U16Be
-}
-
-impl View for CertificateRequestExtensionCont1 {
-    type V = spec_fn(u16) -> U16Be;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_certificate_request_extension_cont1(deps)
-        }
-    }
-}
-
-pub open spec fn spec_certificate_request_extension_cont0(deps: (u16, u16)) -> SpecCertificateRequestExtensionExtensionDataCombinator {
-    let (extension_type, ext_len) = deps;
-    spec_certificate_request_extension_extension_data(ext_len, extension_type)
+pub open spec fn spec_opaque1_ffffff_cont0(deps: u24) -> bytes::Variable {
+    let l = deps;
+    bytes::Variable((usize::spec_from(l)) as usize)
 }
 
-impl View for CertificateRequestExtensionCont0 {
-    type V = spec_fn((u16, u16)) -> SpecCertificateRequestExtensionExtensionDataCombinator;
+impl View for Opaque1FfffffCont0 {
+    type V = spec_fn(u24) -> bytes::Variable;
 
     open spec fn view(&self) -> Self::V {
-        |deps: (u16, u16)| {
-            spec_certificate_request_extension_cont0(deps)
+        |deps: u24| {
+            spec_opaque1_ffffff_cont0(deps)
         }
     }
 }
 
                 
-pub fn certificate_request_extension<'a>() -> (o: CertificateRequestExtensionCombinator)
-    ensures o@ == spec_certificate_request_extension(),
+pub fn opaque_1_ffffff<'a>() -> (o: Opaque1FfffffCombinator)
+    ensures o@ == spec_opaque_1_ffffff(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateRequestExtensionCombinator(
+    let combinator = Opaque1FfffffCombinator(
     Mapped {
-        inner: Pair::new(Pair::new(extension_type(), CertificateRequestExtensionCont1), CertificateRequestExtensionCont0),
-        mapper: CertificateRequestExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_request_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U24Be, predicate: Predicate15036445817960576151 }, Opaque1FfffffCont0),
+        mapper: Opaque1FfffffMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_opaque_1_ffffff()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_request_extension<'a>(input: &'a [u8]) -> (res: PResult<<CertificateRequestExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_opaque_1_ffffff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque1FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_request_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_request_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_opaque_1_ffffff().spec_parse(input@) == Some((n as int, v@)),
+        spec_opaque_1_ffffff().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_request_extension().spec_parse(input@) is None,
-        spec_certificate_request_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_opaque_1_ffffff().spec_parse(input@) is None,
+        spec_opaque_1_ffffff().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_request_extension();
+    let combinator = opaque_1_ffffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_request_extension<'a>(v: <CertificateRequestExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_opaque_1_ffffff<'a>(v: <Opaque1FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_request_extension().wf(v@),
+        spec_opaque_1_ffffff().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_request_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_request_extension().spec_serialize(v@))
+            &&& n == spec_opaque_1_ffffff().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_1_ffffff().spec_serialize(v@))
         },
 {
-    let combinator = certificate_request_extension();
+    let combinator = opaque_1_ffffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_request_extension_len<'a>(v: <CertificateRequestExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn opaque_1_ffffff_len<'a>(v: <Opaque1FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_request_extension().wf(v@),
-        spec_certificate_request_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_opaque_1_ffffff().wf(v@),
+        spec_opaque_1_ffffff().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_request_extension().spec_serialize(v@).len(),
+        serialize_len == spec_opaque_1_ffffff().spec_serialize(v@).len(),
 {
-    let combinator = certificate_request_extension();
+    let combinator = opaque_1_ffffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct CertificateRequestExtensionCont1;
-type CertificateRequestExtensionCont1Type<'a, 'b> = &'b u16;
-type CertificateRequestExtensionCont1SType<'a, 'x> = &'x u16;
-type CertificateRequestExtensionCont1Input<'a, 'b, 'x> = POrSType<CertificateRequestExtensionCont1Type<'a, 'b>, CertificateRequestExtensionCont1SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CertificateRequestExtensionCont1Input<'a, 'b, 'x>> for CertificateRequestExtensionCont1 {
-    type Output = U16Be;
+pub struct Opaque1FfffffCont0;
+type Opaque1FfffffCont0Type<'a, 'b> = &'b u24;
+type Opaque1FfffffCont0SType<'a, 'x> = &'x u24;
+type Opaque1FfffffCont0Input<'a, 'b, 'x> = POrSType<Opaque1FfffffCont0Type<'a, 'b>, Opaque1FfffffCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Opaque1FfffffCont0Input<'a, 'b, 'x>> for Opaque1FfffffCont0 {
+    type Output = bytes::Variable;
 
-    open spec fn requires(&self, deps: CertificateRequestExtensionCont1Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: CertificateRequestExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_certificate_request_extension_cont1(deps@)
-    }
-
-    fn apply(&self, deps: CertificateRequestExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let extension_type = *deps;
-                U16Be
-            }
-            POrSType::S(deps) => {
-                let extension_type = deps;
-                let extension_type = *extension_type;
-                U16Be
-            }
+    open spec fn requires(&self, deps: Opaque1FfffffCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U24Be, predicate: Predicate15036445817960576151 }).wf(deps@)
         }
-    }
-}
-pub struct CertificateRequestExtensionCont0;
-type CertificateRequestExtensionCont0Type<'a, 'b> = &'b (u16, u16);
-type CertificateRequestExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
-type CertificateRequestExtensionCont0Input<'a, 'b, 'x> = POrSType<CertificateRequestExtensionCont0Type<'a, 'b>, CertificateRequestExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CertificateRequestExtensionCont0Input<'a, 'b, 'x>> for CertificateRequestExtensionCont0 {
-    type Output = CertificateRequestExtensionExtensionDataCombinator;
 
-    open spec fn requires(&self, deps: CertificateRequestExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: CertificateRequestExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_certificate_request_extension_cont0(deps@)
+    open spec fn ensures(&self, deps: Opaque1FfffffCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_opaque1_ffffff_cont0(deps@)
     }
 
-    fn apply(&self, deps: CertificateRequestExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: Opaque1FfffffCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let (extension_type, ext_len) = *deps;
-                certificate_request_extension_extension_data(ext_len, extension_type)
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
-                let (extension_type, ext_len) = deps;
-                let (extension_type, ext_len) = (*extension_type, *ext_len);
-                certificate_request_extension_extension_data(ext_len, extension_type)
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
+pub type SpecOcspResponse = SpecOpaque1Ffffff;
+pub type OcspResponse<'a> = Opaque1Ffffff<'a>;
+pub type OcspResponseRef<'a> = &'a Opaque1Ffffff<'a>;
 
-pub struct SpecCertificateRequestExtensions {
-    pub l: u16,
-    pub list: Seq<SpecCertificateRequestExtension>,
-}
-
-pub type SpecCertificateRequestExtensionsInner = (u16, Seq<SpecCertificateRequestExtension>);
-
-
-impl SpecFrom<SpecCertificateRequestExtensions> for SpecCertificateRequestExtensionsInner {
-    open spec fn spec_from(m: SpecCertificateRequestExtensions) -> SpecCertificateRequestExtensionsInner {
-        (m.l, m.list)
-    }
-}
-
-impl SpecFrom<SpecCertificateRequestExtensionsInner> for SpecCertificateRequestExtensions {
-    open spec fn spec_from(m: SpecCertificateRequestExtensionsInner) -> SpecCertificateRequestExtensions {
-        let (l, list) = m;
-        SpecCertificateRequestExtensions { l, list }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct CertificateRequestExtensions<'a> {
-    pub l: u16,
-    pub list: RepeatResult<CertificateRequestExtension<'a>>,
-}
-
-impl View for CertificateRequestExtensions<'_> {
-    type V = SpecCertificateRequestExtensions;
-
-    open spec fn view(&self) -> Self::V {
-        SpecCertificateRequestExtensions {
-            l: self.l@,
-            list: self.list@,
-        }
-    }
-}
-pub type CertificateRequestExtensionsInner<'a> = (u16, RepeatResult<CertificateRequestExtension<'a>>);
-
-pub type CertificateRequestExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<CertificateRequestExtension<'a>>);
-impl<'a> From<&'a CertificateRequestExtensions<'a>> for CertificateRequestExtensionsInnerRef<'a> {
-    fn ex_from(m: &'a CertificateRequestExtensions) -> CertificateRequestExtensionsInnerRef<'a> {
-        (&m.l, &m.list)
-    }
-}
-
-impl<'a> From<CertificateRequestExtensionsInner<'a>> for CertificateRequestExtensions<'a> {
-    fn ex_from(m: CertificateRequestExtensionsInner) -> CertificateRequestExtensions {
-        let (l, list) = m;
-        CertificateRequestExtensions { l, list }
-    }
-}
-
-pub struct CertificateRequestExtensionsMapper;
-impl View for CertificateRequestExtensionsMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for CertificateRequestExtensionsMapper {
-    type Src = SpecCertificateRequestExtensionsInner;
-    type Dst = SpecCertificateRequestExtensions;
-}
-impl SpecIsoProof for CertificateRequestExtensionsMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for CertificateRequestExtensionsMapper {
-    type Src = CertificateRequestExtensionsInner<'a>;
-    type Dst = CertificateRequestExtensions<'a>;
-    type RefSrc = CertificateRequestExtensionsInnerRef<'a>;
-}
 
-pub struct SpecCertificateRequestExtensionsCombinator(pub SpecCertificateRequestExtensionsCombinatorAlias);
+pub struct SpecOcspResponseCombinator(pub SpecOcspResponseCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateRequestExtensionsCombinator {
-    type Type = SpecCertificateRequestExtensions;
+impl SpecCombinator for SpecOcspResponseCombinator {
+    type Type = SpecOcspResponse;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateRequestExtensionsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateRequestExtensionsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOcspResponseCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOcspResponseCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateRequestExtensionsCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<SpecCertificateRequestExtensionCombinator>>>, CertificateRequestExtensionsMapper>;
+pub type SpecOcspResponseCombinatorAlias = SpecOpaque1FfffffCombinator;
 
-pub struct CertificateRequestExtensionsCombinator(pub CertificateRequestExtensionsCombinatorAlias);
+pub struct OcspResponseCombinator(pub OcspResponseCombinatorAlias);
 
-impl View for CertificateRequestExtensionsCombinator {
-    type V = SpecCertificateRequestExtensionsCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateRequestExtensionsCombinator(self.0@) }
+impl View for OcspResponseCombinator {
+    type V = SpecOcspResponseCombinator;
+    open spec fn view(&self) -> Self::V { SpecOcspResponseCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateRequestExtensionsCombinator {
-    type Type = CertificateRequestExtensions<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for OcspResponseCombinator {
+    type Type = OcspResponse<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateRequestExtensionsCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<CertificateRequestExtensionCombinator>>, CertificateRequestExtensionsCont0>, CertificateRequestExtensionsMapper>;
-
-
-pub open spec fn spec_certificate_request_extensions() -> SpecCertificateRequestExtensionsCombinator {
-    SpecCertificateRequestExtensionsCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, |deps| spec_certificate_request_extensions_cont0(deps)),
-        mapper: CertificateRequestExtensionsMapper,
-    })
-}
-
-pub open spec fn spec_certificate_request_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecCertificateRequestExtensionCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_certificate_request_extension()))
 }
+pub type OcspResponseCombinatorAlias = Opaque1FfffffCombinator;
 
-impl View for CertificateRequestExtensionsCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecCertificateRequestExtensionCombinator>>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_certificate_request_extensions_cont0(deps)
-        }
-    }
+pub open spec fn spec_ocsp_response() -> SpecOcspResponseCombinator {
+    SpecOcspResponseCombinator(spec_opaque_1_ffffff())
 }
 
                 
-pub fn certificate_request_extensions<'a>() -> (o: CertificateRequestExtensionsCombinator)
-    ensures o@ == spec_certificate_request_extensions(),
+pub fn ocsp_response<'a>() -> (o: OcspResponseCombinator)
+    ensures o@ == spec_ocsp_response(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateRequestExtensionsCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, CertificateRequestExtensionsCont0),
-        mapper: CertificateRequestExtensionsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_request_extensions()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = OcspResponseCombinator(opaque_1_ffffff());
+    // assert({
+    //     &&& combinator@ == spec_ocsp_response()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_request_extensions<'a>(input: &'a [u8]) -> (res: PResult<<CertificateRequestExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_ocsp_response<'a>(input: &'a [u8]) -> (res: PResult<<OcspResponseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_request_extensions().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_request_extensions().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_ocsp_response().spec_parse(input@) == Some((n as int, v@)),
+        spec_ocsp_response().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_request_extensions().spec_parse(input@) is None,
-        spec_certificate_request_extensions().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_ocsp_response().spec_parse(input@) is None,
+        spec_ocsp_response().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_request_extensions();
+    let combinator = ocsp_response();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_request_extensions<'a>(v: <CertificateRequestExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_ocsp_response<'a>(v: <OcspResponseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_request_extensions().wf(v@),
+        spec_ocsp_response().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_request_extensions().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_request_extensions().spec_serialize(v@))
+            &&& n == spec_ocsp_response().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_ocsp_response().spec_serialize(v@))
         },
 {
-    let combinator = certificate_request_extensions();
+    let combinator = ocsp_response();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_request_extensions_len<'a>(v: <CertificateRequestExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn ocsp_response_len<'a>(v: <OcspResponseCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_request_extensions().wf(v@),
-        spec_certificate_request_extensions().spec_serialize(v@).len() <= usize::MAX,
+        spec_ocsp_response().wf(v@),
+        spec_ocsp_response().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_request_extensions().spec_serialize(v@).len(),
+        serialize_len == spec_ocsp_response().spec_serialize(v@).len(),
 {
-    let combinator = certificate_request_extensions();
+    let combinator = ocsp_response();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct CertificateRequestExtensionsCont0;
-type CertificateRequestExtensionsCont0Type<'a, 'b> = &'b u16;
-type CertificateRequestExtensionsCont0SType<'a, 'x> = &'x u16;
-type CertificateRequestExtensionsCont0Input<'a, 'b, 'x> = POrSType<CertificateRequestExtensionsCont0Type<'a, 'b>, CertificateRequestExtensionsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CertificateRequestExtensionsCont0Input<'a, 'b, 'x>> for CertificateRequestExtensionsCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<CertificateRequestExtensionCombinator>>;
-
-    open spec fn requires(&self, deps: CertificateRequestExtensionsCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: CertificateRequestExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_certificate_request_extensions_cont0(deps@)
-    }
-
-    fn apply(&self, deps: CertificateRequestExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(certificate_request_extension()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(certificate_request_extension()))
-            }
-        }
-    }
-}
                 
 
-pub struct SpecCertificateRequest {
-    pub certificate_request_context: SpecOpaque0Ff,
-    pub extensions: SpecCertificateRequestExtensions,
+pub struct SpecCertificateStatus {
+    pub status_type: u8,
+    pub response: SpecOcspResponse,
 }
 
-pub type SpecCertificateRequestInner = (SpecOpaque0Ff, SpecCertificateRequestExtensions);
+pub type SpecCertificateStatusInner = (u8, SpecOcspResponse);
 
 
-impl SpecFrom<SpecCertificateRequest> for SpecCertificateRequestInner {
-    open spec fn spec_from(m: SpecCertificateRequest) -> SpecCertificateRequestInner {
-        (m.certificate_request_context, m.extensions)
+impl SpecFrom<SpecCertificateStatus> for SpecCertificateStatusInner {
+    open spec fn spec_from(m: SpecCertificateStatus) -> SpecCertificateStatusInner {
+        (m.status_type, m.response)
     }
 }
 
-impl SpecFrom<SpecCertificateRequestInner> for SpecCertificateRequest {
-    open spec fn spec_from(m: SpecCertificateRequestInner) -> SpecCertificateRequest {
-        let (certificate_request_context, extensions) = m;
-        SpecCertificateRequest { certificate_request_context, extensions }
+impl SpecFrom<SpecCertificateStatusInner> for SpecCertificateStatus {
+    open spec fn spec_from(m: SpecCertificateStatusInner) -> SpecCertificateStatus {
+        let (status_type, response) = m;
+        SpecCertificateStatus { status_type, response }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CertificateRequest<'a> {
-    pub certificate_request_context: Opaque0Ff<'a>,
-    pub extensions: CertificateRequestExtensions<'a>,
+pub struct CertificateStatus<'a> {
+    pub status_type: u8,
+    pub response: OcspResponse<'a>,
 }
 
-impl View for CertificateRequest<'_> {
-    type V = SpecCertificateRequest;
+impl View for CertificateStatus<'_> {
+    type V = SpecCertificateStatus;
 
     open spec fn view(&self) -> Self::V {
-        SpecCertificateRequest {
-            certificate_request_context: self.certificate_request_context@,
-            extensions: self.extensions@,
+        SpecCertificateStatus {
+            status_type: self.status_type@,
+            response: self.response@,
         }
     }
 }
-pub type CertificateRequestInner<'a> = (Opaque0Ff<'a>, CertificateRequestExtensions<'a>);
+pub type CertificateStatusInner<'a> = (u8, OcspResponse<'a>);
 
-pub type CertificateRequestInnerRef<'a> = (&'a Opaque0Ff<'a>, &'a CertificateRequestExtensions<'a>);
-impl<'a> From<&'a CertificateRequest<'a>> for CertificateRequestInnerRef<'a> {
-    fn ex_from(m: &'a CertificateRequest) -> CertificateRequestInnerRef<'a> {
-        (&m.certificate_request_context, &m.extensions)
+pub type CertificateStatusInnerRef<'a> = (&'a u8, &'a OcspResponse<'a>);
+impl<'a> From<&'a CertificateStatus<'a>> for CertificateStatusInnerRef<'a> {
+    fn ex_from(m: &'a CertificateStatus) -> CertificateStatusInnerRef<'a> {
+        (&m.status_type, &m.response)
     }
 }
 
-impl<'a> From<CertificateRequestInner<'a>> for CertificateRequest<'a> {
-    fn ex_from(m: CertificateRequestInner) -> CertificateRequest {
-        let (certificate_request_context, extensions) = m;
-        CertificateRequest { certificate_request_context, extensions }
+impl<'a> From<CertificateStatusInner<'a>> for CertificateStatus<'a> {
+    fn ex_from(m: CertificateStatusInner) -> CertificateStatus {
+        let (status_type, response) = m;
+        CertificateStatus { status_type, response }
     }
 }
 
-pub struct CertificateRequestMapper;
-impl View for CertificateRequestMapper {
+pub struct CertificateStatusMapper;
+impl View for CertificateStatusMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateRequestMapper {
-    type Src = SpecCertificateRequestInner;
-    type Dst = SpecCertificateRequest;
+impl SpecIso for CertificateStatusMapper {
+    type Src = SpecCertificateStatusInner;
+    type Dst = SpecCertificateStatus;
 }
-impl SpecIsoProof for CertificateRequestMapper {
+impl SpecIsoProof for CertificateStatusMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -19204,206 +18221,234 @@ impl SpecIsoProof for CertificateRequestMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateRequestMapper {
-    type Src = CertificateRequestInner<'a>;
-    type Dst = CertificateRequest<'a>;
-    type RefSrc = CertificateRequestInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateStatusMapper {
+    type Src = CertificateStatusInner<'a>;
+    type Dst = CertificateStatus<'a>;
+    type RefSrc = CertificateStatusInnerRef<'a>;
 }
-type SpecCertificateRequestCombinatorAlias1 = (SpecOpaque0FfCombinator, SpecCertificateRequestExtensionsCombinator);
-pub struct SpecCertificateRequestCombinator(pub SpecCertificateRequestCombinatorAlias);
+pub const CERTIFICATESTATUSSTATUS_TYPE_CONST: u8 = 1;
+type SpecCertificateStatusCombinatorAlias1 = (Refined<U8, TagPred<u8>>, SpecOcspResponseCombinator);
+pub struct SpecCertificateStatusCombinator(pub SpecCertificateStatusCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateRequestCombinator {
-    type Type = SpecCertificateRequest;
+impl SpecCombinator for SpecCertificateStatusCombinator {
+    type Type = SpecCertificateStatus;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateRequestCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateRequestCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateStatusCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateStatusCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateRequestCombinatorAlias = Mapped<SpecCertificateRequestCombinatorAlias1, CertificateRequestMapper>;
-type CertificateRequestCombinatorAlias1 = (Opaque0FfCombinator, CertificateRequestExtensionsCombinator);
-pub struct CertificateRequestCombinator1(pub CertificateRequestCombinatorAlias1);
-impl View for CertificateRequestCombinator1 {
-    type V = SpecCertificateRequestCombinatorAlias1;
+pub type SpecCertificateStatusCombinatorAlias = Mapped<SpecCertificateStatusCombinatorAlias1, CertificateStatusMapper>;
+type CertificateStatusCombinatorAlias1 = (Refined<U8, TagPred<u8>>, OcspResponseCombinator);
+pub struct CertificateStatusCombinator1(pub CertificateStatusCombinatorAlias1);
+impl View for CertificateStatusCombinator1 {
+    type V = SpecCertificateStatusCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(CertificateRequestCombinator1, CertificateRequestCombinatorAlias1);
+impl_wrapper_combinator!(CertificateStatusCombinator1, CertificateStatusCombinatorAlias1);
 
-pub struct CertificateRequestCombinator(pub CertificateRequestCombinatorAlias);
+pub struct CertificateStatusCombinator(pub CertificateStatusCombinatorAlias);
 
-impl View for CertificateRequestCombinator {
-    type V = SpecCertificateRequestCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateRequestCombinator(self.0@) }
+impl View for CertificateStatusCombinator {
+    type V = SpecCertificateStatusCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateStatusCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateRequestCombinator {
-    type Type = CertificateRequest<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateStatusCombinator {
+    type Type = CertificateStatus<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateRequestCombinatorAlias = Mapped<CertificateRequestCombinator1, CertificateRequestMapper>;
+}
+pub type CertificateStatusCombinatorAlias = Mapped<CertificateStatusCombinator1, CertificateStatusMapper>;
 
 
-pub open spec fn spec_certificate_request() -> SpecCertificateRequestCombinator {
-    SpecCertificateRequestCombinator(
+pub open spec fn spec_certificate_status() -> SpecCertificateStatusCombinator {
+    SpecCertificateStatusCombinator(
     Mapped {
-        inner: (spec_opaque_0_ff(), spec_certificate_request_extensions()),
-        mapper: CertificateRequestMapper,
+        inner: (Refined { inner: U8, predicate: TagPred(CERTIFICATESTATUSSTATUS_TYPE_CONST) }, spec_ocsp_response()),
+        mapper: CertificateStatusMapper,
     })
 }
 
                 
-pub fn certificate_request<'a>() -> (o: CertificateRequestCombinator)
-    ensures o@ == spec_certificate_request(),
+pub fn certificate_status<'a>() -> (o: CertificateStatusCombinator)
+    ensures o@ == spec_certificate_status(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateRequestCombinator(
+    let combinator = CertificateStatusCombinator(
     Mapped {
-        inner: CertificateRequestCombinator1((opaque_0_ff(), certificate_request_extensions())),
-        mapper: CertificateRequestMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_request()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: CertificateStatusCombinator1((Refined { inner: U8, predicate: TagPred(CERTIFICATESTATUSSTATUS_TYPE_CONST) }, ocsp_response())),
+        mapper: CertificateStatusMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_status()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_request<'a>(input: &'a [u8]) -> (res: PResult<<CertificateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_status<'a>(input: &'a [u8]) -> (res: PResult<<CertificateStatusCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_request().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_request().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_status().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_status().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_request().spec_parse(input@) is None,
-        spec_certificate_request().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_status().spec_parse(input@) is None,
+        spec_certificate_status().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_request();
+    let combinator = certificate_status();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_request<'a>(v: <CertificateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_status<'a>(v: <CertificateStatusCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_request().wf(v@),
+        spec_certificate_status().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_request().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_request().spec_serialize(v@))
+            &&& n == spec_certificate_status().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_status().spec_serialize(v@))
         },
 {
-    let combinator = certificate_request();
+    let combinator = certificate_status();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_request_len<'a>(v: <CertificateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_status_len<'a>(v: <CertificateStatusCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_request().wf(v@),
-        spec_certificate_request().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_status().wf(v@),
+        spec_certificate_status().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_request().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_status().spec_serialize(v@).len(),
 {
-    let combinator = certificate_request();
+    let combinator = certificate_status();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecEcPointFormatList {
-    pub l: u8,
-    pub list: Seq<u8>,
+pub enum SpecCertificateExtensionExtensionData {
+    StatusRequest(SpecCertificateStatus),
+    SignedCertificateTimeStamp(SpecSignedCertificateTimestampList),
+    Unrecognized(Seq<u8>),
 }
 
-pub type SpecEcPointFormatListInner = (u8, Seq<u8>);
-
+pub type SpecCertificateExtensionExtensionDataInner = Either<SpecCertificateStatus, Either<SpecSignedCertificateTimestampList, Seq<u8>>>;
 
-impl SpecFrom<SpecEcPointFormatList> for SpecEcPointFormatListInner {
-    open spec fn spec_from(m: SpecEcPointFormatList) -> SpecEcPointFormatListInner {
-        (m.l, m.list)
+impl SpecFrom<SpecCertificateExtensionExtensionData> for SpecCertificateExtensionExtensionDataInner {
+    open spec fn spec_from(m: SpecCertificateExtensionExtensionData) -> SpecCertificateExtensionExtensionDataInner {
+        match m {
+            SpecCertificateExtensionExtensionData::StatusRequest(m) => Either::Left(m),
+            SpecCertificateExtensionExtensionData::SignedCertificateTimeStamp(m) => Either::Right(Either::Left(m)),
+            SpecCertificateExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(m)),
+        }
     }
+
 }
 
-impl SpecFrom<SpecEcPointFormatListInner> for SpecEcPointFormatList {
-    open spec fn spec_from(m: SpecEcPointFormatListInner) -> SpecEcPointFormatList {
-        let (l, list) = m;
-        SpecEcPointFormatList { l, list }
+                
+impl SpecFrom<SpecCertificateExtensionExtensionDataInner> for SpecCertificateExtensionExtensionData {
+    open spec fn spec_from(m: SpecCertificateExtensionExtensionDataInner) -> SpecCertificateExtensionExtensionData {
+        match m {
+            Either::Left(m) => SpecCertificateExtensionExtensionData::StatusRequest(m),
+            Either::Right(Either::Left(m)) => SpecCertificateExtensionExtensionData::SignedCertificateTimeStamp(m),
+            Either::Right(Either::Right(m)) => SpecCertificateExtensionExtensionData::Unrecognized(m),
+        }
     }
+
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct EcPointFormatList {
-    pub l: u8,
-    pub list: RepeatResult<u8>,
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CertificateExtensionExtensionData<'a> {
+    StatusRequest(CertificateStatus<'a>),
+    SignedCertificateTimeStamp(SignedCertificateTimestampList<'a>),
+    Unrecognized(&'a [u8]),
 }
 
-impl View for EcPointFormatList {
-    type V = SpecEcPointFormatList;
+pub type CertificateExtensionExtensionDataInner<'a> = Either<CertificateStatus<'a>, Either<SignedCertificateTimestampList<'a>, &'a [u8]>>;
+
+pub type CertificateExtensionExtensionDataInnerRef<'a> = Either<&'a CertificateStatus<'a>, Either<&'a SignedCertificateTimestampList<'a>, &'a &'a [u8]>>;
+
 
+impl<'a> View for CertificateExtensionExtensionData<'a> {
+    type V = SpecCertificateExtensionExtensionData;
     open spec fn view(&self) -> Self::V {
-        SpecEcPointFormatList {
-            l: self.l@,
-            list: self.list@,
+        match self {
+            CertificateExtensionExtensionData::StatusRequest(m) => SpecCertificateExtensionExtensionData::StatusRequest(m@),
+            CertificateExtensionExtensionData::SignedCertificateTimeStamp(m) => SpecCertificateExtensionExtensionData::SignedCertificateTimeStamp(m@),
+            CertificateExtensionExtensionData::Unrecognized(m) => SpecCertificateExtensionExtensionData::Unrecognized(m@),
         }
     }
 }
-pub type EcPointFormatListInner = (u8, RepeatResult<u8>);
 
-pub type EcPointFormatListInnerRef<'a> = (&'a u8, &'a RepeatResult<u8>);
-impl<'a> From<&'a EcPointFormatList> for EcPointFormatListInnerRef<'a> {
-    fn ex_from(m: &'a EcPointFormatList) -> EcPointFormatListInnerRef<'a> {
-        (&m.l, &m.list)
+
+impl<'a> From<&'a CertificateExtensionExtensionData<'a>> for CertificateExtensionExtensionDataInnerRef<'a> {
+    fn ex_from(m: &'a CertificateExtensionExtensionData<'a>) -> CertificateExtensionExtensionDataInnerRef<'a> {
+        match m {
+            CertificateExtensionExtensionData::StatusRequest(m) => Either::Left(m),
+            CertificateExtensionExtensionData::SignedCertificateTimeStamp(m) => Either::Right(Either::Left(m)),
+            CertificateExtensionExtensionData::Unrecognized(m) => Either::Right(Either::Right(m)),
+        }
     }
+
 }
 
-impl From<EcPointFormatListInner> for EcPointFormatList {
-    fn ex_from(m: EcPointFormatListInner) -> EcPointFormatList {
-        let (l, list) = m;
-        EcPointFormatList { l, list }
+impl<'a> From<CertificateExtensionExtensionDataInner<'a>> for CertificateExtensionExtensionData<'a> {
+    fn ex_from(m: CertificateExtensionExtensionDataInner<'a>) -> CertificateExtensionExtensionData<'a> {
+        match m {
+            Either::Left(m) => CertificateExtensionExtensionData::StatusRequest(m),
+            Either::Right(Either::Left(m)) => CertificateExtensionExtensionData::SignedCertificateTimeStamp(m),
+            Either::Right(Either::Right(m)) => CertificateExtensionExtensionData::Unrecognized(m),
+        }
     }
+    
 }
 
-pub struct EcPointFormatListMapper;
-impl View for EcPointFormatListMapper {
+
+pub struct CertificateExtensionExtensionDataMapper;
+impl View for CertificateExtensionExtensionDataMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for EcPointFormatListMapper {
-    type Src = SpecEcPointFormatListInner;
-    type Dst = SpecEcPointFormatList;
+impl SpecIso for CertificateExtensionExtensionDataMapper {
+    type Src = SpecCertificateExtensionExtensionDataInner;
+    type Dst = SpecCertificateExtensionExtensionData;
 }
-impl SpecIsoProof for EcPointFormatListMapper {
+impl SpecIsoProof for CertificateExtensionExtensionDataMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -19411,241 +18456,218 @@ impl SpecIsoProof for EcPointFormatListMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for EcPointFormatListMapper {
-    type Src = EcPointFormatListInner;
-    type Dst = EcPointFormatList;
-    type RefSrc = EcPointFormatListInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateExtensionExtensionDataMapper {
+    type Src = CertificateExtensionExtensionDataInner<'a>;
+    type Dst = CertificateExtensionExtensionData<'a>;
+    type RefSrc = CertificateExtensionExtensionDataInnerRef<'a>;
 }
 
-pub struct SpecEcPointFormatListCombinator(pub SpecEcPointFormatListCombinatorAlias);
+type SpecCertificateExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SpecSignedCertificateTimestampListCombinator>, Cond<bytes::Variable>>;
+type SpecCertificateExtensionExtensionDataCombinatorAlias2 = Choice<Cond<SpecCertificateStatusCombinator>, SpecCertificateExtensionExtensionDataCombinatorAlias1>;
+pub struct SpecCertificateExtensionExtensionDataCombinator(pub SpecCertificateExtensionExtensionDataCombinatorAlias);
 
-impl SpecCombinator for SpecEcPointFormatListCombinator {
-    type Type = SpecEcPointFormatList;
+impl SpecCombinator for SpecCertificateExtensionExtensionDataCombinator {
+    type Type = SpecCertificateExtensionExtensionData;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecEcPointFormatListCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecEcPointFormatListCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateExtensionExtensionDataCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateExtensionExtensionDataCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecEcPointFormatListCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<SpecEcPointFormatCombinator>>>, EcPointFormatListMapper>;
+pub type SpecCertificateExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecCertificateExtensionExtensionDataCombinatorAlias2, CertificateExtensionExtensionDataMapper>>;
+type CertificateExtensionExtensionDataCombinatorAlias1 = Choice<Cond<SignedCertificateTimestampListCombinator>, Cond<bytes::Variable>>;
+type CertificateExtensionExtensionDataCombinatorAlias2 = Choice<Cond<CertificateStatusCombinator>, CertificateExtensionExtensionDataCombinator1>;
+pub struct CertificateExtensionExtensionDataCombinator1(pub CertificateExtensionExtensionDataCombinatorAlias1);
+impl View for CertificateExtensionExtensionDataCombinator1 {
+    type V = SpecCertificateExtensionExtensionDataCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateExtensionExtensionDataCombinator1, CertificateExtensionExtensionDataCombinatorAlias1);
 
-pub struct EcPointFormatListCombinator(pub EcPointFormatListCombinatorAlias);
+pub struct CertificateExtensionExtensionDataCombinator2(pub CertificateExtensionExtensionDataCombinatorAlias2);
+impl View for CertificateExtensionExtensionDataCombinator2 {
+    type V = SpecCertificateExtensionExtensionDataCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateExtensionExtensionDataCombinator2, CertificateExtensionExtensionDataCombinatorAlias2);
 
-impl View for EcPointFormatListCombinator {
-    type V = SpecEcPointFormatListCombinator;
-    open spec fn view(&self) -> Self::V { SpecEcPointFormatListCombinator(self.0@) }
+pub struct CertificateExtensionExtensionDataCombinator(pub CertificateExtensionExtensionDataCombinatorAlias);
+
+impl View for CertificateExtensionExtensionDataCombinator {
+    type V = SpecCertificateExtensionExtensionDataCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateExtensionExtensionDataCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EcPointFormatListCombinator {
-    type Type = EcPointFormatList;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateExtensionExtensionDataCombinator {
+    type Type = CertificateExtensionExtensionData<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type EcPointFormatListCombinatorAlias = Mapped<Pair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<EcPointFormatCombinator>>, EcPointFormatListCont0>, EcPointFormatListMapper>;
-
-
-pub open spec fn spec_ec_point_format_list() -> SpecEcPointFormatListCombinator {
-    SpecEcPointFormatListCombinator(
-    Mapped {
-        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, |deps| spec_ec_point_format_list_cont0(deps)),
-        mapper: EcPointFormatListMapper,
-    })
-}
-
-pub open spec fn spec_ec_point_format_list_cont0(deps: u8) -> AndThen<bytes::Variable, Repeat<SpecEcPointFormatCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_ec_point_format()))
 }
+pub type CertificateExtensionExtensionDataCombinatorAlias = AndThen<bytes::Variable, Mapped<CertificateExtensionExtensionDataCombinator2, CertificateExtensionExtensionDataMapper>>;
 
-impl View for EcPointFormatListCont0 {
-    type V = spec_fn(u8) -> AndThen<bytes::Variable, Repeat<SpecEcPointFormatCombinator>>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u8| {
-            spec_ec_point_format_list_cont0(deps)
-        }
-    }
+pub open spec fn spec_certificate_extension_extension_data(ext_len: u16, extension_type: u16) -> SpecCertificateExtensionExtensionDataCombinator {
+    SpecCertificateExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::spec_from(ext_len)) as usize), Mapped { inner: Choice(Cond { cond: extension_type == ExtensionType::SPEC_StatusRequest, inner: spec_certificate_status() }, Choice(Cond { cond: extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp, inner: spec_signed_certificate_timestamp_list() }, Cond { cond: !(extension_type == ExtensionType::SPEC_StatusRequest || extension_type == ExtensionType::SPEC_SignedCertificateTimeStamp), inner: bytes::Variable((usize::spec_from(ext_len)) as usize) })), mapper: CertificateExtensionExtensionDataMapper }))
 }
 
-                
-pub fn ec_point_format_list<'a>() -> (o: EcPointFormatListCombinator)
-    ensures o@ == spec_ec_point_format_list(),
+pub fn certificate_extension_extension_data<'a>(ext_len: u16, extension_type: u16) -> (o: CertificateExtensionExtensionDataCombinator)
+    requires
+        spec_extension_type().wf(extension_type@),
+
+    ensures o@ == spec_certificate_extension_extension_data(ext_len@, extension_type@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = EcPointFormatListCombinator(
-    Mapped {
-        inner: Pair::new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, EcPointFormatListCont0),
-        mapper: EcPointFormatListMapper,
-    });
-    assert({
-        &&& combinator@ == spec_ec_point_format_list()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = CertificateExtensionExtensionDataCombinator(AndThen(bytes::Variable((usize::ex_from(ext_len)) as usize), Mapped { inner: CertificateExtensionExtensionDataCombinator2(Choice::new(Cond { cond: extension_type == ExtensionType::StatusRequest, inner: certificate_status() }, CertificateExtensionExtensionDataCombinator1(Choice::new(Cond { cond: extension_type == ExtensionType::SignedCertificateTimeStamp, inner: signed_certificate_timestamp_list() }, Cond { cond: !(extension_type == ExtensionType::StatusRequest || extension_type == ExtensionType::SignedCertificateTimeStamp), inner: bytes::Variable((usize::ex_from(ext_len)) as usize) })))), mapper: CertificateExtensionExtensionDataMapper }));
+    // assert({
+    //     &&& combinator@ == spec_certificate_extension_extension_data(ext_len@, extension_type@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_ec_point_format_list<'a>(input: &'a [u8]) -> (res: PResult<<EcPointFormatListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_extension_extension_data<'a>(input: &'a [u8], ext_len: u16, extension_type: u16) -> (res: PResult<<CertificateExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_ec_point_format_list().spec_parse(input@) == Some((n as int, v@)),
-        spec_ec_point_format_list().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_ec_point_format_list().spec_parse(input@) is None,
-        spec_ec_point_format_list().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None,
+        spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = ec_point_format_list();
+    let combinator = certificate_extension_extension_data( ext_len, extension_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_ec_point_format_list<'a>(v: <EcPointFormatListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_extension_extension_data<'a>(v: <CertificateExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16, extension_type: u16) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_ec_point_format_list().wf(v@),
+        spec_certificate_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_extension_type().wf(extension_type@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_ec_point_format_list().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_ec_point_format_list().spec_serialize(v@))
+            &&& n == spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@))
         },
 {
-    let combinator = ec_point_format_list();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = certificate_extension_extension_data( ext_len, extension_type );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn ec_point_format_list_len<'a>(v: <EcPointFormatListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_extension_extension_data_len<'a>(v: <CertificateExtensionExtensionDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16, extension_type: u16) -> (serialize_len: usize)
     requires
-        spec_ec_point_format_list().wf(v@),
-        spec_ec_point_format_list().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_extension_extension_data(ext_len@, extension_type@).wf(v@),
+        spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_extension_type().wf(extension_type@),
+
     ensures
-        serialize_len == spec_ec_point_format_list().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_extension_extension_data(ext_len@, extension_type@).spec_serialize(v@).len(),
 {
-    let combinator = ec_point_format_list();
+    let combinator = certificate_extension_extension_data( ext_len, extension_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct EcPointFormatListCont0;
-type EcPointFormatListCont0Type<'a, 'b> = &'b u8;
-type EcPointFormatListCont0SType<'a, 'x> = &'x u8;
-type EcPointFormatListCont0Input<'a, 'b, 'x> = POrSType<EcPointFormatListCont0Type<'a, 'b>, EcPointFormatListCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<EcPointFormatListCont0Input<'a, 'b, 'x>> for EcPointFormatListCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<EcPointFormatCombinator>>;
-
-    open spec fn requires(&self, deps: EcPointFormatListCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: EcPointFormatListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_ec_point_format_list_cont0(deps@)
-    }
-
-    fn apply(&self, deps: EcPointFormatListCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(ec_point_format()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(ec_point_format()))
-            }
-        }
-    }
-}
-                
 
-pub struct SpecCertificateEntryOpaque {
-    pub cert_data: SpecOpaque1Ffffff,
-    pub extensions: SpecCertificateExtensions,
+pub struct SpecCertificateExtension {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: SpecCertificateExtensionExtensionData,
 }
 
-pub type SpecCertificateEntryOpaqueInner = (SpecOpaque1Ffffff, SpecCertificateExtensions);
+pub type SpecCertificateExtensionInner = ((u16, u16), SpecCertificateExtensionExtensionData);
 
 
-impl SpecFrom<SpecCertificateEntryOpaque> for SpecCertificateEntryOpaqueInner {
-    open spec fn spec_from(m: SpecCertificateEntryOpaque) -> SpecCertificateEntryOpaqueInner {
-        (m.cert_data, m.extensions)
+impl SpecFrom<SpecCertificateExtension> for SpecCertificateExtensionInner {
+    open spec fn spec_from(m: SpecCertificateExtension) -> SpecCertificateExtensionInner {
+        ((m.extension_type, m.ext_len), m.extension_data)
     }
 }
 
-impl SpecFrom<SpecCertificateEntryOpaqueInner> for SpecCertificateEntryOpaque {
-    open spec fn spec_from(m: SpecCertificateEntryOpaqueInner) -> SpecCertificateEntryOpaque {
-        let (cert_data, extensions) = m;
-        SpecCertificateEntryOpaque { cert_data, extensions }
+impl SpecFrom<SpecCertificateExtensionInner> for SpecCertificateExtension {
+    open spec fn spec_from(m: SpecCertificateExtensionInner) -> SpecCertificateExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        SpecCertificateExtension { extension_type, ext_len, extension_data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CertificateEntryOpaque<'a> {
-    pub cert_data: Opaque1Ffffff<'a>,
-    pub extensions: CertificateExtensions<'a>,
+pub struct CertificateExtension<'a> {
+    pub extension_type: u16,
+    pub ext_len: u16,
+    pub extension_data: CertificateExtensionExtensionData<'a>,
 }
 
-impl View for CertificateEntryOpaque<'_> {
-    type V = SpecCertificateEntryOpaque;
+impl View for CertificateExtension<'_> {
+    type V = SpecCertificateExtension;
 
     open spec fn view(&self) -> Self::V {
-        SpecCertificateEntryOpaque {
-            cert_data: self.cert_data@,
-            extensions: self.extensions@,
+        SpecCertificateExtension {
+            extension_type: self.extension_type@,
+            ext_len: self.ext_len@,
+            extension_data: self.extension_data@,
         }
     }
 }
-pub type CertificateEntryOpaqueInner<'a> = (Opaque1Ffffff<'a>, CertificateExtensions<'a>);
+pub type CertificateExtensionInner<'a> = ((u16, u16), CertificateExtensionExtensionData<'a>);
 
-pub type CertificateEntryOpaqueInnerRef<'a> = (&'a Opaque1Ffffff<'a>, &'a CertificateExtensions<'a>);
-impl<'a> From<&'a CertificateEntryOpaque<'a>> for CertificateEntryOpaqueInnerRef<'a> {
-    fn ex_from(m: &'a CertificateEntryOpaque) -> CertificateEntryOpaqueInnerRef<'a> {
-        (&m.cert_data, &m.extensions)
+pub type CertificateExtensionInnerRef<'a> = ((&'a u16, &'a u16), &'a CertificateExtensionExtensionData<'a>);
+impl<'a> From<&'a CertificateExtension<'a>> for CertificateExtensionInnerRef<'a> {
+    fn ex_from(m: &'a CertificateExtension) -> CertificateExtensionInnerRef<'a> {
+        ((&m.extension_type, &m.ext_len), &m.extension_data)
     }
 }
 
-impl<'a> From<CertificateEntryOpaqueInner<'a>> for CertificateEntryOpaque<'a> {
-    fn ex_from(m: CertificateEntryOpaqueInner) -> CertificateEntryOpaque {
-        let (cert_data, extensions) = m;
-        CertificateEntryOpaque { cert_data, extensions }
+impl<'a> From<CertificateExtensionInner<'a>> for CertificateExtension<'a> {
+    fn ex_from(m: CertificateExtensionInner) -> CertificateExtension {
+        let ((extension_type, ext_len), extension_data) = m;
+        CertificateExtension { extension_type, ext_len, extension_data }
     }
 }
 
-pub struct CertificateEntryOpaqueMapper;
-impl View for CertificateEntryOpaqueMapper {
+pub struct CertificateExtensionMapper;
+impl View for CertificateExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateEntryOpaqueMapper {
-    type Src = SpecCertificateEntryOpaqueInner;
-    type Dst = SpecCertificateEntryOpaque;
+impl SpecIso for CertificateExtensionMapper {
+    type Src = SpecCertificateExtensionInner;
+    type Dst = SpecCertificateExtension;
 }
-impl SpecIsoProof for CertificateEntryOpaqueMapper {
+impl SpecIsoProof for CertificateExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -19653,209 +18675,293 @@ impl SpecIsoProof for CertificateEntryOpaqueMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateEntryOpaqueMapper {
-    type Src = CertificateEntryOpaqueInner<'a>;
-    type Dst = CertificateEntryOpaque<'a>;
-    type RefSrc = CertificateEntryOpaqueInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateExtensionMapper {
+    type Src = CertificateExtensionInner<'a>;
+    type Dst = CertificateExtension<'a>;
+    type RefSrc = CertificateExtensionInnerRef<'a>;
 }
-type SpecCertificateEntryOpaqueCombinatorAlias1 = (SpecOpaque1FfffffCombinator, SpecCertificateExtensionsCombinator);
-pub struct SpecCertificateEntryOpaqueCombinator(pub SpecCertificateEntryOpaqueCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateEntryOpaqueCombinator {
-    type Type = SpecCertificateEntryOpaque;
+pub struct SpecCertificateExtensionCombinator(pub SpecCertificateExtensionCombinatorAlias);
+
+impl SpecCombinator for SpecCertificateExtensionCombinator {
+    type Type = SpecCertificateExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateEntryOpaqueCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateEntryOpaqueCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateEntryOpaqueCombinatorAlias = Mapped<SpecCertificateEntryOpaqueCombinatorAlias1, CertificateEntryOpaqueMapper>;
-type CertificateEntryOpaqueCombinatorAlias1 = (Opaque1FfffffCombinator, CertificateExtensionsCombinator);
-pub struct CertificateEntryOpaqueCombinator1(pub CertificateEntryOpaqueCombinatorAlias1);
-impl View for CertificateEntryOpaqueCombinator1 {
-    type V = SpecCertificateEntryOpaqueCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateEntryOpaqueCombinator1, CertificateEntryOpaqueCombinatorAlias1);
+pub type SpecCertificateExtensionCombinatorAlias = Mapped<SpecPair<SpecPair<SpecExtensionTypeCombinator, U16Be>, SpecCertificateExtensionExtensionDataCombinator>, CertificateExtensionMapper>;
 
-pub struct CertificateEntryOpaqueCombinator(pub CertificateEntryOpaqueCombinatorAlias);
+pub struct CertificateExtensionCombinator(pub CertificateExtensionCombinatorAlias);
 
-impl View for CertificateEntryOpaqueCombinator {
-    type V = SpecCertificateEntryOpaqueCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateEntryOpaqueCombinator(self.0@) }
+impl View for CertificateExtensionCombinator {
+    type V = SpecCertificateExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateEntryOpaqueCombinator {
-    type Type = CertificateEntryOpaque<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateExtensionCombinator {
+    type Type = CertificateExtension<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateEntryOpaqueCombinatorAlias = Mapped<CertificateEntryOpaqueCombinator1, CertificateEntryOpaqueMapper>;
+}
+pub type CertificateExtensionCombinatorAlias = Mapped<Pair<Pair<ExtensionTypeCombinator, U16Be, CertificateExtensionCont1>, CertificateExtensionExtensionDataCombinator, CertificateExtensionCont0>, CertificateExtensionMapper>;
 
 
-pub open spec fn spec_certificate_entry_opaque() -> SpecCertificateEntryOpaqueCombinator {
-    SpecCertificateEntryOpaqueCombinator(
+pub open spec fn spec_certificate_extension() -> SpecCertificateExtensionCombinator {
+    SpecCertificateExtensionCombinator(
     Mapped {
-        inner: (spec_opaque_1_ffffff(), spec_certificate_extensions()),
-        mapper: CertificateEntryOpaqueMapper,
+        inner: Pair::spec_new(Pair::spec_new(spec_extension_type(), |deps| spec_certificate_extension_cont1(deps)), |deps| spec_certificate_extension_cont0(deps)),
+        mapper: CertificateExtensionMapper,
     })
 }
 
-                
-pub fn certificate_entry_opaque<'a>() -> (o: CertificateEntryOpaqueCombinator)
-    ensures o@ == spec_certificate_entry_opaque(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = CertificateEntryOpaqueCombinator(
-    Mapped {
-        inner: CertificateEntryOpaqueCombinator1((opaque_1_ffffff(), certificate_extensions())),
-        mapper: CertificateEntryOpaqueMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_entry_opaque()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+pub open spec fn spec_certificate_extension_cont1(deps: u16) -> U16Be {
+    let extension_type = deps;
+    U16Be
+}
+
+impl View for CertificateExtensionCont1 {
+    type V = spec_fn(u16) -> U16Be;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_certificate_extension_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_certificate_extension_cont0(deps: (u16, u16)) -> SpecCertificateExtensionExtensionDataCombinator {
+    let (extension_type, ext_len) = deps;
+    spec_certificate_extension_extension_data(ext_len, extension_type)
+}
+
+impl View for CertificateExtensionCont0 {
+    type V = spec_fn((u16, u16)) -> SpecCertificateExtensionExtensionDataCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (u16, u16)| {
+            spec_certificate_extension_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn certificate_extension<'a>() -> (o: CertificateExtensionCombinator)
+    ensures o@ == spec_certificate_extension(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CertificateExtensionCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(extension_type(), CertificateExtensionCont1), CertificateExtensionCont0),
+        mapper: CertificateExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_entry_opaque<'a>(input: &'a [u8]) -> (res: PResult<<CertificateEntryOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_extension<'a>(input: &'a [u8]) -> (res: PResult<<CertificateExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_entry_opaque().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_entry_opaque().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_entry_opaque().spec_parse(input@) is None,
-        spec_certificate_entry_opaque().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_extension().spec_parse(input@) is None,
+        spec_certificate_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_entry_opaque();
+    let combinator = certificate_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_entry_opaque<'a>(v: <CertificateEntryOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_extension<'a>(v: <CertificateExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_entry_opaque().wf(v@),
+        spec_certificate_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_entry_opaque().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_entry_opaque().spec_serialize(v@))
+            &&& n == spec_certificate_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_extension().spec_serialize(v@))
         },
 {
-    let combinator = certificate_entry_opaque();
+    let combinator = certificate_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_entry_opaque_len<'a>(v: <CertificateEntryOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_extension_len<'a>(v: <CertificateExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_entry_opaque().wf(v@),
-        spec_certificate_entry_opaque().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_extension().wf(v@),
+        spec_certificate_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_entry_opaque().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_extension().spec_serialize(v@).len(),
 {
-    let combinator = certificate_entry_opaque();
+    let combinator = certificate_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct CertificateExtensionCont1;
+type CertificateExtensionCont1Type<'a, 'b> = &'b u16;
+type CertificateExtensionCont1SType<'a, 'x> = &'x u16;
+type CertificateExtensionCont1Input<'a, 'b, 'x> = POrSType<CertificateExtensionCont1Type<'a, 'b>, CertificateExtensionCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CertificateExtensionCont1Input<'a, 'b, 'x>> for CertificateExtensionCont1 {
+    type Output = U16Be;
+
+    open spec fn requires(&self, deps: CertificateExtensionCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_extension_type()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CertificateExtensionCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_certificate_extension_cont1(deps@)
+    }
+
+    fn apply(&self, deps: CertificateExtensionCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
+            }
+            POrSType::S(deps) => {
+                let extension_type = deps;
+                let extension_type = *extension_type;
+                U16Be
+            }
+        }
+    }
+}
+pub struct CertificateExtensionCont0;
+type CertificateExtensionCont0Type<'a, 'b> = &'b (u16, u16);
+type CertificateExtensionCont0SType<'a, 'x> = (&'x u16, &'x u16);
+type CertificateExtensionCont0Input<'a, 'b, 'x> = POrSType<CertificateExtensionCont0Type<'a, 'b>, CertificateExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CertificateExtensionCont0Input<'a, 'b, 'x>> for CertificateExtensionCont0 {
+    type Output = CertificateExtensionExtensionDataCombinator;
+
+    open spec fn requires(&self, deps: CertificateExtensionCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_extension_type(), |deps| spec_certificate_extension_cont1(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CertificateExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_certificate_extension_cont0(deps@)
+    }
+
+    fn apply(&self, deps: CertificateExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                certificate_extension_extension_data(ext_len, extension_type)
+            }
+            POrSType::S(deps) => {
+                let (extension_type, ext_len) = deps;
+                let extension_type = *extension_type;
+                let ext_len = *ext_len;
+                certificate_extension_extension_data(ext_len, extension_type)
+            }
+        }
+    }
+}
                 
 
-pub struct SpecTlsCiphertext {
-    pub opaque_type: SpecContentType,
-    pub version: u16,
-    pub encrypted_record: SpecOpaque0Ffff,
+pub struct SpecCertificateExtensions {
+    pub l: u16,
+    pub list: Seq<SpecCertificateExtension>,
 }
 
-pub type SpecTlsCiphertextInner = (SpecContentType, (u16, SpecOpaque0Ffff));
+pub type SpecCertificateExtensionsInner = (u16, Seq<SpecCertificateExtension>);
 
 
-impl SpecFrom<SpecTlsCiphertext> for SpecTlsCiphertextInner {
-    open spec fn spec_from(m: SpecTlsCiphertext) -> SpecTlsCiphertextInner {
-        (m.opaque_type, (m.version, m.encrypted_record))
+impl SpecFrom<SpecCertificateExtensions> for SpecCertificateExtensionsInner {
+    open spec fn spec_from(m: SpecCertificateExtensions) -> SpecCertificateExtensionsInner {
+        (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecTlsCiphertextInner> for SpecTlsCiphertext {
-    open spec fn spec_from(m: SpecTlsCiphertextInner) -> SpecTlsCiphertext {
-        let (opaque_type, (version, encrypted_record)) = m;
-        SpecTlsCiphertext { opaque_type, version, encrypted_record }
+impl SpecFrom<SpecCertificateExtensionsInner> for SpecCertificateExtensions {
+    open spec fn spec_from(m: SpecCertificateExtensionsInner) -> SpecCertificateExtensions {
+        let (l, list) = m;
+        SpecCertificateExtensions { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct TlsCiphertext<'a> {
-    pub opaque_type: ContentType,
-    pub version: u16,
-    pub encrypted_record: Opaque0Ffff<'a>,
+pub struct CertificateExtensions<'a> {
+    pub l: u16,
+    pub list: RepeatResult<CertificateExtension<'a>>,
 }
 
-impl View for TlsCiphertext<'_> {
-    type V = SpecTlsCiphertext;
+impl View for CertificateExtensions<'_> {
+    type V = SpecCertificateExtensions;
 
     open spec fn view(&self) -> Self::V {
-        SpecTlsCiphertext {
-            opaque_type: self.opaque_type@,
-            version: self.version@,
-            encrypted_record: self.encrypted_record@,
+        SpecCertificateExtensions {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
-pub type TlsCiphertextInner<'a> = (ContentType, (u16, Opaque0Ffff<'a>));
+pub type CertificateExtensionsInner<'a> = (u16, RepeatResult<CertificateExtension<'a>>);
 
-pub type TlsCiphertextInnerRef<'a> = (&'a ContentType, (&'a u16, &'a Opaque0Ffff<'a>));
-impl<'a> From<&'a TlsCiphertext<'a>> for TlsCiphertextInnerRef<'a> {
-    fn ex_from(m: &'a TlsCiphertext) -> TlsCiphertextInnerRef<'a> {
-        (&m.opaque_type, (&m.version, &m.encrypted_record))
+pub type CertificateExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<CertificateExtension<'a>>);
+impl<'a> From<&'a CertificateExtensions<'a>> for CertificateExtensionsInnerRef<'a> {
+    fn ex_from(m: &'a CertificateExtensions) -> CertificateExtensionsInnerRef<'a> {
+        (&m.l, &m.list)
     }
 }
 
-impl<'a> From<TlsCiphertextInner<'a>> for TlsCiphertext<'a> {
-    fn ex_from(m: TlsCiphertextInner) -> TlsCiphertext {
-        let (opaque_type, (version, encrypted_record)) = m;
-        TlsCiphertext { opaque_type, version, encrypted_record }
+impl<'a> From<CertificateExtensionsInner<'a>> for CertificateExtensions<'a> {
+    fn ex_from(m: CertificateExtensionsInner) -> CertificateExtensions {
+        let (l, list) = m;
+        CertificateExtensions { l, list }
     }
 }
 
-pub struct TlsCiphertextMapper;
-impl View for TlsCiphertextMapper {
+pub struct CertificateExtensionsMapper;
+impl View for CertificateExtensionsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for TlsCiphertextMapper {
-    type Src = SpecTlsCiphertextInner;
-    type Dst = SpecTlsCiphertext;
+impl SpecIso for CertificateExtensionsMapper {
+    type Src = SpecCertificateExtensionsInner;
+    type Dst = SpecCertificateExtensions;
 }
-impl SpecIsoProof for TlsCiphertextMapper {
+impl SpecIsoProof for CertificateExtensionsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -19863,218 +18969,245 @@ impl SpecIsoProof for TlsCiphertextMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for TlsCiphertextMapper {
-    type Src = TlsCiphertextInner<'a>;
-    type Dst = TlsCiphertext<'a>;
-    type RefSrc = TlsCiphertextInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateExtensionsMapper {
+    type Src = CertificateExtensionsInner<'a>;
+    type Dst = CertificateExtensions<'a>;
+    type RefSrc = CertificateExtensionsInnerRef<'a>;
 }
-type SpecTlsCiphertextCombinatorAlias1 = (SpecProtocolVersionCombinator, SpecOpaque0FfffCombinator);
-type SpecTlsCiphertextCombinatorAlias2 = (SpecContentTypeCombinator, SpecTlsCiphertextCombinatorAlias1);
-pub struct SpecTlsCiphertextCombinator(pub SpecTlsCiphertextCombinatorAlias);
 
-impl SpecCombinator for SpecTlsCiphertextCombinator {
-    type Type = SpecTlsCiphertext;
+pub struct SpecCertificateExtensionsCombinator(pub SpecCertificateExtensionsCombinatorAlias);
+
+impl SpecCombinator for SpecCertificateExtensionsCombinator {
+    type Type = SpecCertificateExtensions;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTlsCiphertextCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTlsCiphertextCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateExtensionsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateExtensionsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTlsCiphertextCombinatorAlias = Mapped<SpecTlsCiphertextCombinatorAlias2, TlsCiphertextMapper>;
-type TlsCiphertextCombinatorAlias1 = (ProtocolVersionCombinator, Opaque0FfffCombinator);
-type TlsCiphertextCombinatorAlias2 = (ContentTypeCombinator, TlsCiphertextCombinator1);
-pub struct TlsCiphertextCombinator1(pub TlsCiphertextCombinatorAlias1);
-impl View for TlsCiphertextCombinator1 {
-    type V = SpecTlsCiphertextCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(TlsCiphertextCombinator1, TlsCiphertextCombinatorAlias1);
-
-pub struct TlsCiphertextCombinator2(pub TlsCiphertextCombinatorAlias2);
-impl View for TlsCiphertextCombinator2 {
-    type V = SpecTlsCiphertextCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(TlsCiphertextCombinator2, TlsCiphertextCombinatorAlias2);
+pub type SpecCertificateExtensionsCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecCertificateExtensionCombinator>>>, CertificateExtensionsMapper>;
 
-pub struct TlsCiphertextCombinator(pub TlsCiphertextCombinatorAlias);
+pub struct CertificateExtensionsCombinator(pub CertificateExtensionsCombinatorAlias);
 
-impl View for TlsCiphertextCombinator {
-    type V = SpecTlsCiphertextCombinator;
-    open spec fn view(&self) -> Self::V { SpecTlsCiphertextCombinator(self.0@) }
+impl View for CertificateExtensionsCombinator {
+    type V = SpecCertificateExtensionsCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateExtensionsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TlsCiphertextCombinator {
-    type Type = TlsCiphertext<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateExtensionsCombinator {
+    type Type = CertificateExtensions<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TlsCiphertextCombinatorAlias = Mapped<TlsCiphertextCombinator2, TlsCiphertextMapper>;
+}
+pub type CertificateExtensionsCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<CertificateExtensionCombinator>>, CertificateExtensionsCont0>, CertificateExtensionsMapper>;
 
 
-pub open spec fn spec_tls_ciphertext() -> SpecTlsCiphertextCombinator {
-    SpecTlsCiphertextCombinator(
+pub open spec fn spec_certificate_extensions() -> SpecCertificateExtensionsCombinator {
+    SpecCertificateExtensionsCombinator(
     Mapped {
-        inner: (spec_content_type(), (spec_protocol_version(), spec_opaque_0_ffff())),
-        mapper: TlsCiphertextMapper,
+        inner: Pair::spec_new(U16Be, |deps| spec_certificate_extensions_cont0(deps)),
+        mapper: CertificateExtensionsMapper,
     })
 }
 
+pub open spec fn spec_certificate_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecCertificateExtensionCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_certificate_extension()))
+}
+
+impl View for CertificateExtensionsCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecCertificateExtensionCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_certificate_extensions_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn tls_ciphertext<'a>() -> (o: TlsCiphertextCombinator)
-    ensures o@ == spec_tls_ciphertext(),
+pub fn certificate_extensions<'a>() -> (o: CertificateExtensionsCombinator)
+    ensures o@ == spec_certificate_extensions(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = TlsCiphertextCombinator(
+    let combinator = CertificateExtensionsCombinator(
     Mapped {
-        inner: TlsCiphertextCombinator2((content_type(), TlsCiphertextCombinator1((protocol_version(), opaque_0_ffff())))),
-        mapper: TlsCiphertextMapper,
-    });
-    assert({
-        &&& combinator@ == spec_tls_ciphertext()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(U16Be, CertificateExtensionsCont0),
+        mapper: CertificateExtensionsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_extensions()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_tls_ciphertext<'a>(input: &'a [u8]) -> (res: PResult<<TlsCiphertextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_extensions<'a>(input: &'a [u8]) -> (res: PResult<<CertificateExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_tls_ciphertext().spec_parse(input@) == Some((n as int, v@)),
-        spec_tls_ciphertext().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_extensions().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_extensions().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_tls_ciphertext().spec_parse(input@) is None,
-        spec_tls_ciphertext().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_extensions().spec_parse(input@) is None,
+        spec_certificate_extensions().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = tls_ciphertext();
+    let combinator = certificate_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_tls_ciphertext<'a>(v: <TlsCiphertextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_extensions<'a>(v: <CertificateExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_tls_ciphertext().wf(v@),
+        spec_certificate_extensions().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_tls_ciphertext().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_tls_ciphertext().spec_serialize(v@))
+            &&& n == spec_certificate_extensions().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_extensions().spec_serialize(v@))
         },
 {
-    let combinator = tls_ciphertext();
+    let combinator = certificate_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn tls_ciphertext_len<'a>(v: <TlsCiphertextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_extensions_len<'a>(v: <CertificateExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_tls_ciphertext().wf(v@),
-        spec_tls_ciphertext().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_extensions().wf(v@),
+        spec_certificate_extensions().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_tls_ciphertext().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_extensions().spec_serialize(v@).len(),
 {
-    let combinator = tls_ciphertext();
+    let combinator = certificate_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct CertificateExtensionsCont0;
+type CertificateExtensionsCont0Type<'a, 'b> = &'b u16;
+type CertificateExtensionsCont0SType<'a, 'x> = &'x u16;
+type CertificateExtensionsCont0Input<'a, 'b, 'x> = POrSType<CertificateExtensionsCont0Type<'a, 'b>, CertificateExtensionsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CertificateExtensionsCont0Input<'a, 'b, 'x>> for CertificateExtensionsCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<CertificateExtensionCombinator>>;
+
+    open spec fn requires(&self, deps: CertificateExtensionsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U16Be).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CertificateExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_certificate_extensions_cont0(deps@)
+    }
+
+    fn apply(&self, deps: CertificateExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(certificate_extension()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(certificate_extension()))
+            }
+        }
+    }
+}
                 
 
-pub struct SpecShOrHrr {
-    pub legacy_version: u16,
-    pub random: Seq<u8>,
-    pub payload: SpecShOrHrrPayload,
+pub struct SpecCertificateEntryOpaque {
+    pub cert_data: SpecOpaque1Ffffff,
+    pub extensions: SpecCertificateExtensions,
 }
 
-pub type SpecShOrHrrInner = ((u16, Seq<u8>), SpecShOrHrrPayload);
+pub type SpecCertificateEntryOpaqueInner = (SpecOpaque1Ffffff, SpecCertificateExtensions);
 
 
-impl SpecFrom<SpecShOrHrr> for SpecShOrHrrInner {
-    open spec fn spec_from(m: SpecShOrHrr) -> SpecShOrHrrInner {
-        ((m.legacy_version, m.random), m.payload)
+impl SpecFrom<SpecCertificateEntryOpaque> for SpecCertificateEntryOpaqueInner {
+    open spec fn spec_from(m: SpecCertificateEntryOpaque) -> SpecCertificateEntryOpaqueInner {
+        (m.cert_data, m.extensions)
     }
 }
 
-impl SpecFrom<SpecShOrHrrInner> for SpecShOrHrr {
-    open spec fn spec_from(m: SpecShOrHrrInner) -> SpecShOrHrr {
-        let ((legacy_version, random), payload) = m;
-        SpecShOrHrr { legacy_version, random, payload }
+impl SpecFrom<SpecCertificateEntryOpaqueInner> for SpecCertificateEntryOpaque {
+    open spec fn spec_from(m: SpecCertificateEntryOpaqueInner) -> SpecCertificateEntryOpaque {
+        let (cert_data, extensions) = m;
+        SpecCertificateEntryOpaque { cert_data, extensions }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ShOrHrr<'a> {
-    pub legacy_version: u16,
-    pub random: &'a [u8],
-    pub payload: ShOrHrrPayload<'a>,
+pub struct CertificateEntryOpaque<'a> {
+    pub cert_data: Opaque1Ffffff<'a>,
+    pub extensions: CertificateExtensions<'a>,
 }
 
-impl View for ShOrHrr<'_> {
-    type V = SpecShOrHrr;
+impl View for CertificateEntryOpaque<'_> {
+    type V = SpecCertificateEntryOpaque;
 
     open spec fn view(&self) -> Self::V {
-        SpecShOrHrr {
-            legacy_version: self.legacy_version@,
-            random: self.random@,
-            payload: self.payload@,
+        SpecCertificateEntryOpaque {
+            cert_data: self.cert_data@,
+            extensions: self.extensions@,
         }
     }
 }
-pub type ShOrHrrInner<'a> = ((u16, &'a [u8]), ShOrHrrPayload<'a>);
+pub type CertificateEntryOpaqueInner<'a> = (Opaque1Ffffff<'a>, CertificateExtensions<'a>);
 
-pub type ShOrHrrInnerRef<'a> = ((&'a u16, &'a &'a [u8]), &'a ShOrHrrPayload<'a>);
-impl<'a> From<&'a ShOrHrr<'a>> for ShOrHrrInnerRef<'a> {
-    fn ex_from(m: &'a ShOrHrr) -> ShOrHrrInnerRef<'a> {
-        ((&m.legacy_version, &m.random), &m.payload)
+pub type CertificateEntryOpaqueInnerRef<'a> = (&'a Opaque1Ffffff<'a>, &'a CertificateExtensions<'a>);
+impl<'a> From<&'a CertificateEntryOpaque<'a>> for CertificateEntryOpaqueInnerRef<'a> {
+    fn ex_from(m: &'a CertificateEntryOpaque) -> CertificateEntryOpaqueInnerRef<'a> {
+        (&m.cert_data, &m.extensions)
     }
 }
 
-impl<'a> From<ShOrHrrInner<'a>> for ShOrHrr<'a> {
-    fn ex_from(m: ShOrHrrInner) -> ShOrHrr {
-        let ((legacy_version, random), payload) = m;
-        ShOrHrr { legacy_version, random, payload }
+impl<'a> From<CertificateEntryOpaqueInner<'a>> for CertificateEntryOpaque<'a> {
+    fn ex_from(m: CertificateEntryOpaqueInner) -> CertificateEntryOpaque {
+        let (cert_data, extensions) = m;
+        CertificateEntryOpaque { cert_data, extensions }
     }
 }
 
-pub struct ShOrHrrMapper;
-impl View for ShOrHrrMapper {
+pub struct CertificateEntryOpaqueMapper;
+impl View for CertificateEntryOpaqueMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ShOrHrrMapper {
-    type Src = SpecShOrHrrInner;
-    type Dst = SpecShOrHrr;
+impl SpecIso for CertificateEntryOpaqueMapper {
+    type Src = SpecCertificateEntryOpaqueInner;
+    type Dst = SpecCertificateEntryOpaque;
 }
-impl SpecIsoProof for ShOrHrrMapper {
+impl SpecIsoProof for CertificateEntryOpaqueMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -20082,262 +19215,206 @@ impl SpecIsoProof for ShOrHrrMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ShOrHrrMapper {
-    type Src = ShOrHrrInner<'a>;
-    type Dst = ShOrHrr<'a>;
-    type RefSrc = ShOrHrrInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateEntryOpaqueMapper {
+    type Src = CertificateEntryOpaqueInner<'a>;
+    type Dst = CertificateEntryOpaque<'a>;
+    type RefSrc = CertificateEntryOpaqueInnerRef<'a>;
 }
-pub const SHORHRRLEGACY_VERSION_CONST: u16 = 771;
-
-pub struct SpecShOrHrrCombinator(pub SpecShOrHrrCombinatorAlias);
+type SpecCertificateEntryOpaqueCombinatorAlias1 = (SpecOpaque1FfffffCombinator, SpecCertificateExtensionsCombinator);
+pub struct SpecCertificateEntryOpaqueCombinator(pub SpecCertificateEntryOpaqueCombinatorAlias);
 
-impl SpecCombinator for SpecShOrHrrCombinator {
-    type Type = SpecShOrHrr;
+impl SpecCombinator for SpecCertificateEntryOpaqueCombinator {
+    type Type = SpecCertificateEntryOpaque;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecShOrHrrCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecShOrHrrCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateEntryOpaqueCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateEntryOpaqueCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecShOrHrrCombinatorAlias = Mapped<SpecPair<(Refined<U16Be, TagPred<u16>>, bytes::Fixed<32>), SpecShOrHrrPayloadCombinator>, ShOrHrrMapper>;
+pub type SpecCertificateEntryOpaqueCombinatorAlias = Mapped<SpecCertificateEntryOpaqueCombinatorAlias1, CertificateEntryOpaqueMapper>;
+type CertificateEntryOpaqueCombinatorAlias1 = (Opaque1FfffffCombinator, CertificateExtensionsCombinator);
+pub struct CertificateEntryOpaqueCombinator1(pub CertificateEntryOpaqueCombinatorAlias1);
+impl View for CertificateEntryOpaqueCombinator1 {
+    type V = SpecCertificateEntryOpaqueCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateEntryOpaqueCombinator1, CertificateEntryOpaqueCombinatorAlias1);
 
-pub struct ShOrHrrCombinator(pub ShOrHrrCombinatorAlias);
+pub struct CertificateEntryOpaqueCombinator(pub CertificateEntryOpaqueCombinatorAlias);
 
-impl View for ShOrHrrCombinator {
-    type V = SpecShOrHrrCombinator;
-    open spec fn view(&self) -> Self::V { SpecShOrHrrCombinator(self.0@) }
+impl View for CertificateEntryOpaqueCombinator {
+    type V = SpecCertificateEntryOpaqueCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateEntryOpaqueCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ShOrHrrCombinator {
-    type Type = ShOrHrr<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateEntryOpaqueCombinator {
+    type Type = CertificateEntryOpaque<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ShOrHrrCombinatorAlias = Mapped<Pair<(Refined<U16Be, TagPred<u16>>, bytes::Fixed<32>), ShOrHrrPayloadCombinator, ShOrHrrCont0>, ShOrHrrMapper>;
+}
+pub type CertificateEntryOpaqueCombinatorAlias = Mapped<CertificateEntryOpaqueCombinator1, CertificateEntryOpaqueMapper>;
 
 
-pub open spec fn spec_sh_or_hrr() -> SpecShOrHrrCombinator {
-    SpecShOrHrrCombinator(
+pub open spec fn spec_certificate_entry_opaque() -> SpecCertificateEntryOpaqueCombinator {
+    SpecCertificateEntryOpaqueCombinator(
     Mapped {
-        inner: Pair::spec_new((Refined { inner: U16Be, predicate: TagPred(SHORHRRLEGACY_VERSION_CONST) }, bytes::Fixed::<32>), |deps| spec_sh_or_hrr_cont0(deps)),
-        mapper: ShOrHrrMapper,
+        inner: (spec_opaque_1_ffffff(), spec_certificate_extensions()),
+        mapper: CertificateEntryOpaqueMapper,
     })
 }
 
-pub open spec fn spec_sh_or_hrr_cont0(deps: (u16, Seq<u8>)) -> SpecShOrHrrPayloadCombinator {
-    let (_, random) = deps;
-    spec_sh_or_hrr_payload(random)
-}
-
-impl View for ShOrHrrCont0 {
-    type V = spec_fn((u16, Seq<u8>)) -> SpecShOrHrrPayloadCombinator;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: (u16, Seq<u8>)| {
-            spec_sh_or_hrr_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn sh_or_hrr<'a>() -> (o: ShOrHrrCombinator)
-    ensures o@ == spec_sh_or_hrr(),
+pub fn certificate_entry_opaque<'a>() -> (o: CertificateEntryOpaqueCombinator)
+    ensures o@ == spec_certificate_entry_opaque(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ShOrHrrCombinator(
+    let combinator = CertificateEntryOpaqueCombinator(
     Mapped {
-        inner: Pair::new((Refined { inner: U16Be, predicate: TagPred(SHORHRRLEGACY_VERSION_CONST) }, bytes::Fixed::<32>), ShOrHrrCont0),
-        mapper: ShOrHrrMapper,
-    });
-    assert({
-        &&& combinator@ == spec_sh_or_hrr()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: CertificateEntryOpaqueCombinator1((opaque_1_ffffff(), certificate_extensions())),
+        mapper: CertificateEntryOpaqueMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_entry_opaque()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_sh_or_hrr<'a>(input: &'a [u8]) -> (res: PResult<<ShOrHrrCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_entry_opaque<'a>(input: &'a [u8]) -> (res: PResult<<CertificateEntryOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_sh_or_hrr().spec_parse(input@) == Some((n as int, v@)),
-        spec_sh_or_hrr().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_entry_opaque().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_entry_opaque().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_sh_or_hrr().spec_parse(input@) is None,
-        spec_sh_or_hrr().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_entry_opaque().spec_parse(input@) is None,
+        spec_certificate_entry_opaque().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = sh_or_hrr();
+    let combinator = certificate_entry_opaque();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_sh_or_hrr<'a>(v: <ShOrHrrCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_entry_opaque<'a>(v: <CertificateEntryOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_sh_or_hrr().wf(v@),
+        spec_certificate_entry_opaque().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_sh_or_hrr().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_sh_or_hrr().spec_serialize(v@))
+            &&& n == spec_certificate_entry_opaque().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_entry_opaque().spec_serialize(v@))
         },
 {
-    let combinator = sh_or_hrr();
+    let combinator = certificate_entry_opaque();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn sh_or_hrr_len<'a>(v: <ShOrHrrCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_entry_opaque_len<'a>(v: <CertificateEntryOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_sh_or_hrr().wf(v@),
-        spec_sh_or_hrr().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_entry_opaque().wf(v@),
+        spec_certificate_entry_opaque().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_sh_or_hrr().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_entry_opaque().spec_serialize(v@).len(),
 {
-    let combinator = sh_or_hrr();
+    let combinator = certificate_entry_opaque();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ShOrHrrCont0;
-type ShOrHrrCont0Type<'a, 'b> = &'b (u16, &'a [u8]);
-type ShOrHrrCont0SType<'a, 'x> = (&'x u16, &'x &'a [u8]);
-type ShOrHrrCont0Input<'a, 'b, 'x> = POrSType<ShOrHrrCont0Type<'a, 'b>, ShOrHrrCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ShOrHrrCont0Input<'a, 'b, 'x>> for ShOrHrrCont0 {
-    type Output = ShOrHrrPayloadCombinator;
-
-    open spec fn requires(&self, deps: ShOrHrrCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: ShOrHrrCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_sh_or_hrr_cont0(deps@)
-    }
-
-    fn apply(&self, deps: ShOrHrrCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let (_, random) = *deps;
-                sh_or_hrr_payload(random)
-            }
-            POrSType::S(deps) => {
-                let (_, random) = deps;
-                let random = *random;
-                sh_or_hrr_payload(random)
-            }
-        }
-    }
-}
                 
 
-pub enum SpecCertificateEntryData {
-    X509(SpecOpaque1Ffffff),
-    RawPublicKey(SpecOpaque1Ffffff),
+pub struct SpecCertificateList {
+    pub l: u24,
+    pub list: Seq<SpecCertificateEntryOpaque>,
 }
 
-pub type SpecCertificateEntryDataInner = Either<SpecOpaque1Ffffff, SpecOpaque1Ffffff>;
+pub type SpecCertificateListInner = (u24, Seq<SpecCertificateEntryOpaque>);
 
-impl SpecFrom<SpecCertificateEntryData> for SpecCertificateEntryDataInner {
-    open spec fn spec_from(m: SpecCertificateEntryData) -> SpecCertificateEntryDataInner {
-        match m {
-            SpecCertificateEntryData::X509(m) => Either::Left(m),
-            SpecCertificateEntryData::RawPublicKey(m) => Either::Right(m),
-        }
-    }
 
+impl SpecFrom<SpecCertificateList> for SpecCertificateListInner {
+    open spec fn spec_from(m: SpecCertificateList) -> SpecCertificateListInner {
+        (m.l, m.list)
+    }
 }
 
-                
-impl SpecFrom<SpecCertificateEntryDataInner> for SpecCertificateEntryData {
-    open spec fn spec_from(m: SpecCertificateEntryDataInner) -> SpecCertificateEntryData {
-        match m {
-            Either::Left(m) => SpecCertificateEntryData::X509(m),
-            Either::Right(m) => SpecCertificateEntryData::RawPublicKey(m),
-        }
+impl SpecFrom<SpecCertificateListInner> for SpecCertificateList {
+    open spec fn spec_from(m: SpecCertificateListInner) -> SpecCertificateList {
+        let (l, list) = m;
+        SpecCertificateList { l, list }
     }
-
 }
-
-
-
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum CertificateEntryData<'a> {
-    X509(Opaque1Ffffff<'a>),
-    RawPublicKey(Opaque1Ffffff<'a>),
-}
-
-pub type CertificateEntryDataInner<'a> = Either<Opaque1Ffffff<'a>, Opaque1Ffffff<'a>>;
 
-pub type CertificateEntryDataInnerRef<'a> = Either<&'a Opaque1Ffffff<'a>, &'a Opaque1Ffffff<'a>>;
+pub struct CertificateList<'a> {
+    pub l: u24,
+    pub list: RepeatResult<CertificateEntryOpaque<'a>>,
+}
 
+impl View for CertificateList<'_> {
+    type V = SpecCertificateList;
 
-impl<'a> View for CertificateEntryData<'a> {
-    type V = SpecCertificateEntryData;
     open spec fn view(&self) -> Self::V {
-        match self {
-            CertificateEntryData::X509(m) => SpecCertificateEntryData::X509(m@),
-            CertificateEntryData::RawPublicKey(m) => SpecCertificateEntryData::RawPublicKey(m@),
+        SpecCertificateList {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
+pub type CertificateListInner<'a> = (u24, RepeatResult<CertificateEntryOpaque<'a>>);
 
-
-impl<'a> From<&'a CertificateEntryData<'a>> for CertificateEntryDataInnerRef<'a> {
-    fn ex_from(m: &'a CertificateEntryData<'a>) -> CertificateEntryDataInnerRef<'a> {
-        match m {
-            CertificateEntryData::X509(m) => Either::Left(m),
-            CertificateEntryData::RawPublicKey(m) => Either::Right(m),
-        }
+pub type CertificateListInnerRef<'a> = (&'a u24, &'a RepeatResult<CertificateEntryOpaque<'a>>);
+impl<'a> From<&'a CertificateList<'a>> for CertificateListInnerRef<'a> {
+    fn ex_from(m: &'a CertificateList) -> CertificateListInnerRef<'a> {
+        (&m.l, &m.list)
     }
-
 }
 
-impl<'a> From<CertificateEntryDataInner<'a>> for CertificateEntryData<'a> {
-    fn ex_from(m: CertificateEntryDataInner<'a>) -> CertificateEntryData<'a> {
-        match m {
-            Either::Left(m) => CertificateEntryData::X509(m),
-            Either::Right(m) => CertificateEntryData::RawPublicKey(m),
-        }
+impl<'a> From<CertificateListInner<'a>> for CertificateList<'a> {
+    fn ex_from(m: CertificateListInner) -> CertificateList {
+        let (l, list) = m;
+        CertificateList { l, list }
     }
-    
 }
 
-
-pub struct CertificateEntryDataMapper;
-impl View for CertificateEntryDataMapper {
+pub struct CertificateListMapper;
+impl View for CertificateListMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateEntryDataMapper {
-    type Src = SpecCertificateEntryDataInner;
-    type Dst = SpecCertificateEntryData;
+impl SpecIso for CertificateListMapper {
+    type Src = SpecCertificateListInner;
+    type Dst = SpecCertificateList;
 }
-impl SpecIsoProof for CertificateEntryDataMapper {
+impl SpecIsoProof for CertificateListMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -20345,197 +19422,245 @@ impl SpecIsoProof for CertificateEntryDataMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateEntryDataMapper {
-    type Src = CertificateEntryDataInner<'a>;
-    type Dst = CertificateEntryData<'a>;
-    type RefSrc = CertificateEntryDataInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateListMapper {
+    type Src = CertificateListInner<'a>;
+    type Dst = CertificateList<'a>;
+    type RefSrc = CertificateListInnerRef<'a>;
 }
 
-type SpecCertificateEntryDataCombinatorAlias1 = Choice<Cond<SpecOpaque1FfffffCombinator>, Cond<SpecOpaque1FfffffCombinator>>;
-pub struct SpecCertificateEntryDataCombinator(pub SpecCertificateEntryDataCombinatorAlias);
+pub struct SpecCertificateListCombinator(pub SpecCertificateListCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateEntryDataCombinator {
-    type Type = SpecCertificateEntryData;
+impl SpecCombinator for SpecCertificateListCombinator {
+    type Type = SpecCertificateList;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateEntryDataCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateEntryDataCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateListCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateListCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateEntryDataCombinatorAlias = Mapped<SpecCertificateEntryDataCombinatorAlias1, CertificateEntryDataMapper>;
-type CertificateEntryDataCombinatorAlias1 = Choice<Cond<Opaque1FfffffCombinator>, Cond<Opaque1FfffffCombinator>>;
-pub struct CertificateEntryDataCombinator1(pub CertificateEntryDataCombinatorAlias1);
-impl View for CertificateEntryDataCombinator1 {
-    type V = SpecCertificateEntryDataCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateEntryDataCombinator1, CertificateEntryDataCombinatorAlias1);
+pub type SpecCertificateListCombinatorAlias = Mapped<SpecPair<U24Be, AndThen<bytes::Variable, Repeat<SpecCertificateEntryOpaqueCombinator>>>, CertificateListMapper>;
 
-pub struct CertificateEntryDataCombinator(pub CertificateEntryDataCombinatorAlias);
+pub struct CertificateListCombinator(pub CertificateListCombinatorAlias);
 
-impl View for CertificateEntryDataCombinator {
-    type V = SpecCertificateEntryDataCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateEntryDataCombinator(self.0@) }
+impl View for CertificateListCombinator {
+    type V = SpecCertificateListCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateListCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateEntryDataCombinator {
-    type Type = CertificateEntryData<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateListCombinator {
+    type Type = CertificateList<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateEntryDataCombinatorAlias = Mapped<CertificateEntryDataCombinator1, CertificateEntryDataMapper>;
+}
+pub type CertificateListCombinatorAlias = Mapped<Pair<U24Be, AndThen<bytes::Variable, Repeat<CertificateEntryOpaqueCombinator>>, CertificateListCont0>, CertificateListMapper>;
 
 
-pub open spec fn spec_certificate_entry_data(cert_type: u8) -> SpecCertificateEntryDataCombinator {
-    SpecCertificateEntryDataCombinator(Mapped { inner: Choice(Cond { cond: cert_type == CertificateType::SPEC_X509, inner: spec_opaque_1_ffffff() }, Cond { cond: cert_type == CertificateType::SPEC_RawPublicKey, inner: spec_opaque_1_ffffff() }), mapper: CertificateEntryDataMapper })
+pub open spec fn spec_certificate_list() -> SpecCertificateListCombinator {
+    SpecCertificateListCombinator(
+    Mapped {
+        inner: Pair::spec_new(U24Be, |deps| spec_certificate_list_cont0(deps)),
+        mapper: CertificateListMapper,
+    })
 }
 
-pub fn certificate_entry_data<'a>(cert_type: u8) -> (o: CertificateEntryDataCombinator)
-    ensures o@ == spec_certificate_entry_data(cert_type@),
+pub open spec fn spec_certificate_list_cont0(deps: u24) -> AndThen<bytes::Variable, Repeat<SpecCertificateEntryOpaqueCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_certificate_entry_opaque()))
+}
+
+impl View for CertificateListCont0 {
+    type V = spec_fn(u24) -> AndThen<bytes::Variable, Repeat<SpecCertificateEntryOpaqueCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u24| {
+            spec_certificate_list_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn certificate_list<'a>() -> (o: CertificateListCombinator)
+    ensures o@ == spec_certificate_list(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateEntryDataCombinator(Mapped { inner: CertificateEntryDataCombinator1(Choice::new(Cond { cond: cert_type == CertificateType::X509, inner: opaque_1_ffffff() }, Cond { cond: cert_type == CertificateType::RawPublicKey, inner: opaque_1_ffffff() })), mapper: CertificateEntryDataMapper });
-    assert({
-        &&& combinator@ == spec_certificate_entry_data(cert_type@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = CertificateListCombinator(
+    Mapped {
+        inner: Pair::new(U24Be, CertificateListCont0),
+        mapper: CertificateListMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_list()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_entry_data<'a>(input: &'a [u8], cert_type: u8) -> (res: PResult<<CertificateEntryDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_list<'a>(input: &'a [u8]) -> (res: PResult<<CertificateListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_entry_data(cert_type@).spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_entry_data(cert_type@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_list().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_list().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_entry_data(cert_type@).spec_parse(input@) is None,
-        spec_certificate_entry_data(cert_type@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_list().spec_parse(input@) is None,
+        spec_certificate_list().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_entry_data( cert_type );
+    let combinator = certificate_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_entry_data<'a>(v: <CertificateEntryDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, cert_type: u8) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_list<'a>(v: <CertificateListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_entry_data(cert_type@).wf(v@),
+        spec_certificate_list().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_entry_data(cert_type@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_entry_data(cert_type@).spec_serialize(v@))
+            &&& n == spec_certificate_list().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_list().spec_serialize(v@))
         },
 {
-    let combinator = certificate_entry_data( cert_type );
-    combinator.serialize(v, data, pos)
+    let combinator = certificate_list();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_entry_data_len<'a>(v: <CertificateEntryDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, cert_type: u8) -> (serialize_len: usize)
+pub fn certificate_list_len<'a>(v: <CertificateListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_entry_data(cert_type@).wf(v@),
-        spec_certificate_entry_data(cert_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_list().wf(v@),
+        spec_certificate_list().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_entry_data(cert_type@).spec_serialize(v@).len(),
+        serialize_len == spec_certificate_list().spec_serialize(v@).len(),
 {
-    let combinator = certificate_entry_data( cert_type );
+    let combinator = certificate_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct CertificateListCont0;
+type CertificateListCont0Type<'a, 'b> = &'b u24;
+type CertificateListCont0SType<'a, 'x> = &'x u24;
+type CertificateListCont0Input<'a, 'b, 'x> = POrSType<CertificateListCont0Type<'a, 'b>, CertificateListCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CertificateListCont0Input<'a, 'b, 'x>> for CertificateListCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<CertificateEntryOpaqueCombinator>>;
 
-pub struct SpecNewSessionTicketExtensions {
-    pub l: u16,
-    pub list: Seq<SpecNewSessionTicketExtension>,
-}
-
-pub type SpecNewSessionTicketExtensionsInner = (u16, Seq<SpecNewSessionTicketExtension>);
-
+    open spec fn requires(&self, deps: CertificateListCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U24Be).wf(deps@)
+        }
 
-impl SpecFrom<SpecNewSessionTicketExtensions> for SpecNewSessionTicketExtensionsInner {
-    open spec fn spec_from(m: SpecNewSessionTicketExtensions) -> SpecNewSessionTicketExtensionsInner {
-        (m.l, m.list)
+    open spec fn ensures(&self, deps: CertificateListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_certificate_list_cont0(deps@)
     }
-}
 
-impl SpecFrom<SpecNewSessionTicketExtensionsInner> for SpecNewSessionTicketExtensions {
-    open spec fn spec_from(m: SpecNewSessionTicketExtensionsInner) -> SpecNewSessionTicketExtensions {
-        let (l, list) = m;
-        SpecNewSessionTicketExtensions { l, list }
+    fn apply(&self, deps: CertificateListCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(certificate_entry_opaque()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(certificate_entry_opaque()))
+            }
+        }
+    }
+}
+                
+
+pub struct SpecCertificate {
+    pub certificate_request_context: SpecOpaque0Ff,
+    pub certificate_list: SpecCertificateList,
+}
+
+pub type SpecCertificateInner = (SpecOpaque0Ff, SpecCertificateList);
+
+
+impl SpecFrom<SpecCertificate> for SpecCertificateInner {
+    open spec fn spec_from(m: SpecCertificate) -> SpecCertificateInner {
+        (m.certificate_request_context, m.certificate_list)
+    }
+}
+
+impl SpecFrom<SpecCertificateInner> for SpecCertificate {
+    open spec fn spec_from(m: SpecCertificateInner) -> SpecCertificate {
+        let (certificate_request_context, certificate_list) = m;
+        SpecCertificate { certificate_request_context, certificate_list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct NewSessionTicketExtensions<'a> {
-    pub l: u16,
-    pub list: RepeatResult<NewSessionTicketExtension<'a>>,
+pub struct Certificate<'a> {
+    pub certificate_request_context: Opaque0Ff<'a>,
+    pub certificate_list: CertificateList<'a>,
 }
 
-impl View for NewSessionTicketExtensions<'_> {
-    type V = SpecNewSessionTicketExtensions;
+impl View for Certificate<'_> {
+    type V = SpecCertificate;
 
     open spec fn view(&self) -> Self::V {
-        SpecNewSessionTicketExtensions {
-            l: self.l@,
-            list: self.list@,
+        SpecCertificate {
+            certificate_request_context: self.certificate_request_context@,
+            certificate_list: self.certificate_list@,
         }
     }
 }
-pub type NewSessionTicketExtensionsInner<'a> = (u16, RepeatResult<NewSessionTicketExtension<'a>>);
+pub type CertificateInner<'a> = (Opaque0Ff<'a>, CertificateList<'a>);
 
-pub type NewSessionTicketExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<NewSessionTicketExtension<'a>>);
-impl<'a> From<&'a NewSessionTicketExtensions<'a>> for NewSessionTicketExtensionsInnerRef<'a> {
-    fn ex_from(m: &'a NewSessionTicketExtensions) -> NewSessionTicketExtensionsInnerRef<'a> {
-        (&m.l, &m.list)
+pub type CertificateInnerRef<'a> = (&'a Opaque0Ff<'a>, &'a CertificateList<'a>);
+impl<'a> From<&'a Certificate<'a>> for CertificateInnerRef<'a> {
+    fn ex_from(m: &'a Certificate) -> CertificateInnerRef<'a> {
+        (&m.certificate_request_context, &m.certificate_list)
     }
 }
 
-impl<'a> From<NewSessionTicketExtensionsInner<'a>> for NewSessionTicketExtensions<'a> {
-    fn ex_from(m: NewSessionTicketExtensionsInner) -> NewSessionTicketExtensions {
-        let (l, list) = m;
-        NewSessionTicketExtensions { l, list }
+impl<'a> From<CertificateInner<'a>> for Certificate<'a> {
+    fn ex_from(m: CertificateInner) -> Certificate {
+        let (certificate_request_context, certificate_list) = m;
+        Certificate { certificate_request_context, certificate_list }
     }
 }
 
-pub struct NewSessionTicketExtensionsMapper;
-impl View for NewSessionTicketExtensionsMapper {
+pub struct CertificateMapper;
+impl View for CertificateMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for NewSessionTicketExtensionsMapper {
-    type Src = SpecNewSessionTicketExtensionsInner;
-    type Dst = SpecNewSessionTicketExtensions;
+impl SpecIso for CertificateMapper {
+    type Src = SpecCertificateInner;
+    type Dst = SpecCertificate;
 }
-impl SpecIsoProof for NewSessionTicketExtensionsMapper {
+impl SpecIsoProof for CertificateMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -20543,270 +19668,206 @@ impl SpecIsoProof for NewSessionTicketExtensionsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for NewSessionTicketExtensionsMapper {
-    type Src = NewSessionTicketExtensionsInner<'a>;
-    type Dst = NewSessionTicketExtensions<'a>;
-    type RefSrc = NewSessionTicketExtensionsInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateMapper {
+    type Src = CertificateInner<'a>;
+    type Dst = Certificate<'a>;
+    type RefSrc = CertificateInnerRef<'a>;
 }
+type SpecCertificateCombinatorAlias1 = (SpecOpaque0FfCombinator, SpecCertificateListCombinator);
+pub struct SpecCertificateCombinator(pub SpecCertificateCombinatorAlias);
 
-pub struct SpecNewSessionTicketExtensionsCombinator(pub SpecNewSessionTicketExtensionsCombinatorAlias);
-
-impl SpecCombinator for SpecNewSessionTicketExtensionsCombinator {
-    type Type = SpecNewSessionTicketExtensions;
+impl SpecCombinator for SpecCertificateCombinator {
+    type Type = SpecCertificate;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecNewSessionTicketExtensionsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecNewSessionTicketExtensionsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecNewSessionTicketExtensionsCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate14514213152276180162>, AndThen<bytes::Variable, Repeat<SpecNewSessionTicketExtensionCombinator>>>, NewSessionTicketExtensionsMapper>;
-pub struct Predicate14514213152276180162;
-impl View for Predicate14514213152276180162 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u16> for Predicate14514213152276180162 {
-    fn apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 0 && i <= 65534)
-    }
-}
-impl SpecPred<u16> for Predicate14514213152276180162 {
-    open spec fn spec_apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 0 && i <= 65534)
-    }
+pub type SpecCertificateCombinatorAlias = Mapped<SpecCertificateCombinatorAlias1, CertificateMapper>;
+type CertificateCombinatorAlias1 = (Opaque0FfCombinator, CertificateListCombinator);
+pub struct CertificateCombinator1(pub CertificateCombinatorAlias1);
+impl View for CertificateCombinator1 {
+    type V = SpecCertificateCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(CertificateCombinator1, CertificateCombinatorAlias1);
 
-pub struct NewSessionTicketExtensionsCombinator(pub NewSessionTicketExtensionsCombinatorAlias);
+pub struct CertificateCombinator(pub CertificateCombinatorAlias);
 
-impl View for NewSessionTicketExtensionsCombinator {
-    type V = SpecNewSessionTicketExtensionsCombinator;
-    open spec fn view(&self) -> Self::V { SpecNewSessionTicketExtensionsCombinator(self.0@) }
+impl View for CertificateCombinator {
+    type V = SpecCertificateCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NewSessionTicketExtensionsCombinator {
-    type Type = NewSessionTicketExtensions<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateCombinator {
+    type Type = Certificate<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type NewSessionTicketExtensionsCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate14514213152276180162>, AndThen<bytes::Variable, Repeat<NewSessionTicketExtensionCombinator>>, NewSessionTicketExtensionsCont0>, NewSessionTicketExtensionsMapper>;
+}
+pub type CertificateCombinatorAlias = Mapped<CertificateCombinator1, CertificateMapper>;
 
 
-pub open spec fn spec_new_session_ticket_extensions() -> SpecNewSessionTicketExtensionsCombinator {
-    SpecNewSessionTicketExtensionsCombinator(
+pub open spec fn spec_certificate() -> SpecCertificateCombinator {
+    SpecCertificateCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate14514213152276180162 }, |deps| spec_new_session_ticket_extensions_cont0(deps)),
-        mapper: NewSessionTicketExtensionsMapper,
+        inner: (spec_opaque_0_ff(), spec_certificate_list()),
+        mapper: CertificateMapper,
     })
 }
 
-pub open spec fn spec_new_session_ticket_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecNewSessionTicketExtensionCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_new_session_ticket_extension()))
-}
-
-impl View for NewSessionTicketExtensionsCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecNewSessionTicketExtensionCombinator>>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_new_session_ticket_extensions_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn new_session_ticket_extensions<'a>() -> (o: NewSessionTicketExtensionsCombinator)
-    ensures o@ == spec_new_session_ticket_extensions(),
+pub fn certificate<'a>() -> (o: CertificateCombinator)
+    ensures o@ == spec_certificate(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = NewSessionTicketExtensionsCombinator(
+    let combinator = CertificateCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate14514213152276180162 }, NewSessionTicketExtensionsCont0),
-        mapper: NewSessionTicketExtensionsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_new_session_ticket_extensions()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: CertificateCombinator1((opaque_0_ff(), certificate_list())),
+        mapper: CertificateMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_new_session_ticket_extensions<'a>(input: &'a [u8]) -> (res: PResult<<NewSessionTicketExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate<'a>(input: &'a [u8]) -> (res: PResult<<CertificateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_new_session_ticket_extensions().spec_parse(input@) == Some((n as int, v@)),
-        spec_new_session_ticket_extensions().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_new_session_ticket_extensions().spec_parse(input@) is None,
-        spec_new_session_ticket_extensions().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate().spec_parse(input@) is None,
+        spec_certificate().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = new_session_ticket_extensions();
+    let combinator = certificate();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_new_session_ticket_extensions<'a>(v: <NewSessionTicketExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate<'a>(v: <CertificateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_new_session_ticket_extensions().wf(v@),
+        spec_certificate().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_new_session_ticket_extensions().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_new_session_ticket_extensions().spec_serialize(v@))
+            &&& n == spec_certificate().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate().spec_serialize(v@))
         },
 {
-    let combinator = new_session_ticket_extensions();
+    let combinator = certificate();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn new_session_ticket_extensions_len<'a>(v: <NewSessionTicketExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_len<'a>(v: <CertificateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_new_session_ticket_extensions().wf(v@),
-        spec_new_session_ticket_extensions().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate().wf(v@),
+        spec_certificate().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_new_session_ticket_extensions().spec_serialize(v@).len(),
+        serialize_len == spec_certificate().spec_serialize(v@).len(),
 {
-    let combinator = new_session_ticket_extensions();
+    let combinator = certificate();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct NewSessionTicketExtensionsCont0;
-type NewSessionTicketExtensionsCont0Type<'a, 'b> = &'b u16;
-type NewSessionTicketExtensionsCont0SType<'a, 'x> = &'x u16;
-type NewSessionTicketExtensionsCont0Input<'a, 'b, 'x> = POrSType<NewSessionTicketExtensionsCont0Type<'a, 'b>, NewSessionTicketExtensionsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<NewSessionTicketExtensionsCont0Input<'a, 'b, 'x>> for NewSessionTicketExtensionsCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<NewSessionTicketExtensionCombinator>>;
+                
+
+pub struct SpecCertificateRequestExtensions {
+    pub l: u16,
+    pub list: Seq<SpecCertificateRequestExtension>,
+}
 
-    open spec fn requires(&self, deps: NewSessionTicketExtensionsCont0Input<'a, 'b, 'x>) -> bool { true }
+pub type SpecCertificateRequestExtensionsInner = (u16, Seq<SpecCertificateRequestExtension>);
 
-    open spec fn ensures(&self, deps: NewSessionTicketExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_new_session_ticket_extensions_cont0(deps@)
+
+impl SpecFrom<SpecCertificateRequestExtensions> for SpecCertificateRequestExtensionsInner {
+    open spec fn spec_from(m: SpecCertificateRequestExtensions) -> SpecCertificateRequestExtensionsInner {
+        (m.l, m.list)
     }
+}
 
-    fn apply(&self, deps: NewSessionTicketExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(new_session_ticket_extension()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(new_session_ticket_extension()))
-            }
-        }
+impl SpecFrom<SpecCertificateRequestExtensionsInner> for SpecCertificateRequestExtensions {
+    open spec fn spec_from(m: SpecCertificateRequestExtensionsInner) -> SpecCertificateRequestExtensions {
+        let (l, list) = m;
+        SpecCertificateRequestExtensions { l, list }
     }
 }
-                
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct SpecNewSessionTicket {
-    pub ticket_lifetime: u32,
-    pub ticket_age_add: u32,
-    pub ticket_nonce: SpecOpaque0Ff,
-    pub ticket: SpecOpaque1Ffff,
-    pub extensions: SpecNewSessionTicketExtensions,
+pub struct CertificateRequestExtensions<'a> {
+    pub l: u16,
+    pub list: RepeatResult<CertificateRequestExtension<'a>>,
 }
 
-pub type SpecNewSessionTicketInner = (u32, (u32, (SpecOpaque0Ff, (SpecOpaque1Ffff, SpecNewSessionTicketExtensions))));
-
-
-impl SpecFrom<SpecNewSessionTicket> for SpecNewSessionTicketInner {
-    open spec fn spec_from(m: SpecNewSessionTicket) -> SpecNewSessionTicketInner {
-        (m.ticket_lifetime, (m.ticket_age_add, (m.ticket_nonce, (m.ticket, m.extensions))))
-    }
-}
-
-impl SpecFrom<SpecNewSessionTicketInner> for SpecNewSessionTicket {
-    open spec fn spec_from(m: SpecNewSessionTicketInner) -> SpecNewSessionTicket {
-        let (ticket_lifetime, (ticket_age_add, (ticket_nonce, (ticket, extensions)))) = m;
-        SpecNewSessionTicket { ticket_lifetime, ticket_age_add, ticket_nonce, ticket, extensions }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct NewSessionTicket<'a> {
-    pub ticket_lifetime: u32,
-    pub ticket_age_add: u32,
-    pub ticket_nonce: Opaque0Ff<'a>,
-    pub ticket: Opaque1Ffff<'a>,
-    pub extensions: NewSessionTicketExtensions<'a>,
-}
-
-impl View for NewSessionTicket<'_> {
-    type V = SpecNewSessionTicket;
+impl View for CertificateRequestExtensions<'_> {
+    type V = SpecCertificateRequestExtensions;
 
     open spec fn view(&self) -> Self::V {
-        SpecNewSessionTicket {
-            ticket_lifetime: self.ticket_lifetime@,
-            ticket_age_add: self.ticket_age_add@,
-            ticket_nonce: self.ticket_nonce@,
-            ticket: self.ticket@,
-            extensions: self.extensions@,
+        SpecCertificateRequestExtensions {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
-pub type NewSessionTicketInner<'a> = (u32, (u32, (Opaque0Ff<'a>, (Opaque1Ffff<'a>, NewSessionTicketExtensions<'a>))));
+pub type CertificateRequestExtensionsInner<'a> = (u16, RepeatResult<CertificateRequestExtension<'a>>);
 
-pub type NewSessionTicketInnerRef<'a> = (&'a u32, (&'a u32, (&'a Opaque0Ff<'a>, (&'a Opaque1Ffff<'a>, &'a NewSessionTicketExtensions<'a>))));
-impl<'a> From<&'a NewSessionTicket<'a>> for NewSessionTicketInnerRef<'a> {
-    fn ex_from(m: &'a NewSessionTicket) -> NewSessionTicketInnerRef<'a> {
-        (&m.ticket_lifetime, (&m.ticket_age_add, (&m.ticket_nonce, (&m.ticket, &m.extensions))))
+pub type CertificateRequestExtensionsInnerRef<'a> = (&'a u16, &'a RepeatResult<CertificateRequestExtension<'a>>);
+impl<'a> From<&'a CertificateRequestExtensions<'a>> for CertificateRequestExtensionsInnerRef<'a> {
+    fn ex_from(m: &'a CertificateRequestExtensions) -> CertificateRequestExtensionsInnerRef<'a> {
+        (&m.l, &m.list)
     }
 }
 
-impl<'a> From<NewSessionTicketInner<'a>> for NewSessionTicket<'a> {
-    fn ex_from(m: NewSessionTicketInner) -> NewSessionTicket {
-        let (ticket_lifetime, (ticket_age_add, (ticket_nonce, (ticket, extensions)))) = m;
-        NewSessionTicket { ticket_lifetime, ticket_age_add, ticket_nonce, ticket, extensions }
+impl<'a> From<CertificateRequestExtensionsInner<'a>> for CertificateRequestExtensions<'a> {
+    fn ex_from(m: CertificateRequestExtensionsInner) -> CertificateRequestExtensions {
+        let (l, list) = m;
+        CertificateRequestExtensions { l, list }
     }
 }
 
-pub struct NewSessionTicketMapper;
-impl View for NewSessionTicketMapper {
+pub struct CertificateRequestExtensionsMapper;
+impl View for CertificateRequestExtensionsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for NewSessionTicketMapper {
-    type Src = SpecNewSessionTicketInner;
-    type Dst = SpecNewSessionTicket;
+impl SpecIso for CertificateRequestExtensionsMapper {
+    type Src = SpecCertificateRequestExtensionsInner;
+    type Dst = SpecCertificateRequestExtensions;
 }
-impl SpecIsoProof for NewSessionTicketMapper {
+impl SpecIsoProof for CertificateRequestExtensionsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -20814,230 +19875,245 @@ impl SpecIsoProof for NewSessionTicketMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for NewSessionTicketMapper {
-    type Src = NewSessionTicketInner<'a>;
-    type Dst = NewSessionTicket<'a>;
-    type RefSrc = NewSessionTicketInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateRequestExtensionsMapper {
+    type Src = CertificateRequestExtensionsInner<'a>;
+    type Dst = CertificateRequestExtensions<'a>;
+    type RefSrc = CertificateRequestExtensionsInnerRef<'a>;
 }
-type SpecNewSessionTicketCombinatorAlias1 = (SpecOpaque1FfffCombinator, SpecNewSessionTicketExtensionsCombinator);
-type SpecNewSessionTicketCombinatorAlias2 = (SpecOpaque0FfCombinator, SpecNewSessionTicketCombinatorAlias1);
-type SpecNewSessionTicketCombinatorAlias3 = (U32Be, SpecNewSessionTicketCombinatorAlias2);
-type SpecNewSessionTicketCombinatorAlias4 = (U32Be, SpecNewSessionTicketCombinatorAlias3);
-pub struct SpecNewSessionTicketCombinator(pub SpecNewSessionTicketCombinatorAlias);
 
-impl SpecCombinator for SpecNewSessionTicketCombinator {
-    type Type = SpecNewSessionTicket;
+pub struct SpecCertificateRequestExtensionsCombinator(pub SpecCertificateRequestExtensionsCombinatorAlias);
+
+impl SpecCombinator for SpecCertificateRequestExtensionsCombinator {
+    type Type = SpecCertificateRequestExtensions;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecNewSessionTicketCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecNewSessionTicketCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateRequestExtensionsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateRequestExtensionsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecNewSessionTicketCombinatorAlias = Mapped<SpecNewSessionTicketCombinatorAlias4, NewSessionTicketMapper>;
-type NewSessionTicketCombinatorAlias1 = (Opaque1FfffCombinator, NewSessionTicketExtensionsCombinator);
-type NewSessionTicketCombinatorAlias2 = (Opaque0FfCombinator, NewSessionTicketCombinator1);
-type NewSessionTicketCombinatorAlias3 = (U32Be, NewSessionTicketCombinator2);
-type NewSessionTicketCombinatorAlias4 = (U32Be, NewSessionTicketCombinator3);
-pub struct NewSessionTicketCombinator1(pub NewSessionTicketCombinatorAlias1);
-impl View for NewSessionTicketCombinator1 {
-    type V = SpecNewSessionTicketCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(NewSessionTicketCombinator1, NewSessionTicketCombinatorAlias1);
-
-pub struct NewSessionTicketCombinator2(pub NewSessionTicketCombinatorAlias2);
-impl View for NewSessionTicketCombinator2 {
-    type V = SpecNewSessionTicketCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(NewSessionTicketCombinator2, NewSessionTicketCombinatorAlias2);
-
-pub struct NewSessionTicketCombinator3(pub NewSessionTicketCombinatorAlias3);
-impl View for NewSessionTicketCombinator3 {
-    type V = SpecNewSessionTicketCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(NewSessionTicketCombinator3, NewSessionTicketCombinatorAlias3);
-
-pub struct NewSessionTicketCombinator4(pub NewSessionTicketCombinatorAlias4);
-impl View for NewSessionTicketCombinator4 {
-    type V = SpecNewSessionTicketCombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(NewSessionTicketCombinator4, NewSessionTicketCombinatorAlias4);
+pub type SpecCertificateRequestExtensionsCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<SpecCertificateRequestExtensionCombinator>>>, CertificateRequestExtensionsMapper>;
 
-pub struct NewSessionTicketCombinator(pub NewSessionTicketCombinatorAlias);
+pub struct CertificateRequestExtensionsCombinator(pub CertificateRequestExtensionsCombinatorAlias);
 
-impl View for NewSessionTicketCombinator {
-    type V = SpecNewSessionTicketCombinator;
-    open spec fn view(&self) -> Self::V { SpecNewSessionTicketCombinator(self.0@) }
+impl View for CertificateRequestExtensionsCombinator {
+    type V = SpecCertificateRequestExtensionsCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateRequestExtensionsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NewSessionTicketCombinator {
-    type Type = NewSessionTicket<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateRequestExtensionsCombinator {
+    type Type = CertificateRequestExtensions<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type NewSessionTicketCombinatorAlias = Mapped<NewSessionTicketCombinator4, NewSessionTicketMapper>;
+}
+pub type CertificateRequestExtensionsCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<CertificateRequestExtensionCombinator>>, CertificateRequestExtensionsCont0>, CertificateRequestExtensionsMapper>;
 
 
-pub open spec fn spec_new_session_ticket() -> SpecNewSessionTicketCombinator {
-    SpecNewSessionTicketCombinator(
+pub open spec fn spec_certificate_request_extensions() -> SpecCertificateRequestExtensionsCombinator {
+    SpecCertificateRequestExtensionsCombinator(
     Mapped {
-        inner: (U32Be, (U32Be, (spec_opaque_0_ff(), (spec_opaque_1_ffff(), spec_new_session_ticket_extensions())))),
-        mapper: NewSessionTicketMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, |deps| spec_certificate_request_extensions_cont0(deps)),
+        mapper: CertificateRequestExtensionsMapper,
     })
 }
 
+pub open spec fn spec_certificate_request_extensions_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecCertificateRequestExtensionCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_certificate_request_extension()))
+}
+
+impl View for CertificateRequestExtensionsCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecCertificateRequestExtensionCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_certificate_request_extensions_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn new_session_ticket<'a>() -> (o: NewSessionTicketCombinator)
-    ensures o@ == spec_new_session_ticket(),
+pub fn certificate_request_extensions<'a>() -> (o: CertificateRequestExtensionsCombinator)
+    ensures o@ == spec_certificate_request_extensions(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = NewSessionTicketCombinator(
+    let combinator = CertificateRequestExtensionsCombinator(
     Mapped {
-        inner: NewSessionTicketCombinator4((U32Be, NewSessionTicketCombinator3((U32Be, NewSessionTicketCombinator2((opaque_0_ff(), NewSessionTicketCombinator1((opaque_1_ffff(), new_session_ticket_extensions())))))))),
-        mapper: NewSessionTicketMapper,
-    });
-    assert({
-        &&& combinator@ == spec_new_session_ticket()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, CertificateRequestExtensionsCont0),
+        mapper: CertificateRequestExtensionsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_request_extensions()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_new_session_ticket<'a>(input: &'a [u8]) -> (res: PResult<<NewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_request_extensions<'a>(input: &'a [u8]) -> (res: PResult<<CertificateRequestExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_new_session_ticket().spec_parse(input@) == Some((n as int, v@)),
-        spec_new_session_ticket().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_request_extensions().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_request_extensions().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_new_session_ticket().spec_parse(input@) is None,
-        spec_new_session_ticket().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_request_extensions().spec_parse(input@) is None,
+        spec_certificate_request_extensions().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = new_session_ticket();
+    let combinator = certificate_request_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_new_session_ticket<'a>(v: <NewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_request_extensions<'a>(v: <CertificateRequestExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_new_session_ticket().wf(v@),
+        spec_certificate_request_extensions().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_new_session_ticket().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_new_session_ticket().spec_serialize(v@))
+            &&& n == spec_certificate_request_extensions().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_request_extensions().spec_serialize(v@))
         },
 {
-    let combinator = new_session_ticket();
+    let combinator = certificate_request_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn new_session_ticket_len<'a>(v: <NewSessionTicketCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_request_extensions_len<'a>(v: <CertificateRequestExtensionsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_new_session_ticket().wf(v@),
-        spec_new_session_ticket().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_request_extensions().wf(v@),
+        spec_certificate_request_extensions().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_new_session_ticket().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_request_extensions().spec_serialize(v@).len(),
 {
-    let combinator = new_session_ticket();
+    let combinator = certificate_request_extensions();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct CertificateRequestExtensionsCont0;
+type CertificateRequestExtensionsCont0Type<'a, 'b> = &'b u16;
+type CertificateRequestExtensionsCont0SType<'a, 'x> = &'x u16;
+type CertificateRequestExtensionsCont0Input<'a, 'b, 'x> = POrSType<CertificateRequestExtensionsCont0Type<'a, 'b>, CertificateRequestExtensionsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CertificateRequestExtensionsCont0Input<'a, 'b, 'x>> for CertificateRequestExtensionsCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<CertificateRequestExtensionCombinator>>;
+
+    open spec fn requires(&self, deps: CertificateRequestExtensionsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate8195707947578446211 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CertificateRequestExtensionsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_certificate_request_extensions_cont0(deps@)
+    }
+
+    fn apply(&self, deps: CertificateRequestExtensionsCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(certificate_request_extension()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(certificate_request_extension()))
+            }
+        }
+    }
+}
                 
 
-pub struct SpecClientCertTypeServerExtension {
-    pub client_certificate_type: u8,
+pub struct SpecCertificateRequest {
+    pub certificate_request_context: SpecOpaque0Ff,
+    pub extensions: SpecCertificateRequestExtensions,
 }
 
-pub type SpecClientCertTypeServerExtensionInner = u8;
+pub type SpecCertificateRequestInner = (SpecOpaque0Ff, SpecCertificateRequestExtensions);
 
 
-impl SpecFrom<SpecClientCertTypeServerExtension> for SpecClientCertTypeServerExtensionInner {
-    open spec fn spec_from(m: SpecClientCertTypeServerExtension) -> SpecClientCertTypeServerExtensionInner {
-        m.client_certificate_type
+impl SpecFrom<SpecCertificateRequest> for SpecCertificateRequestInner {
+    open spec fn spec_from(m: SpecCertificateRequest) -> SpecCertificateRequestInner {
+        (m.certificate_request_context, m.extensions)
     }
 }
 
-impl SpecFrom<SpecClientCertTypeServerExtensionInner> for SpecClientCertTypeServerExtension {
-    open spec fn spec_from(m: SpecClientCertTypeServerExtensionInner) -> SpecClientCertTypeServerExtension {
-        let client_certificate_type = m;
-        SpecClientCertTypeServerExtension { client_certificate_type }
+impl SpecFrom<SpecCertificateRequestInner> for SpecCertificateRequest {
+    open spec fn spec_from(m: SpecCertificateRequestInner) -> SpecCertificateRequest {
+        let (certificate_request_context, extensions) = m;
+        SpecCertificateRequest { certificate_request_context, extensions }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ClientCertTypeServerExtension {
-    pub client_certificate_type: u8,
+pub struct CertificateRequest<'a> {
+    pub certificate_request_context: Opaque0Ff<'a>,
+    pub extensions: CertificateRequestExtensions<'a>,
 }
 
-impl View for ClientCertTypeServerExtension {
-    type V = SpecClientCertTypeServerExtension;
+impl View for CertificateRequest<'_> {
+    type V = SpecCertificateRequest;
 
     open spec fn view(&self) -> Self::V {
-        SpecClientCertTypeServerExtension {
-            client_certificate_type: self.client_certificate_type@,
+        SpecCertificateRequest {
+            certificate_request_context: self.certificate_request_context@,
+            extensions: self.extensions@,
         }
     }
 }
-pub type ClientCertTypeServerExtensionInner = u8;
+pub type CertificateRequestInner<'a> = (Opaque0Ff<'a>, CertificateRequestExtensions<'a>);
 
-pub type ClientCertTypeServerExtensionInnerRef<'a> = &'a u8;
-impl<'a> From<&'a ClientCertTypeServerExtension> for ClientCertTypeServerExtensionInnerRef<'a> {
-    fn ex_from(m: &'a ClientCertTypeServerExtension) -> ClientCertTypeServerExtensionInnerRef<'a> {
-        &m.client_certificate_type
+pub type CertificateRequestInnerRef<'a> = (&'a Opaque0Ff<'a>, &'a CertificateRequestExtensions<'a>);
+impl<'a> From<&'a CertificateRequest<'a>> for CertificateRequestInnerRef<'a> {
+    fn ex_from(m: &'a CertificateRequest) -> CertificateRequestInnerRef<'a> {
+        (&m.certificate_request_context, &m.extensions)
     }
 }
 
-impl From<ClientCertTypeServerExtensionInner> for ClientCertTypeServerExtension {
-    fn ex_from(m: ClientCertTypeServerExtensionInner) -> ClientCertTypeServerExtension {
-        let client_certificate_type = m;
-        ClientCertTypeServerExtension { client_certificate_type }
+impl<'a> From<CertificateRequestInner<'a>> for CertificateRequest<'a> {
+    fn ex_from(m: CertificateRequestInner) -> CertificateRequest {
+        let (certificate_request_context, extensions) = m;
+        CertificateRequest { certificate_request_context, extensions }
     }
 }
 
-pub struct ClientCertTypeServerExtensionMapper;
-impl View for ClientCertTypeServerExtensionMapper {
+pub struct CertificateRequestMapper;
+impl View for CertificateRequestMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ClientCertTypeServerExtensionMapper {
-    type Src = SpecClientCertTypeServerExtensionInner;
-    type Dst = SpecClientCertTypeServerExtension;
+impl SpecIso for CertificateRequestMapper {
+    type Src = SpecCertificateRequestInner;
+    type Dst = SpecCertificateRequest;
 }
-impl SpecIsoProof for ClientCertTypeServerExtensionMapper {
+impl SpecIsoProof for CertificateRequestMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -21045,196 +20121,206 @@ impl SpecIsoProof for ClientCertTypeServerExtensionMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ClientCertTypeServerExtensionMapper {
-    type Src = ClientCertTypeServerExtensionInner;
-    type Dst = ClientCertTypeServerExtension;
-    type RefSrc = ClientCertTypeServerExtensionInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateRequestMapper {
+    type Src = CertificateRequestInner<'a>;
+    type Dst = CertificateRequest<'a>;
+    type RefSrc = CertificateRequestInnerRef<'a>;
 }
+type SpecCertificateRequestCombinatorAlias1 = (SpecOpaque0FfCombinator, SpecCertificateRequestExtensionsCombinator);
+pub struct SpecCertificateRequestCombinator(pub SpecCertificateRequestCombinatorAlias);
 
-pub struct SpecClientCertTypeServerExtensionCombinator(pub SpecClientCertTypeServerExtensionCombinatorAlias);
-
-impl SpecCombinator for SpecClientCertTypeServerExtensionCombinator {
-    type Type = SpecClientCertTypeServerExtension;
+impl SpecCombinator for SpecCertificateRequestCombinator {
+    type Type = SpecCertificateRequest;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecClientCertTypeServerExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecClientCertTypeServerExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateRequestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateRequestCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecClientCertTypeServerExtensionCombinatorAlias = Mapped<SpecCertificateTypeCombinator, ClientCertTypeServerExtensionMapper>;
+pub type SpecCertificateRequestCombinatorAlias = Mapped<SpecCertificateRequestCombinatorAlias1, CertificateRequestMapper>;
+type CertificateRequestCombinatorAlias1 = (Opaque0FfCombinator, CertificateRequestExtensionsCombinator);
+pub struct CertificateRequestCombinator1(pub CertificateRequestCombinatorAlias1);
+impl View for CertificateRequestCombinator1 {
+    type V = SpecCertificateRequestCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateRequestCombinator1, CertificateRequestCombinatorAlias1);
 
-pub struct ClientCertTypeServerExtensionCombinator(pub ClientCertTypeServerExtensionCombinatorAlias);
+pub struct CertificateRequestCombinator(pub CertificateRequestCombinatorAlias);
 
-impl View for ClientCertTypeServerExtensionCombinator {
-    type V = SpecClientCertTypeServerExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecClientCertTypeServerExtensionCombinator(self.0@) }
+impl View for CertificateRequestCombinator {
+    type V = SpecCertificateRequestCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateRequestCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientCertTypeServerExtensionCombinator {
-    type Type = ClientCertTypeServerExtension;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateRequestCombinator {
+    type Type = CertificateRequest<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ClientCertTypeServerExtensionCombinatorAlias = Mapped<CertificateTypeCombinator, ClientCertTypeServerExtensionMapper>;
+}
+pub type CertificateRequestCombinatorAlias = Mapped<CertificateRequestCombinator1, CertificateRequestMapper>;
 
 
-pub open spec fn spec_client_cert_type_server_extension() -> SpecClientCertTypeServerExtensionCombinator {
-    SpecClientCertTypeServerExtensionCombinator(
+pub open spec fn spec_certificate_request() -> SpecCertificateRequestCombinator {
+    SpecCertificateRequestCombinator(
     Mapped {
-        inner: spec_certificate_type(),
-        mapper: ClientCertTypeServerExtensionMapper,
+        inner: (spec_opaque_0_ff(), spec_certificate_request_extensions()),
+        mapper: CertificateRequestMapper,
     })
 }
 
                 
-pub fn client_cert_type_server_extension<'a>() -> (o: ClientCertTypeServerExtensionCombinator)
-    ensures o@ == spec_client_cert_type_server_extension(),
+pub fn certificate_request<'a>() -> (o: CertificateRequestCombinator)
+    ensures o@ == spec_certificate_request(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ClientCertTypeServerExtensionCombinator(
+    let combinator = CertificateRequestCombinator(
     Mapped {
-        inner: certificate_type(),
-        mapper: ClientCertTypeServerExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_client_cert_type_server_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: CertificateRequestCombinator1((opaque_0_ff(), certificate_request_extensions())),
+        mapper: CertificateRequestMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_request()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_client_cert_type_server_extension<'a>(input: &'a [u8]) -> (res: PResult<<ClientCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_request<'a>(input: &'a [u8]) -> (res: PResult<<CertificateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_client_cert_type_server_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_client_cert_type_server_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_request().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_request().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_client_cert_type_server_extension().spec_parse(input@) is None,
-        spec_client_cert_type_server_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_request().spec_parse(input@) is None,
+        spec_certificate_request().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = client_cert_type_server_extension();
+    let combinator = certificate_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_client_cert_type_server_extension<'a>(v: <ClientCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_request<'a>(v: <CertificateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_client_cert_type_server_extension().wf(v@),
+        spec_certificate_request().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_client_cert_type_server_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_client_cert_type_server_extension().spec_serialize(v@))
+            &&& n == spec_certificate_request().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_request().spec_serialize(v@))
         },
 {
-    let combinator = client_cert_type_server_extension();
+    let combinator = certificate_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn client_cert_type_server_extension_len<'a>(v: <ClientCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_request_len<'a>(v: <CertificateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_client_cert_type_server_extension().wf(v@),
-        spec_client_cert_type_server_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_request().wf(v@),
+        spec_certificate_request().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_client_cert_type_server_extension().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_request().spec_serialize(v@).len(),
 {
-    let combinator = client_cert_type_server_extension();
+    let combinator = certificate_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecZeroByte {
-    pub zero: u8,
+pub struct SpecCertificateVerify {
+    pub algorithm: u16,
+    pub signature: SpecOpaque0Ffff,
 }
 
-pub type SpecZeroByteInner = u8;
+pub type SpecCertificateVerifyInner = (u16, SpecOpaque0Ffff);
 
 
-impl SpecFrom<SpecZeroByte> for SpecZeroByteInner {
-    open spec fn spec_from(m: SpecZeroByte) -> SpecZeroByteInner {
-        m.zero
+impl SpecFrom<SpecCertificateVerify> for SpecCertificateVerifyInner {
+    open spec fn spec_from(m: SpecCertificateVerify) -> SpecCertificateVerifyInner {
+        (m.algorithm, m.signature)
     }
 }
 
-impl SpecFrom<SpecZeroByteInner> for SpecZeroByte {
-    open spec fn spec_from(m: SpecZeroByteInner) -> SpecZeroByte {
-        let zero = m;
-        SpecZeroByte { zero }
+impl SpecFrom<SpecCertificateVerifyInner> for SpecCertificateVerify {
+    open spec fn spec_from(m: SpecCertificateVerifyInner) -> SpecCertificateVerify {
+        let (algorithm, signature) = m;
+        SpecCertificateVerify { algorithm, signature }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ZeroByte {
-    pub zero: u8,
+pub struct CertificateVerify<'a> {
+    pub algorithm: u16,
+    pub signature: Opaque0Ffff<'a>,
 }
 
-impl View for ZeroByte {
-    type V = SpecZeroByte;
+impl View for CertificateVerify<'_> {
+    type V = SpecCertificateVerify;
 
     open spec fn view(&self) -> Self::V {
-        SpecZeroByte {
-            zero: self.zero@,
+        SpecCertificateVerify {
+            algorithm: self.algorithm@,
+            signature: self.signature@,
         }
     }
 }
-pub type ZeroByteInner = u8;
+pub type CertificateVerifyInner<'a> = (u16, Opaque0Ffff<'a>);
 
-pub type ZeroByteInnerRef<'a> = &'a u8;
-impl<'a> From<&'a ZeroByte> for ZeroByteInnerRef<'a> {
-    fn ex_from(m: &'a ZeroByte) -> ZeroByteInnerRef<'a> {
-        &m.zero
+pub type CertificateVerifyInnerRef<'a> = (&'a u16, &'a Opaque0Ffff<'a>);
+impl<'a> From<&'a CertificateVerify<'a>> for CertificateVerifyInnerRef<'a> {
+    fn ex_from(m: &'a CertificateVerify) -> CertificateVerifyInnerRef<'a> {
+        (&m.algorithm, &m.signature)
     }
 }
 
-impl From<ZeroByteInner> for ZeroByte {
-    fn ex_from(m: ZeroByteInner) -> ZeroByte {
-        let zero = m;
-        ZeroByte { zero }
+impl<'a> From<CertificateVerifyInner<'a>> for CertificateVerify<'a> {
+    fn ex_from(m: CertificateVerifyInner) -> CertificateVerify {
+        let (algorithm, signature) = m;
+        CertificateVerify { algorithm, signature }
     }
 }
 
-pub struct ZeroByteMapper;
-impl View for ZeroByteMapper {
+pub struct CertificateVerifyMapper;
+impl View for CertificateVerifyMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ZeroByteMapper {
-    type Src = SpecZeroByteInner;
-    type Dst = SpecZeroByte;
+impl SpecIso for CertificateVerifyMapper {
+    type Src = SpecCertificateVerifyInner;
+    type Dst = SpecCertificateVerify;
 }
-impl SpecIsoProof for ZeroByteMapper {
+impl SpecIsoProof for CertificateVerifyMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -21242,562 +20328,449 @@ impl SpecIsoProof for ZeroByteMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ZeroByteMapper {
-    type Src = ZeroByteInner;
-    type Dst = ZeroByte;
-    type RefSrc = ZeroByteInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateVerifyMapper {
+    type Src = CertificateVerifyInner<'a>;
+    type Dst = CertificateVerify<'a>;
+    type RefSrc = CertificateVerifyInnerRef<'a>;
 }
-pub const ZEROBYTEZERO_CONST: u8 = 0;
-
-pub struct SpecZeroByteCombinator(pub SpecZeroByteCombinatorAlias);
+type SpecCertificateVerifyCombinatorAlias1 = (SpecSignatureSchemeCombinator, SpecOpaque0FfffCombinator);
+pub struct SpecCertificateVerifyCombinator(pub SpecCertificateVerifyCombinatorAlias);
 
-impl SpecCombinator for SpecZeroByteCombinator {
-    type Type = SpecZeroByte;
+impl SpecCombinator for SpecCertificateVerifyCombinator {
+    type Type = SpecCertificateVerify;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecZeroByteCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecZeroByteCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateVerifyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateVerifyCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecZeroByteCombinatorAlias = Mapped<Refined<U8, TagPred<u8>>, ZeroByteMapper>;
+pub type SpecCertificateVerifyCombinatorAlias = Mapped<SpecCertificateVerifyCombinatorAlias1, CertificateVerifyMapper>;
+type CertificateVerifyCombinatorAlias1 = (SignatureSchemeCombinator, Opaque0FfffCombinator);
+pub struct CertificateVerifyCombinator1(pub CertificateVerifyCombinatorAlias1);
+impl View for CertificateVerifyCombinator1 {
+    type V = SpecCertificateVerifyCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateVerifyCombinator1, CertificateVerifyCombinatorAlias1);
 
-pub struct ZeroByteCombinator(pub ZeroByteCombinatorAlias);
+pub struct CertificateVerifyCombinator(pub CertificateVerifyCombinatorAlias);
 
-impl View for ZeroByteCombinator {
-    type V = SpecZeroByteCombinator;
-    open spec fn view(&self) -> Self::V { SpecZeroByteCombinator(self.0@) }
+impl View for CertificateVerifyCombinator {
+    type V = SpecCertificateVerifyCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateVerifyCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ZeroByteCombinator {
-    type Type = ZeroByte;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateVerifyCombinator {
+    type Type = CertificateVerify<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ZeroByteCombinatorAlias = Mapped<Refined<U8, TagPred<u8>>, ZeroByteMapper>;
+}
+pub type CertificateVerifyCombinatorAlias = Mapped<CertificateVerifyCombinator1, CertificateVerifyMapper>;
 
 
-pub open spec fn spec_zero_byte() -> SpecZeroByteCombinator {
-    SpecZeroByteCombinator(
+pub open spec fn spec_certificate_verify() -> SpecCertificateVerifyCombinator {
+    SpecCertificateVerifyCombinator(
     Mapped {
-        inner: Refined { inner: U8, predicate: TagPred(ZEROBYTEZERO_CONST) },
-        mapper: ZeroByteMapper,
+        inner: (spec_signature_scheme(), spec_opaque_0_ffff()),
+        mapper: CertificateVerifyMapper,
     })
 }
 
                 
-pub fn zero_byte<'a>() -> (o: ZeroByteCombinator)
-    ensures o@ == spec_zero_byte(),
+pub fn certificate_verify<'a>() -> (o: CertificateVerifyCombinator)
+    ensures o@ == spec_certificate_verify(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ZeroByteCombinator(
+    let combinator = CertificateVerifyCombinator(
     Mapped {
-        inner: Refined { inner: U8, predicate: TagPred(ZEROBYTEZERO_CONST) },
-        mapper: ZeroByteMapper,
-    });
-    assert({
-        &&& combinator@ == spec_zero_byte()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: CertificateVerifyCombinator1((signature_scheme(), opaque_0_ffff())),
+        mapper: CertificateVerifyMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_verify()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_zero_byte<'a>(input: &'a [u8]) -> (res: PResult<<ZeroByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_verify<'a>(input: &'a [u8]) -> (res: PResult<<CertificateVerifyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_zero_byte().spec_parse(input@) == Some((n as int, v@)),
-        spec_zero_byte().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_verify().spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_verify().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_zero_byte().spec_parse(input@) is None,
-        spec_zero_byte().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_verify().spec_parse(input@) is None,
+        spec_certificate_verify().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = zero_byte();
+    let combinator = certificate_verify();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_zero_byte<'a>(v: <ZeroByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_verify<'a>(v: <CertificateVerifyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_zero_byte().wf(v@),
+        spec_certificate_verify().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_zero_byte().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_zero_byte().spec_serialize(v@))
+            &&& n == spec_certificate_verify().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_verify().spec_serialize(v@))
         },
 {
-    let combinator = zero_byte();
+    let combinator = certificate_verify();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn zero_byte_len<'a>(v: <ZeroByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_verify_len<'a>(v: <CertificateVerifyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_zero_byte().wf(v@),
-        spec_zero_byte().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_verify().wf(v@),
+        spec_certificate_verify().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_zero_byte().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_verify().spec_serialize(v@).len(),
 {
-    let combinator = zero_byte();
+    let combinator = certificate_verify();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub spec const SPEC_HandshakeType_ClientHello: u8 = 1;
-pub spec const SPEC_HandshakeType_ServerHello: u8 = 2;
-pub spec const SPEC_HandshakeType_NewSessionTicket: u8 = 4;
-pub spec const SPEC_HandshakeType_EndOfEarlyData: u8 = 5;
-pub spec const SPEC_HandshakeType_EncryptedExtensions: u8 = 8;
-pub spec const SPEC_HandshakeType_Certificate: u8 = 11;
-pub spec const SPEC_HandshakeType_CertificateRequest: u8 = 13;
-pub spec const SPEC_HandshakeType_CertificateVerify: u8 = 15;
-pub spec const SPEC_HandshakeType_Finished: u8 = 20;
-pub spec const SPEC_HandshakeType_KeyUpdate: u8 = 24;
-pub exec static EXEC_HandshakeType_ClientHello: u8 ensures EXEC_HandshakeType_ClientHello == SPEC_HandshakeType_ClientHello { 1 }
-pub exec static EXEC_HandshakeType_ServerHello: u8 ensures EXEC_HandshakeType_ServerHello == SPEC_HandshakeType_ServerHello { 2 }
-pub exec static EXEC_HandshakeType_NewSessionTicket: u8 ensures EXEC_HandshakeType_NewSessionTicket == SPEC_HandshakeType_NewSessionTicket { 4 }
-pub exec static EXEC_HandshakeType_EndOfEarlyData: u8 ensures EXEC_HandshakeType_EndOfEarlyData == SPEC_HandshakeType_EndOfEarlyData { 5 }
-pub exec static EXEC_HandshakeType_EncryptedExtensions: u8 ensures EXEC_HandshakeType_EncryptedExtensions == SPEC_HandshakeType_EncryptedExtensions { 8 }
-pub exec static EXEC_HandshakeType_Certificate: u8 ensures EXEC_HandshakeType_Certificate == SPEC_HandshakeType_Certificate { 11 }
-pub exec static EXEC_HandshakeType_CertificateRequest: u8 ensures EXEC_HandshakeType_CertificateRequest == SPEC_HandshakeType_CertificateRequest { 13 }
-pub exec static EXEC_HandshakeType_CertificateVerify: u8 ensures EXEC_HandshakeType_CertificateVerify == SPEC_HandshakeType_CertificateVerify { 15 }
-pub exec static EXEC_HandshakeType_Finished: u8 ensures EXEC_HandshakeType_Finished == SPEC_HandshakeType_Finished { 20 }
-pub exec static EXEC_HandshakeType_KeyUpdate: u8 ensures EXEC_HandshakeType_KeyUpdate == SPEC_HandshakeType_KeyUpdate { 24 }
-
-#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
-pub enum HandshakeType {
-    ClientHello = 1,
-ServerHello = 2,
-NewSessionTicket = 4,
-EndOfEarlyData = 5,
-EncryptedExtensions = 8,
-Certificate = 11,
-CertificateRequest = 13,
-CertificateVerify = 15,
-Finished = 20,
-KeyUpdate = 24
+pub enum SpecFinished {
+    Hash12(Seq<u8>),
+    Hash20(Seq<u8>),
+    Sha256(Seq<u8>),
+    Sha384(Seq<u8>),
+    Sha512(Seq<u8>),
+    Unrecognized(Seq<u8>),
 }
-pub type SpecHandshakeType = HandshakeType;
 
-pub type HandshakeTypeInner = u8;
+pub type SpecFinishedInner = Either<Seq<u8>, Either<Seq<u8>, Either<Seq<u8>, Either<Seq<u8>, Either<Seq<u8>, Seq<u8>>>>>>;
 
-pub type HandshakeTypeInnerRef<'a> = &'a u8;
+impl SpecFrom<SpecFinished> for SpecFinishedInner {
+    open spec fn spec_from(m: SpecFinished) -> SpecFinishedInner {
+        match m {
+            SpecFinished::Hash12(m) => Either::Left(m),
+            SpecFinished::Hash20(m) => Either::Right(Either::Left(m)),
+            SpecFinished::Sha256(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecFinished::Sha384(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecFinished::Sha512(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecFinished::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))),
+        }
+    }
 
-impl View for HandshakeType {
-    type V = Self;
+}
 
-    open spec fn view(&self) -> Self::V {
-        *self
+                
+impl SpecFrom<SpecFinishedInner> for SpecFinished {
+    open spec fn spec_from(m: SpecFinishedInner) -> SpecFinished {
+        match m {
+            Either::Left(m) => SpecFinished::Hash12(m),
+            Either::Right(Either::Left(m)) => SpecFinished::Hash20(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecFinished::Sha256(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecFinished::Sha384(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecFinished::Sha512(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))) => SpecFinished::Unrecognized(m),
+        }
     }
+
 }
 
-impl SpecTryFrom<HandshakeTypeInner> for HandshakeType {
-    type Error = ();
 
-    open spec fn spec_try_from(v: HandshakeTypeInner) -> Result<HandshakeType, ()> {
-        match v {
-            1u8 => Ok(HandshakeType::ClientHello),
-            2u8 => Ok(HandshakeType::ServerHello),
-            4u8 => Ok(HandshakeType::NewSessionTicket),
-            5u8 => Ok(HandshakeType::EndOfEarlyData),
-            8u8 => Ok(HandshakeType::EncryptedExtensions),
-            11u8 => Ok(HandshakeType::Certificate),
-            13u8 => Ok(HandshakeType::CertificateRequest),
-            15u8 => Ok(HandshakeType::CertificateVerify),
-            20u8 => Ok(HandshakeType::Finished),
-            24u8 => Ok(HandshakeType::KeyUpdate),
-            _ => Err(()),
-        }
-    }
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Finished<'a> {
+    Hash12(&'a [u8]),
+    Hash20(&'a [u8]),
+    Sha256(&'a [u8]),
+    Sha384(&'a [u8]),
+    Sha512(&'a [u8]),
+    Unrecognized(&'a [u8]),
 }
 
-impl SpecTryFrom<HandshakeType> for HandshakeTypeInner {
-    type Error = ();
+pub type FinishedInner<'a> = Either<&'a [u8], Either<&'a [u8], Either<&'a [u8], Either<&'a [u8], Either<&'a [u8], &'a [u8]>>>>>;
 
-    open spec fn spec_try_from(v: HandshakeType) -> Result<HandshakeTypeInner, ()> {
-        match v {
-            HandshakeType::ClientHello => Ok(SPEC_HandshakeType_ClientHello),
-            HandshakeType::ServerHello => Ok(SPEC_HandshakeType_ServerHello),
-            HandshakeType::NewSessionTicket => Ok(SPEC_HandshakeType_NewSessionTicket),
-            HandshakeType::EndOfEarlyData => Ok(SPEC_HandshakeType_EndOfEarlyData),
-            HandshakeType::EncryptedExtensions => Ok(SPEC_HandshakeType_EncryptedExtensions),
-            HandshakeType::Certificate => Ok(SPEC_HandshakeType_Certificate),
-            HandshakeType::CertificateRequest => Ok(SPEC_HandshakeType_CertificateRequest),
-            HandshakeType::CertificateVerify => Ok(SPEC_HandshakeType_CertificateVerify),
-            HandshakeType::Finished => Ok(SPEC_HandshakeType_Finished),
-            HandshakeType::KeyUpdate => Ok(SPEC_HandshakeType_KeyUpdate),
+pub type FinishedInnerRef<'a> = Either<&'a &'a [u8], Either<&'a &'a [u8], Either<&'a &'a [u8], Either<&'a &'a [u8], Either<&'a &'a [u8], &'a &'a [u8]>>>>>;
+
+
+impl<'a> View for Finished<'a> {
+    type V = SpecFinished;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            Finished::Hash12(m) => SpecFinished::Hash12(m@),
+            Finished::Hash20(m) => SpecFinished::Hash20(m@),
+            Finished::Sha256(m) => SpecFinished::Sha256(m@),
+            Finished::Sha384(m) => SpecFinished::Sha384(m@),
+            Finished::Sha512(m) => SpecFinished::Sha512(m@),
+            Finished::Unrecognized(m) => SpecFinished::Unrecognized(m@),
         }
     }
 }
 
-impl TryFrom<HandshakeTypeInner> for HandshakeType {
-    type Error = ();
 
-    fn ex_try_from(v: HandshakeTypeInner) -> Result<HandshakeType, ()> {
-        match v {
-            1u8 => Ok(HandshakeType::ClientHello),
-            2u8 => Ok(HandshakeType::ServerHello),
-            4u8 => Ok(HandshakeType::NewSessionTicket),
-            5u8 => Ok(HandshakeType::EndOfEarlyData),
-            8u8 => Ok(HandshakeType::EncryptedExtensions),
-            11u8 => Ok(HandshakeType::Certificate),
-            13u8 => Ok(HandshakeType::CertificateRequest),
-            15u8 => Ok(HandshakeType::CertificateVerify),
-            20u8 => Ok(HandshakeType::Finished),
-            24u8 => Ok(HandshakeType::KeyUpdate),
-            _ => Err(()),
+impl<'a> From<&'a Finished<'a>> for FinishedInnerRef<'a> {
+    fn ex_from(m: &'a Finished<'a>) -> FinishedInnerRef<'a> {
+        match m {
+            Finished::Hash12(m) => Either::Left(m),
+            Finished::Hash20(m) => Either::Right(Either::Left(m)),
+            Finished::Sha256(m) => Either::Right(Either::Right(Either::Left(m))),
+            Finished::Sha384(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            Finished::Sha512(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            Finished::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))),
         }
     }
-}
 
-impl<'a> TryFrom<&'a HandshakeType> for HandshakeTypeInnerRef<'a> {
-    type Error = ();
+}
 
-    fn ex_try_from(v: &'a HandshakeType) -> Result<HandshakeTypeInnerRef<'a>, ()> {
-        match v {
-            HandshakeType::ClientHello => Ok(&EXEC_HandshakeType_ClientHello),
-            HandshakeType::ServerHello => Ok(&EXEC_HandshakeType_ServerHello),
-            HandshakeType::NewSessionTicket => Ok(&EXEC_HandshakeType_NewSessionTicket),
-            HandshakeType::EndOfEarlyData => Ok(&EXEC_HandshakeType_EndOfEarlyData),
-            HandshakeType::EncryptedExtensions => Ok(&EXEC_HandshakeType_EncryptedExtensions),
-            HandshakeType::Certificate => Ok(&EXEC_HandshakeType_Certificate),
-            HandshakeType::CertificateRequest => Ok(&EXEC_HandshakeType_CertificateRequest),
-            HandshakeType::CertificateVerify => Ok(&EXEC_HandshakeType_CertificateVerify),
-            HandshakeType::Finished => Ok(&EXEC_HandshakeType_Finished),
-            HandshakeType::KeyUpdate => Ok(&EXEC_HandshakeType_KeyUpdate),
+impl<'a> From<FinishedInner<'a>> for Finished<'a> {
+    fn ex_from(m: FinishedInner<'a>) -> Finished<'a> {
+        match m {
+            Either::Left(m) => Finished::Hash12(m),
+            Either::Right(Either::Left(m)) => Finished::Hash20(m),
+            Either::Right(Either::Right(Either::Left(m))) => Finished::Sha256(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => Finished::Sha384(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => Finished::Sha512(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))) => Finished::Unrecognized(m),
         }
     }
+    
 }
 
-pub struct HandshakeTypeMapper;
 
-impl View for HandshakeTypeMapper {
+pub struct FinishedMapper;
+impl View for FinishedMapper {
     type V = Self;
-
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-
-impl SpecPartialIso for HandshakeTypeMapper {
-    type Src = HandshakeTypeInner;
-    type Dst = HandshakeType;
+impl SpecIso for FinishedMapper {
+    type Src = SpecFinishedInner;
+    type Dst = SpecFinished;
 }
-
-impl SpecPartialIsoProof for HandshakeTypeMapper {
-    proof fn spec_iso(s: Self::Src) { 
-        assert(
-            Self::spec_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_rev_apply(v) is Ok
-            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
-        });
+impl SpecIsoProof for FinishedMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
-
-    proof fn spec_iso_rev(s: Self::Dst) { 
-        assert(
-            Self::spec_rev_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_apply(v) is Ok
-            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
-        });
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-
-impl<'a> PartialIso<'a> for HandshakeTypeMapper {
-    type Src = HandshakeTypeInner;
-    type Dst = HandshakeType;
-    type RefSrc = HandshakeTypeInnerRef<'a>;
+impl<'a> Iso<'a> for FinishedMapper {
+    type Src = FinishedInner<'a>;
+    type Dst = Finished<'a>;
+    type RefSrc = FinishedInnerRef<'a>;
 }
 
+type SpecFinishedCombinatorAlias1 = Choice<Cond<bytes::Fixed<64>>, Cond<bytes::Variable>>;
+type SpecFinishedCombinatorAlias2 = Choice<Cond<bytes::Fixed<48>>, SpecFinishedCombinatorAlias1>;
+type SpecFinishedCombinatorAlias3 = Choice<Cond<bytes::Fixed<32>>, SpecFinishedCombinatorAlias2>;
+type SpecFinishedCombinatorAlias4 = Choice<Cond<bytes::Fixed<20>>, SpecFinishedCombinatorAlias3>;
+type SpecFinishedCombinatorAlias5 = Choice<Cond<bytes::Fixed<12>>, SpecFinishedCombinatorAlias4>;
+pub struct SpecFinishedCombinator(pub SpecFinishedCombinatorAlias);
 
-pub struct SpecHandshakeTypeCombinator(pub SpecHandshakeTypeCombinatorAlias);
-
-impl SpecCombinator for SpecHandshakeTypeCombinator {
-    type Type = SpecHandshakeType;
+impl SpecCombinator for SpecFinishedCombinator {
+    type Type = SpecFinished;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecHandshakeTypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecHandshakeTypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecFinishedCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecFinishedCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecHandshakeTypeCombinatorAlias = TryMap<U8, HandshakeTypeMapper>;
-
-pub struct HandshakeTypeCombinator(pub HandshakeTypeCombinatorAlias);
-
-impl View for HandshakeTypeCombinator {
-    type V = SpecHandshakeTypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecHandshakeTypeCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HandshakeTypeCombinator {
-    type Type = HandshakeType;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type HandshakeTypeCombinatorAlias = TryMap<U8, HandshakeTypeMapper>;
-
-
-pub open spec fn spec_handshake_type() -> SpecHandshakeTypeCombinator {
-    SpecHandshakeTypeCombinator(TryMap { inner: U8, mapper: HandshakeTypeMapper })
-}
-
-                
-pub fn handshake_type<'a>() -> (o: HandshakeTypeCombinator)
-    ensures o@ == spec_handshake_type(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = HandshakeTypeCombinator(TryMap { inner: U8, mapper: HandshakeTypeMapper });
-    assert({
-        &&& combinator@ == spec_handshake_type()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
-
-pub fn parse_handshake_type<'a>(input: &'a [u8]) -> (res: PResult<<HandshakeTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_handshake_type().spec_parse(input@) == Some((n as int, v@)),
-        spec_handshake_type().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_handshake_type().spec_parse(input@) is None,
-        spec_handshake_type().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = handshake_type();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+pub type SpecFinishedCombinatorAlias = Mapped<SpecFinishedCombinatorAlias5, FinishedMapper>;
+type FinishedCombinatorAlias1 = Choice<Cond<bytes::Fixed<64>>, Cond<bytes::Variable>>;
+type FinishedCombinatorAlias2 = Choice<Cond<bytes::Fixed<48>>, FinishedCombinator1>;
+type FinishedCombinatorAlias3 = Choice<Cond<bytes::Fixed<32>>, FinishedCombinator2>;
+type FinishedCombinatorAlias4 = Choice<Cond<bytes::Fixed<20>>, FinishedCombinator3>;
+type FinishedCombinatorAlias5 = Choice<Cond<bytes::Fixed<12>>, FinishedCombinator4>;
+pub struct FinishedCombinator1(pub FinishedCombinatorAlias1);
+impl View for FinishedCombinator1 {
+    type V = SpecFinishedCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(FinishedCombinator1, FinishedCombinatorAlias1);
 
-pub fn serialize_handshake_type<'a>(v: <HandshakeTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_handshake_type().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_handshake_type().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_handshake_type().spec_serialize(v@))
-        },
-{
-    let combinator = handshake_type();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+pub struct FinishedCombinator2(pub FinishedCombinatorAlias2);
+impl View for FinishedCombinator2 {
+    type V = SpecFinishedCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(FinishedCombinator2, FinishedCombinatorAlias2);
 
-pub fn handshake_type_len<'a>(v: <HandshakeTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_handshake_type().wf(v@),
-        spec_handshake_type().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_handshake_type().spec_serialize(v@).len(),
-{
-    let combinator = handshake_type();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+pub struct FinishedCombinator3(pub FinishedCombinatorAlias3);
+impl View for FinishedCombinator3 {
+    type V = SpecFinishedCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(FinishedCombinator3, FinishedCombinatorAlias3);
 
-                
-pub mod DigestSize {
-    use super::*;
-    pub spec const SPEC_Hash12: u32 = 12;
-    pub spec const SPEC_Hash20: u32 = 20;
-    pub spec const SPEC_Sha256: u32 = 32;
-    pub spec const SPEC_Sha384: u32 = 48;
-    pub spec const SPEC_Sha512: u32 = 64;
-    pub spec const SPEC_Max: u32 = 16777215;
-    pub exec const Hash12: u32 ensures Hash12 == SPEC_Hash12 { 12 }
-    pub exec const Hash20: u32 ensures Hash20 == SPEC_Hash20 { 20 }
-    pub exec const Sha256: u32 ensures Sha256 == SPEC_Sha256 { 32 }
-    pub exec const Sha384: u32 ensures Sha384 == SPEC_Sha384 { 48 }
-    pub exec const Sha512: u32 ensures Sha512 == SPEC_Sha512 { 64 }
-    pub exec const Max: u32 ensures Max == SPEC_Max { 16777215 }
+pub struct FinishedCombinator4(pub FinishedCombinatorAlias4);
+impl View for FinishedCombinator4 {
+    type V = SpecFinishedCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(FinishedCombinator4, FinishedCombinatorAlias4);
 
-
-pub struct SpecDigestSizeCombinator(pub SpecDigestSizeCombinatorAlias);
-
-impl SpecCombinator for SpecDigestSizeCombinator {
-    type Type = u24;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecDigestSizeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecDigestSizeCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
+pub struct FinishedCombinator5(pub FinishedCombinatorAlias5);
+impl View for FinishedCombinator5 {
+    type V = SpecFinishedCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-pub type SpecDigestSizeCombinatorAlias = U24Be;
+impl_wrapper_combinator!(FinishedCombinator5, FinishedCombinatorAlias5);
 
-pub struct DigestSizeCombinator(pub DigestSizeCombinatorAlias);
+pub struct FinishedCombinator(pub FinishedCombinatorAlias);
 
-impl View for DigestSizeCombinator {
-    type V = SpecDigestSizeCombinator;
-    open spec fn view(&self) -> Self::V { SpecDigestSizeCombinator(self.0@) }
+impl View for FinishedCombinator {
+    type V = SpecFinishedCombinator;
+    open spec fn view(&self) -> Self::V { SpecFinishedCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DigestSizeCombinator {
-    type Type = u24;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FinishedCombinator {
+    type Type = Finished<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type DigestSizeCombinatorAlias = U24Be;
+}
+pub type FinishedCombinatorAlias = Mapped<FinishedCombinator5, FinishedMapper>;
 
 
-pub open spec fn spec_digest_size() -> SpecDigestSizeCombinator {
-    SpecDigestSizeCombinator(U24Be)
+pub open spec fn spec_finished(size: u24) -> SpecFinishedCombinator {
+    SpecFinishedCombinator(Mapped { inner: Choice(Cond { cond: size.spec_as_u32() == DigestSize::SPEC_Hash12, inner: bytes::Fixed::<12> }, Choice(Cond { cond: size.spec_as_u32() == DigestSize::SPEC_Hash20, inner: bytes::Fixed::<20> }, Choice(Cond { cond: size.spec_as_u32() == DigestSize::SPEC_Sha256, inner: bytes::Fixed::<32> }, Choice(Cond { cond: size.spec_as_u32() == DigestSize::SPEC_Sha384, inner: bytes::Fixed::<48> }, Choice(Cond { cond: size.spec_as_u32() == DigestSize::SPEC_Sha512, inner: bytes::Fixed::<64> }, Cond { cond: !(size.spec_as_u32() == DigestSize::SPEC_Hash12 || size.spec_as_u32() == DigestSize::SPEC_Hash20 || size.spec_as_u32() == DigestSize::SPEC_Sha256 || size.spec_as_u32() == DigestSize::SPEC_Sha384 || size.spec_as_u32() == DigestSize::SPEC_Sha512), inner: bytes::Variable((usize::spec_from(size)) as usize) }))))), mapper: FinishedMapper })
 }
 
-                
-pub fn digest_size<'a>() -> (o: DigestSizeCombinator)
-    ensures o@ == spec_digest_size(),
+pub fn finished<'a>(size: u24) -> (o: FinishedCombinator)
+    requires
+        spec_digest_size().wf(size@),
+
+    ensures o@ == spec_finished(size@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = DigestSizeCombinator(U24Be);
-    assert({
-        &&& combinator@ == spec_digest_size()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = FinishedCombinator(Mapped { inner: FinishedCombinator5(Choice::new(Cond { cond: size.as_u32() == DigestSize::Hash12, inner: bytes::Fixed::<12> }, FinishedCombinator4(Choice::new(Cond { cond: size.as_u32() == DigestSize::Hash20, inner: bytes::Fixed::<20> }, FinishedCombinator3(Choice::new(Cond { cond: size.as_u32() == DigestSize::Sha256, inner: bytes::Fixed::<32> }, FinishedCombinator2(Choice::new(Cond { cond: size.as_u32() == DigestSize::Sha384, inner: bytes::Fixed::<48> }, FinishedCombinator1(Choice::new(Cond { cond: size.as_u32() == DigestSize::Sha512, inner: bytes::Fixed::<64> }, Cond { cond: !(size.as_u32() == DigestSize::Hash12 || size.as_u32() == DigestSize::Hash20 || size.as_u32() == DigestSize::Sha256 || size.as_u32() == DigestSize::Sha384 || size.as_u32() == DigestSize::Sha512), inner: bytes::Variable((usize::ex_from(size)) as usize) })))))))))), mapper: FinishedMapper });
+    // assert({
+    //     &&& combinator@ == spec_finished(size@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_digest_size<'a>(input: &'a [u8]) -> (res: PResult<<DigestSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_finished<'a>(input: &'a [u8], size: u24) -> (res: PResult<<FinishedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_digest_size().wf(size@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_digest_size().spec_parse(input@) == Some((n as int, v@)),
-        spec_digest_size().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_finished(size@).spec_parse(input@) == Some((n as int, v@)),
+        spec_finished(size@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_digest_size().spec_parse(input@) is None,
-        spec_digest_size().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_finished(size@).spec_parse(input@) is None,
+        spec_finished(size@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = digest_size();
+    let combinator = finished( size );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_digest_size<'a>(v: <DigestSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_finished<'a>(v: <FinishedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, size: u24) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_digest_size().wf(v@),
+        spec_finished(size@).wf(v@),
+        spec_digest_size().wf(size@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_digest_size().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_digest_size().spec_serialize(v@))
+            &&& n == spec_finished(size@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_finished(size@).spec_serialize(v@))
         },
 {
-    let combinator = digest_size();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = finished( size );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn digest_size_len<'a>(v: <DigestSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn finished_len<'a>(v: <FinishedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, size: u24) -> (serialize_len: usize)
     requires
-        spec_digest_size().wf(v@),
-        spec_digest_size().spec_serialize(v@).len() <= usize::MAX,
+        spec_finished(size@).wf(v@),
+        spec_finished(size@).spec_serialize(v@).len() <= usize::MAX,
+        spec_digest_size().wf(size@),
+
     ensures
-        serialize_len == spec_digest_size().spec_serialize(v@).len(),
+        serialize_len == spec_finished(size@).spec_serialize(v@).len(),
 {
-    let combinator = digest_size();
+    let combinator = finished( size );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
 
-pub spec const SPEC_AlertLevel_Warning: u8 = 1;
-pub spec const SPEC_AlertLevel_Fatal: u8 = 2;
-pub exec static EXEC_AlertLevel_Warning: u8 ensures EXEC_AlertLevel_Warning == SPEC_AlertLevel_Warning { 1 }
-pub exec static EXEC_AlertLevel_Fatal: u8 ensures EXEC_AlertLevel_Fatal == SPEC_AlertLevel_Fatal { 2 }
+pub spec const SPEC_KeyUpdateRequest_UpdateNotRequested: u8 = 0;
+pub spec const SPEC_KeyUpdateRequest_UpdateRequested: u8 = 1;
+pub exec static EXEC_KeyUpdateRequest_UpdateNotRequested: u8 ensures EXEC_KeyUpdateRequest_UpdateNotRequested == SPEC_KeyUpdateRequest_UpdateNotRequested { 0 }
+pub exec static EXEC_KeyUpdateRequest_UpdateRequested: u8 ensures EXEC_KeyUpdateRequest_UpdateRequested == SPEC_KeyUpdateRequest_UpdateRequested { 1 }
 
 #[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
-pub enum AlertLevel {
-    Warning = 1,
-Fatal = 2
+pub enum KeyUpdateRequest {
+    UpdateNotRequested = 0,
+UpdateRequested = 1
 }
-pub type SpecAlertLevel = AlertLevel;
+pub type SpecKeyUpdateRequest = KeyUpdateRequest;
 
-pub type AlertLevelInner = u8;
+pub type KeyUpdateRequestInner = u8;
 
-pub type AlertLevelInnerRef<'a> = &'a u8;
+pub type KeyUpdateRequestInnerRef<'a> = &'a u8;
 
-impl View for AlertLevel {
+impl View for KeyUpdateRequest {
     type V = Self;
 
     open spec fn view(&self) -> Self::V {
@@ -21805,55 +20778,55 @@ impl View for AlertLevel {
     }
 }
 
-impl SpecTryFrom<AlertLevelInner> for AlertLevel {
+impl SpecTryFrom<KeyUpdateRequestInner> for KeyUpdateRequest {
     type Error = ();
 
-    open spec fn spec_try_from(v: AlertLevelInner) -> Result<AlertLevel, ()> {
+    open spec fn spec_try_from(v: KeyUpdateRequestInner) -> Result<KeyUpdateRequest, ()> {
         match v {
-            1u8 => Ok(AlertLevel::Warning),
-            2u8 => Ok(AlertLevel::Fatal),
+            0u8 => Ok(KeyUpdateRequest::UpdateNotRequested),
+            1u8 => Ok(KeyUpdateRequest::UpdateRequested),
             _ => Err(()),
         }
     }
 }
 
-impl SpecTryFrom<AlertLevel> for AlertLevelInner {
+impl SpecTryFrom<KeyUpdateRequest> for KeyUpdateRequestInner {
     type Error = ();
 
-    open spec fn spec_try_from(v: AlertLevel) -> Result<AlertLevelInner, ()> {
+    open spec fn spec_try_from(v: KeyUpdateRequest) -> Result<KeyUpdateRequestInner, ()> {
         match v {
-            AlertLevel::Warning => Ok(SPEC_AlertLevel_Warning),
-            AlertLevel::Fatal => Ok(SPEC_AlertLevel_Fatal),
+            KeyUpdateRequest::UpdateNotRequested => Ok(SPEC_KeyUpdateRequest_UpdateNotRequested),
+            KeyUpdateRequest::UpdateRequested => Ok(SPEC_KeyUpdateRequest_UpdateRequested),
         }
     }
 }
 
-impl TryFrom<AlertLevelInner> for AlertLevel {
+impl TryFrom<KeyUpdateRequestInner> for KeyUpdateRequest {
     type Error = ();
 
-    fn ex_try_from(v: AlertLevelInner) -> Result<AlertLevel, ()> {
+    fn ex_try_from(v: KeyUpdateRequestInner) -> Result<KeyUpdateRequest, ()> {
         match v {
-            1u8 => Ok(AlertLevel::Warning),
-            2u8 => Ok(AlertLevel::Fatal),
+            0u8 => Ok(KeyUpdateRequest::UpdateNotRequested),
+            1u8 => Ok(KeyUpdateRequest::UpdateRequested),
             _ => Err(()),
         }
     }
 }
 
-impl<'a> TryFrom<&'a AlertLevel> for AlertLevelInnerRef<'a> {
+impl<'a> TryFrom<&'a KeyUpdateRequest> for KeyUpdateRequestInnerRef<'a> {
     type Error = ();
 
-    fn ex_try_from(v: &'a AlertLevel) -> Result<AlertLevelInnerRef<'a>, ()> {
+    fn ex_try_from(v: &'a KeyUpdateRequest) -> Result<KeyUpdateRequestInnerRef<'a>, ()> {
         match v {
-            AlertLevel::Warning => Ok(&EXEC_AlertLevel_Warning),
-            AlertLevel::Fatal => Ok(&EXEC_AlertLevel_Fatal),
+            KeyUpdateRequest::UpdateNotRequested => Ok(&EXEC_KeyUpdateRequest_UpdateNotRequested),
+            KeyUpdateRequest::UpdateRequested => Ok(&EXEC_KeyUpdateRequest_UpdateRequested),
         }
     }
 }
 
-pub struct AlertLevelMapper;
+pub struct KeyUpdateRequestMapper;
 
-impl View for AlertLevelMapper {
+impl View for KeyUpdateRequestMapper {
     type V = Self;
 
     open spec fn view(&self) -> Self::V {
@@ -21861,13 +20834,13 @@ impl View for AlertLevelMapper {
     }
 }
 
-impl SpecPartialIso for AlertLevelMapper {
-    type Src = AlertLevelInner;
-    type Dst = AlertLevel;
+impl SpecPartialIso for KeyUpdateRequestMapper {
+    type Src = KeyUpdateRequestInner;
+    type Dst = KeyUpdateRequest;
 }
 
-impl SpecPartialIsoProof for AlertLevelMapper {
-    proof fn spec_iso(s: Self::Src) { 
+impl SpecPartialIsoProof for KeyUpdateRequestMapper {
+    proof fn spec_iso(s: Self::Src) {
         assert(
             Self::spec_apply(s) matches Ok(v) ==> {
             &&& Self::spec_rev_apply(v) is Ok
@@ -21875,7 +20848,7 @@ impl SpecPartialIsoProof for AlertLevelMapper {
         });
     }
 
-    proof fn spec_iso_rev(s: Self::Dst) { 
+    proof fn spec_iso_rev(s: Self::Dst) {
         assert(
             Self::spec_rev_apply(s) matches Ok(v) ==> {
             &&& Self::spec_apply(v) is Ok
@@ -21884,798 +20857,2144 @@ impl SpecPartialIsoProof for AlertLevelMapper {
     }
 }
 
-impl<'a> PartialIso<'a> for AlertLevelMapper {
-    type Src = AlertLevelInner;
-    type Dst = AlertLevel;
-    type RefSrc = AlertLevelInnerRef<'a>;
+impl<'a> PartialIso<'a> for KeyUpdateRequestMapper {
+    type Src = KeyUpdateRequestInner;
+    type Dst = KeyUpdateRequest;
+    type RefSrc = KeyUpdateRequestInnerRef<'a>;
 }
 
 
-pub struct SpecAlertLevelCombinator(pub SpecAlertLevelCombinatorAlias);
+pub struct SpecKeyUpdateRequestCombinator(pub SpecKeyUpdateRequestCombinatorAlias);
 
-impl SpecCombinator for SpecAlertLevelCombinator {
-    type Type = SpecAlertLevel;
+impl SpecCombinator for SpecKeyUpdateRequestCombinator {
+    type Type = SpecKeyUpdateRequest;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecAlertLevelCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecAlertLevelCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecKeyUpdateRequestCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecKeyUpdateRequestCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecAlertLevelCombinatorAlias = TryMap<U8, AlertLevelMapper>;
+pub type SpecKeyUpdateRequestCombinatorAlias = TryMap<U8, KeyUpdateRequestMapper>;
 
-pub struct AlertLevelCombinator(pub AlertLevelCombinatorAlias);
+pub struct KeyUpdateRequestCombinator(pub KeyUpdateRequestCombinatorAlias);
 
-impl View for AlertLevelCombinator {
-    type V = SpecAlertLevelCombinator;
-    open spec fn view(&self) -> Self::V { SpecAlertLevelCombinator(self.0@) }
+impl View for KeyUpdateRequestCombinator {
+    type V = SpecKeyUpdateRequestCombinator;
+    open spec fn view(&self) -> Self::V { SpecKeyUpdateRequestCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AlertLevelCombinator {
-    type Type = AlertLevel;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for KeyUpdateRequestCombinator {
+    type Type = KeyUpdateRequest;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type AlertLevelCombinatorAlias = TryMap<U8, AlertLevelMapper>;
+}
+pub type KeyUpdateRequestCombinatorAlias = TryMap<U8, KeyUpdateRequestMapper>;
 
 
-pub open spec fn spec_alert_level() -> SpecAlertLevelCombinator {
-    SpecAlertLevelCombinator(TryMap { inner: U8, mapper: AlertLevelMapper })
+pub open spec fn spec_key_update_request() -> SpecKeyUpdateRequestCombinator {
+    SpecKeyUpdateRequestCombinator(TryMap { inner: U8, mapper: KeyUpdateRequestMapper })
 }
 
                 
-pub fn alert_level<'a>() -> (o: AlertLevelCombinator)
-    ensures o@ == spec_alert_level(),
+pub fn key_update_request<'a>() -> (o: KeyUpdateRequestCombinator)
+    ensures o@ == spec_key_update_request(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = AlertLevelCombinator(TryMap { inner: U8, mapper: AlertLevelMapper });
-    assert({
-        &&& combinator@ == spec_alert_level()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = KeyUpdateRequestCombinator(TryMap { inner: U8, mapper: KeyUpdateRequestMapper });
+    // assert({
+    //     &&& combinator@ == spec_key_update_request()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_alert_level<'a>(input: &'a [u8]) -> (res: PResult<<AlertLevelCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_key_update_request<'a>(input: &'a [u8]) -> (res: PResult<<KeyUpdateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_alert_level().spec_parse(input@) == Some((n as int, v@)),
-        spec_alert_level().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_key_update_request().spec_parse(input@) == Some((n as int, v@)),
+        spec_key_update_request().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_alert_level().spec_parse(input@) is None,
-        spec_alert_level().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_key_update_request().spec_parse(input@) is None,
+        spec_key_update_request().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = alert_level();
+    let combinator = key_update_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_alert_level<'a>(v: <AlertLevelCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_key_update_request<'a>(v: <KeyUpdateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_alert_level().wf(v@),
+        spec_key_update_request().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_alert_level().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_alert_level().spec_serialize(v@))
+            &&& n == spec_key_update_request().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_key_update_request().spec_serialize(v@))
         },
 {
-    let combinator = alert_level();
+    let combinator = key_update_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn alert_level_len<'a>(v: <AlertLevelCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn key_update_request_len<'a>(v: <KeyUpdateRequestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_alert_level().wf(v@),
-        spec_alert_level().spec_serialize(v@).len() <= usize::MAX,
+        spec_key_update_request().wf(v@),
+        spec_key_update_request().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_alert_level().spec_serialize(v@).len(),
+        serialize_len == spec_key_update_request().spec_serialize(v@).len(),
 {
-    let combinator = alert_level();
+    let combinator = key_update_request();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub spec const SPEC_AlertDescription_CloseNotify: u8 = 0;
-pub spec const SPEC_AlertDescription_UnexpectedMessage: u8 = 10;
-pub spec const SPEC_AlertDescription_BadRecordMac: u8 = 20;
-pub spec const SPEC_AlertDescription_RecordOverflow: u8 = 22;
-pub spec const SPEC_AlertDescription_HandshakeFailure: u8 = 40;
-pub spec const SPEC_AlertDescription_BadCertificate: u8 = 42;
-pub spec const SPEC_AlertDescription_UnsupportedCertificate: u8 = 43;
-pub spec const SPEC_AlertDescription_CertificateRevoked: u8 = 44;
-pub spec const SPEC_AlertDescription_CertificateExpired: u8 = 45;
-pub spec const SPEC_AlertDescription_CertificateUnknown: u8 = 46;
-pub spec const SPEC_AlertDescription_IllegalParameter: u8 = 47;
-pub spec const SPEC_AlertDescription_UnknownCA: u8 = 48;
-pub spec const SPEC_AlertDescription_AccessDenied: u8 = 49;
-pub spec const SPEC_AlertDescription_DecodeError: u8 = 50;
-pub spec const SPEC_AlertDescription_DecryptError: u8 = 51;
-pub spec const SPEC_AlertDescription_ProtocolVersion: u8 = 70;
-pub spec const SPEC_AlertDescription_InsufficientSecurity: u8 = 71;
-pub spec const SPEC_AlertDescription_InternalError: u8 = 80;
-pub spec const SPEC_AlertDescription_InappropriateFallback: u8 = 86;
-pub spec const SPEC_AlertDescription_UserCanceled: u8 = 90;
-pub spec const SPEC_AlertDescription_MissingExtension: u8 = 109;
-pub spec const SPEC_AlertDescription_UnsupportedExtension: u8 = 110;
-pub spec const SPEC_AlertDescription_UnrecognizedName: u8 = 112;
-pub spec const SPEC_AlertDescription_BadCertificateStatusResponse: u8 = 113;
-pub spec const SPEC_AlertDescription_UnknownPSKIdentity: u8 = 115;
-pub spec const SPEC_AlertDescription_CertificateRequired: u8 = 116;
-pub spec const SPEC_AlertDescription_NoApplicationProtocol: u8 = 120;
-pub exec static EXEC_AlertDescription_CloseNotify: u8 ensures EXEC_AlertDescription_CloseNotify == SPEC_AlertDescription_CloseNotify { 0 }
-pub exec static EXEC_AlertDescription_UnexpectedMessage: u8 ensures EXEC_AlertDescription_UnexpectedMessage == SPEC_AlertDescription_UnexpectedMessage { 10 }
-pub exec static EXEC_AlertDescription_BadRecordMac: u8 ensures EXEC_AlertDescription_BadRecordMac == SPEC_AlertDescription_BadRecordMac { 20 }
-pub exec static EXEC_AlertDescription_RecordOverflow: u8 ensures EXEC_AlertDescription_RecordOverflow == SPEC_AlertDescription_RecordOverflow { 22 }
-pub exec static EXEC_AlertDescription_HandshakeFailure: u8 ensures EXEC_AlertDescription_HandshakeFailure == SPEC_AlertDescription_HandshakeFailure { 40 }
-pub exec static EXEC_AlertDescription_BadCertificate: u8 ensures EXEC_AlertDescription_BadCertificate == SPEC_AlertDescription_BadCertificate { 42 }
-pub exec static EXEC_AlertDescription_UnsupportedCertificate: u8 ensures EXEC_AlertDescription_UnsupportedCertificate == SPEC_AlertDescription_UnsupportedCertificate { 43 }
-pub exec static EXEC_AlertDescription_CertificateRevoked: u8 ensures EXEC_AlertDescription_CertificateRevoked == SPEC_AlertDescription_CertificateRevoked { 44 }
-pub exec static EXEC_AlertDescription_CertificateExpired: u8 ensures EXEC_AlertDescription_CertificateExpired == SPEC_AlertDescription_CertificateExpired { 45 }
-pub exec static EXEC_AlertDescription_CertificateUnknown: u8 ensures EXEC_AlertDescription_CertificateUnknown == SPEC_AlertDescription_CertificateUnknown { 46 }
-pub exec static EXEC_AlertDescription_IllegalParameter: u8 ensures EXEC_AlertDescription_IllegalParameter == SPEC_AlertDescription_IllegalParameter { 47 }
-pub exec static EXEC_AlertDescription_UnknownCA: u8 ensures EXEC_AlertDescription_UnknownCA == SPEC_AlertDescription_UnknownCA { 48 }
-pub exec static EXEC_AlertDescription_AccessDenied: u8 ensures EXEC_AlertDescription_AccessDenied == SPEC_AlertDescription_AccessDenied { 49 }
-pub exec static EXEC_AlertDescription_DecodeError: u8 ensures EXEC_AlertDescription_DecodeError == SPEC_AlertDescription_DecodeError { 50 }
-pub exec static EXEC_AlertDescription_DecryptError: u8 ensures EXEC_AlertDescription_DecryptError == SPEC_AlertDescription_DecryptError { 51 }
-pub exec static EXEC_AlertDescription_ProtocolVersion: u8 ensures EXEC_AlertDescription_ProtocolVersion == SPEC_AlertDescription_ProtocolVersion { 70 }
-pub exec static EXEC_AlertDescription_InsufficientSecurity: u8 ensures EXEC_AlertDescription_InsufficientSecurity == SPEC_AlertDescription_InsufficientSecurity { 71 }
-pub exec static EXEC_AlertDescription_InternalError: u8 ensures EXEC_AlertDescription_InternalError == SPEC_AlertDescription_InternalError { 80 }
-pub exec static EXEC_AlertDescription_InappropriateFallback: u8 ensures EXEC_AlertDescription_InappropriateFallback == SPEC_AlertDescription_InappropriateFallback { 86 }
-pub exec static EXEC_AlertDescription_UserCanceled: u8 ensures EXEC_AlertDescription_UserCanceled == SPEC_AlertDescription_UserCanceled { 90 }
-pub exec static EXEC_AlertDescription_MissingExtension: u8 ensures EXEC_AlertDescription_MissingExtension == SPEC_AlertDescription_MissingExtension { 109 }
-pub exec static EXEC_AlertDescription_UnsupportedExtension: u8 ensures EXEC_AlertDescription_UnsupportedExtension == SPEC_AlertDescription_UnsupportedExtension { 110 }
-pub exec static EXEC_AlertDescription_UnrecognizedName: u8 ensures EXEC_AlertDescription_UnrecognizedName == SPEC_AlertDescription_UnrecognizedName { 112 }
-pub exec static EXEC_AlertDescription_BadCertificateStatusResponse: u8 ensures EXEC_AlertDescription_BadCertificateStatusResponse == SPEC_AlertDescription_BadCertificateStatusResponse { 113 }
-pub exec static EXEC_AlertDescription_UnknownPSKIdentity: u8 ensures EXEC_AlertDescription_UnknownPSKIdentity == SPEC_AlertDescription_UnknownPSKIdentity { 115 }
-pub exec static EXEC_AlertDescription_CertificateRequired: u8 ensures EXEC_AlertDescription_CertificateRequired == SPEC_AlertDescription_CertificateRequired { 116 }
-pub exec static EXEC_AlertDescription_NoApplicationProtocol: u8 ensures EXEC_AlertDescription_NoApplicationProtocol == SPEC_AlertDescription_NoApplicationProtocol { 120 }
-
-#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
-pub enum AlertDescription {
-    CloseNotify = 0,
-UnexpectedMessage = 10,
-BadRecordMac = 20,
-RecordOverflow = 22,
-HandshakeFailure = 40,
-BadCertificate = 42,
-UnsupportedCertificate = 43,
-CertificateRevoked = 44,
-CertificateExpired = 45,
-CertificateUnknown = 46,
-IllegalParameter = 47,
-UnknownCA = 48,
-AccessDenied = 49,
-DecodeError = 50,
-DecryptError = 51,
-ProtocolVersion = 70,
-InsufficientSecurity = 71,
-InternalError = 80,
-InappropriateFallback = 86,
-UserCanceled = 90,
-MissingExtension = 109,
-UnsupportedExtension = 110,
-UnrecognizedName = 112,
-BadCertificateStatusResponse = 113,
-UnknownPSKIdentity = 115,
-CertificateRequired = 116,
-NoApplicationProtocol = 120
+pub struct SpecKeyUpdate {
+    pub request_update: SpecKeyUpdateRequest,
 }
-pub type SpecAlertDescription = AlertDescription;
 
-pub type AlertDescriptionInner = u8;
+pub type SpecKeyUpdateInner = SpecKeyUpdateRequest;
 
-pub type AlertDescriptionInnerRef<'a> = &'a u8;
 
-impl View for AlertDescription {
-    type V = Self;
+impl SpecFrom<SpecKeyUpdate> for SpecKeyUpdateInner {
+    open spec fn spec_from(m: SpecKeyUpdate) -> SpecKeyUpdateInner {
+        m.request_update
+    }
+}
 
-    open spec fn view(&self) -> Self::V {
-        *self
+impl SpecFrom<SpecKeyUpdateInner> for SpecKeyUpdate {
+    open spec fn spec_from(m: SpecKeyUpdateInner) -> SpecKeyUpdate {
+        let request_update = m;
+        SpecKeyUpdate { request_update }
     }
 }
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-impl SpecTryFrom<AlertDescriptionInner> for AlertDescription {
-    type Error = ();
+pub struct KeyUpdate {
+    pub request_update: KeyUpdateRequest,
+}
 
-    open spec fn spec_try_from(v: AlertDescriptionInner) -> Result<AlertDescription, ()> {
-        match v {
-            0u8 => Ok(AlertDescription::CloseNotify),
-            10u8 => Ok(AlertDescription::UnexpectedMessage),
-            20u8 => Ok(AlertDescription::BadRecordMac),
-            22u8 => Ok(AlertDescription::RecordOverflow),
-            40u8 => Ok(AlertDescription::HandshakeFailure),
-            42u8 => Ok(AlertDescription::BadCertificate),
-            43u8 => Ok(AlertDescription::UnsupportedCertificate),
-            44u8 => Ok(AlertDescription::CertificateRevoked),
-            45u8 => Ok(AlertDescription::CertificateExpired),
-            46u8 => Ok(AlertDescription::CertificateUnknown),
-            47u8 => Ok(AlertDescription::IllegalParameter),
-            48u8 => Ok(AlertDescription::UnknownCA),
-            49u8 => Ok(AlertDescription::AccessDenied),
-            50u8 => Ok(AlertDescription::DecodeError),
-            51u8 => Ok(AlertDescription::DecryptError),
-            70u8 => Ok(AlertDescription::ProtocolVersion),
-            71u8 => Ok(AlertDescription::InsufficientSecurity),
-            80u8 => Ok(AlertDescription::InternalError),
-            86u8 => Ok(AlertDescription::InappropriateFallback),
-            90u8 => Ok(AlertDescription::UserCanceled),
-            109u8 => Ok(AlertDescription::MissingExtension),
-            110u8 => Ok(AlertDescription::UnsupportedExtension),
-            112u8 => Ok(AlertDescription::UnrecognizedName),
-            113u8 => Ok(AlertDescription::BadCertificateStatusResponse),
-            115u8 => Ok(AlertDescription::UnknownPSKIdentity),
-            116u8 => Ok(AlertDescription::CertificateRequired),
-            120u8 => Ok(AlertDescription::NoApplicationProtocol),
-            _ => Err(()),
+impl View for KeyUpdate {
+    type V = SpecKeyUpdate;
+
+    open spec fn view(&self) -> Self::V {
+        SpecKeyUpdate {
+            request_update: self.request_update@,
         }
     }
 }
+pub type KeyUpdateInner = KeyUpdateRequest;
 
-impl SpecTryFrom<AlertDescription> for AlertDescriptionInner {
-    type Error = ();
-
-    open spec fn spec_try_from(v: AlertDescription) -> Result<AlertDescriptionInner, ()> {
-        match v {
-            AlertDescription::CloseNotify => Ok(SPEC_AlertDescription_CloseNotify),
-            AlertDescription::UnexpectedMessage => Ok(SPEC_AlertDescription_UnexpectedMessage),
-            AlertDescription::BadRecordMac => Ok(SPEC_AlertDescription_BadRecordMac),
-            AlertDescription::RecordOverflow => Ok(SPEC_AlertDescription_RecordOverflow),
-            AlertDescription::HandshakeFailure => Ok(SPEC_AlertDescription_HandshakeFailure),
-            AlertDescription::BadCertificate => Ok(SPEC_AlertDescription_BadCertificate),
-            AlertDescription::UnsupportedCertificate => Ok(SPEC_AlertDescription_UnsupportedCertificate),
-            AlertDescription::CertificateRevoked => Ok(SPEC_AlertDescription_CertificateRevoked),
-            AlertDescription::CertificateExpired => Ok(SPEC_AlertDescription_CertificateExpired),
-            AlertDescription::CertificateUnknown => Ok(SPEC_AlertDescription_CertificateUnknown),
-            AlertDescription::IllegalParameter => Ok(SPEC_AlertDescription_IllegalParameter),
-            AlertDescription::UnknownCA => Ok(SPEC_AlertDescription_UnknownCA),
-            AlertDescription::AccessDenied => Ok(SPEC_AlertDescription_AccessDenied),
-            AlertDescription::DecodeError => Ok(SPEC_AlertDescription_DecodeError),
-            AlertDescription::DecryptError => Ok(SPEC_AlertDescription_DecryptError),
-            AlertDescription::ProtocolVersion => Ok(SPEC_AlertDescription_ProtocolVersion),
-            AlertDescription::InsufficientSecurity => Ok(SPEC_AlertDescription_InsufficientSecurity),
-            AlertDescription::InternalError => Ok(SPEC_AlertDescription_InternalError),
-            AlertDescription::InappropriateFallback => Ok(SPEC_AlertDescription_InappropriateFallback),
-            AlertDescription::UserCanceled => Ok(SPEC_AlertDescription_UserCanceled),
-            AlertDescription::MissingExtension => Ok(SPEC_AlertDescription_MissingExtension),
-            AlertDescription::UnsupportedExtension => Ok(SPEC_AlertDescription_UnsupportedExtension),
-            AlertDescription::UnrecognizedName => Ok(SPEC_AlertDescription_UnrecognizedName),
-            AlertDescription::BadCertificateStatusResponse => Ok(SPEC_AlertDescription_BadCertificateStatusResponse),
-            AlertDescription::UnknownPSKIdentity => Ok(SPEC_AlertDescription_UnknownPSKIdentity),
-            AlertDescription::CertificateRequired => Ok(SPEC_AlertDescription_CertificateRequired),
-            AlertDescription::NoApplicationProtocol => Ok(SPEC_AlertDescription_NoApplicationProtocol),
+pub type KeyUpdateInnerRef<'a> = &'a KeyUpdateRequest;
+impl<'a> From<&'a KeyUpdate> for KeyUpdateInnerRef<'a> {
+    fn ex_from(m: &'a KeyUpdate) -> KeyUpdateInnerRef<'a> {
+        &m.request_update
+    }
+}
+
+impl From<KeyUpdateInner> for KeyUpdate {
+    fn ex_from(m: KeyUpdateInner) -> KeyUpdate {
+        let request_update = m;
+        KeyUpdate { request_update }
+    }
+}
+
+pub struct KeyUpdateMapper;
+impl View for KeyUpdateMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for KeyUpdateMapper {
+    type Src = SpecKeyUpdateInner;
+    type Dst = SpecKeyUpdate;
+}
+impl SpecIsoProof for KeyUpdateMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for KeyUpdateMapper {
+    type Src = KeyUpdateInner;
+    type Dst = KeyUpdate;
+    type RefSrc = KeyUpdateInnerRef<'a>;
+}
+
+pub struct SpecKeyUpdateCombinator(pub SpecKeyUpdateCombinatorAlias);
+
+impl SpecCombinator for SpecKeyUpdateCombinator {
+    type Type = SpecKeyUpdate;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecKeyUpdateCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecKeyUpdateCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecKeyUpdateCombinatorAlias = Mapped<SpecKeyUpdateRequestCombinator, KeyUpdateMapper>;
+
+pub struct KeyUpdateCombinator(pub KeyUpdateCombinatorAlias);
+
+impl View for KeyUpdateCombinator {
+    type V = SpecKeyUpdateCombinator;
+    open spec fn view(&self) -> Self::V { SpecKeyUpdateCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for KeyUpdateCombinator {
+    type Type = KeyUpdate;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type KeyUpdateCombinatorAlias = Mapped<KeyUpdateRequestCombinator, KeyUpdateMapper>;
+
+
+pub open spec fn spec_key_update() -> SpecKeyUpdateCombinator {
+    SpecKeyUpdateCombinator(
+    Mapped {
+        inner: spec_key_update_request(),
+        mapper: KeyUpdateMapper,
+    })
+}
+
+                
+pub fn key_update<'a>() -> (o: KeyUpdateCombinator)
+    ensures o@ == spec_key_update(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = KeyUpdateCombinator(
+    Mapped {
+        inner: key_update_request(),
+        mapper: KeyUpdateMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_key_update()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_key_update<'a>(input: &'a [u8]) -> (res: PResult<<KeyUpdateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_key_update().spec_parse(input@) == Some((n as int, v@)),
+        spec_key_update().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_key_update().spec_parse(input@) is None,
+        spec_key_update().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = key_update();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_key_update<'a>(v: <KeyUpdateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_key_update().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_key_update().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_key_update().spec_serialize(v@))
+        },
+{
+    let combinator = key_update();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn key_update_len<'a>(v: <KeyUpdateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_key_update().wf(v@),
+        spec_key_update().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_key_update().spec_serialize(v@).len(),
+{
+    let combinator = key_update();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub enum SpecHandshakeMsg {
+    ClientHello(SpecClientHello),
+    ServerHello(SpecShOrHrr),
+    NewSessionTicket(SpecNewSessionTicket),
+    EndOfEarlyData(SpecEmpty),
+    EncryptedExtensions(SpecEncryptedExtensions),
+    Certificate(SpecCertificate),
+    CertificateRequest(SpecCertificateRequest),
+    CertificateVerify(SpecCertificateVerify),
+    Finished(SpecFinished),
+    KeyUpdate(SpecKeyUpdate),
+}
+
+pub type SpecHandshakeMsgInner = Either<SpecClientHello, Either<SpecShOrHrr, Either<SpecNewSessionTicket, Either<SpecEmpty, Either<SpecEncryptedExtensions, Either<SpecCertificate, Either<SpecCertificateRequest, Either<SpecCertificateVerify, Either<SpecFinished, SpecKeyUpdate>>>>>>>>>;
+
+impl SpecFrom<SpecHandshakeMsg> for SpecHandshakeMsgInner {
+    open spec fn spec_from(m: SpecHandshakeMsg) -> SpecHandshakeMsgInner {
+        match m {
+            SpecHandshakeMsg::ClientHello(m) => Either::Left(m),
+            SpecHandshakeMsg::ServerHello(m) => Either::Right(Either::Left(m)),
+            SpecHandshakeMsg::NewSessionTicket(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecHandshakeMsg::EndOfEarlyData(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecHandshakeMsg::EncryptedExtensions(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecHandshakeMsg::Certificate(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            SpecHandshakeMsg::CertificateRequest(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            SpecHandshakeMsg::CertificateVerify(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
+            SpecHandshakeMsg::Finished(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
+            SpecHandshakeMsg::KeyUpdate(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecHandshakeMsgInner> for SpecHandshakeMsg {
+    open spec fn spec_from(m: SpecHandshakeMsgInner) -> SpecHandshakeMsg {
+        match m {
+            Either::Left(m) => SpecHandshakeMsg::ClientHello(m),
+            Either::Right(Either::Left(m)) => SpecHandshakeMsg::ServerHello(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecHandshakeMsg::NewSessionTicket(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecHandshakeMsg::EndOfEarlyData(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecHandshakeMsg::EncryptedExtensions(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecHandshakeMsg::Certificate(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => SpecHandshakeMsg::CertificateRequest(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => SpecHandshakeMsg::CertificateVerify(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => SpecHandshakeMsg::Finished(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))) => SpecHandshakeMsg::KeyUpdate(m),
+        }
+    }
+
+}
+
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum HandshakeMsg<'a> {
+    ClientHello(ClientHello<'a>),
+    ServerHello(ShOrHrr<'a>),
+    NewSessionTicket(NewSessionTicket<'a>),
+    EndOfEarlyData(Empty<'a>),
+    EncryptedExtensions(EncryptedExtensions<'a>),
+    Certificate(Certificate<'a>),
+    CertificateRequest(CertificateRequest<'a>),
+    CertificateVerify(CertificateVerify<'a>),
+    Finished(Finished<'a>),
+    KeyUpdate(KeyUpdate),
+}
+
+pub type HandshakeMsgInner<'a> = Either<ClientHello<'a>, Either<ShOrHrr<'a>, Either<NewSessionTicket<'a>, Either<Empty<'a>, Either<EncryptedExtensions<'a>, Either<Certificate<'a>, Either<CertificateRequest<'a>, Either<CertificateVerify<'a>, Either<Finished<'a>, KeyUpdate>>>>>>>>>;
+
+pub type HandshakeMsgInnerRef<'a> = Either<&'a ClientHello<'a>, Either<&'a ShOrHrr<'a>, Either<&'a NewSessionTicket<'a>, Either<&'a Empty<'a>, Either<&'a EncryptedExtensions<'a>, Either<&'a Certificate<'a>, Either<&'a CertificateRequest<'a>, Either<&'a CertificateVerify<'a>, Either<&'a Finished<'a>, &'a KeyUpdate>>>>>>>>>;
+
+
+impl<'a> View for HandshakeMsg<'a> {
+    type V = SpecHandshakeMsg;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            HandshakeMsg::ClientHello(m) => SpecHandshakeMsg::ClientHello(m@),
+            HandshakeMsg::ServerHello(m) => SpecHandshakeMsg::ServerHello(m@),
+            HandshakeMsg::NewSessionTicket(m) => SpecHandshakeMsg::NewSessionTicket(m@),
+            HandshakeMsg::EndOfEarlyData(m) => SpecHandshakeMsg::EndOfEarlyData(m@),
+            HandshakeMsg::EncryptedExtensions(m) => SpecHandshakeMsg::EncryptedExtensions(m@),
+            HandshakeMsg::Certificate(m) => SpecHandshakeMsg::Certificate(m@),
+            HandshakeMsg::CertificateRequest(m) => SpecHandshakeMsg::CertificateRequest(m@),
+            HandshakeMsg::CertificateVerify(m) => SpecHandshakeMsg::CertificateVerify(m@),
+            HandshakeMsg::Finished(m) => SpecHandshakeMsg::Finished(m@),
+            HandshakeMsg::KeyUpdate(m) => SpecHandshakeMsg::KeyUpdate(m@),
+        }
+    }
+}
+
+
+impl<'a> From<&'a HandshakeMsg<'a>> for HandshakeMsgInnerRef<'a> {
+    fn ex_from(m: &'a HandshakeMsg<'a>) -> HandshakeMsgInnerRef<'a> {
+        match m {
+            HandshakeMsg::ClientHello(m) => Either::Left(m),
+            HandshakeMsg::ServerHello(m) => Either::Right(Either::Left(m)),
+            HandshakeMsg::NewSessionTicket(m) => Either::Right(Either::Right(Either::Left(m))),
+            HandshakeMsg::EndOfEarlyData(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            HandshakeMsg::EncryptedExtensions(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            HandshakeMsg::Certificate(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            HandshakeMsg::CertificateRequest(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            HandshakeMsg::CertificateVerify(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
+            HandshakeMsg::Finished(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
+            HandshakeMsg::KeyUpdate(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))),
+        }
+    }
+
+}
+
+impl<'a> From<HandshakeMsgInner<'a>> for HandshakeMsg<'a> {
+    fn ex_from(m: HandshakeMsgInner<'a>) -> HandshakeMsg<'a> {
+        match m {
+            Either::Left(m) => HandshakeMsg::ClientHello(m),
+            Either::Right(Either::Left(m)) => HandshakeMsg::ServerHello(m),
+            Either::Right(Either::Right(Either::Left(m))) => HandshakeMsg::NewSessionTicket(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => HandshakeMsg::EndOfEarlyData(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => HandshakeMsg::EncryptedExtensions(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => HandshakeMsg::Certificate(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => HandshakeMsg::CertificateRequest(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => HandshakeMsg::CertificateVerify(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => HandshakeMsg::Finished(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))) => HandshakeMsg::KeyUpdate(m),
+        }
+    }
+    
+}
+
+
+pub struct HandshakeMsgMapper;
+impl View for HandshakeMsgMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for HandshakeMsgMapper {
+    type Src = SpecHandshakeMsgInner;
+    type Dst = SpecHandshakeMsg;
+}
+impl SpecIsoProof for HandshakeMsgMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for HandshakeMsgMapper {
+    type Src = HandshakeMsgInner<'a>;
+    type Dst = HandshakeMsg<'a>;
+    type RefSrc = HandshakeMsgInnerRef<'a>;
+}
+
+type SpecHandshakeMsgCombinatorAlias1 = Choice<Cond<SpecFinishedCombinator>, Cond<SpecKeyUpdateCombinator>>;
+type SpecHandshakeMsgCombinatorAlias2 = Choice<Cond<SpecCertificateVerifyCombinator>, SpecHandshakeMsgCombinatorAlias1>;
+type SpecHandshakeMsgCombinatorAlias3 = Choice<Cond<SpecCertificateRequestCombinator>, SpecHandshakeMsgCombinatorAlias2>;
+type SpecHandshakeMsgCombinatorAlias4 = Choice<Cond<SpecCertificateCombinator>, SpecHandshakeMsgCombinatorAlias3>;
+type SpecHandshakeMsgCombinatorAlias5 = Choice<Cond<SpecEncryptedExtensionsCombinator>, SpecHandshakeMsgCombinatorAlias4>;
+type SpecHandshakeMsgCombinatorAlias6 = Choice<Cond<SpecEmptyCombinator>, SpecHandshakeMsgCombinatorAlias5>;
+type SpecHandshakeMsgCombinatorAlias7 = Choice<Cond<SpecNewSessionTicketCombinator>, SpecHandshakeMsgCombinatorAlias6>;
+type SpecHandshakeMsgCombinatorAlias8 = Choice<Cond<SpecShOrHrrCombinator>, SpecHandshakeMsgCombinatorAlias7>;
+type SpecHandshakeMsgCombinatorAlias9 = Choice<Cond<SpecClientHelloCombinator>, SpecHandshakeMsgCombinatorAlias8>;
+pub struct SpecHandshakeMsgCombinator(pub SpecHandshakeMsgCombinatorAlias);
+
+impl SpecCombinator for SpecHandshakeMsgCombinator {
+    type Type = SpecHandshakeMsg;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecHandshakeMsgCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHandshakeMsgCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecHandshakeMsgCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecHandshakeMsgCombinatorAlias9, HandshakeMsgMapper>>;
+type HandshakeMsgCombinatorAlias1 = Choice<Cond<FinishedCombinator>, Cond<KeyUpdateCombinator>>;
+type HandshakeMsgCombinatorAlias2 = Choice<Cond<CertificateVerifyCombinator>, HandshakeMsgCombinator1>;
+type HandshakeMsgCombinatorAlias3 = Choice<Cond<CertificateRequestCombinator>, HandshakeMsgCombinator2>;
+type HandshakeMsgCombinatorAlias4 = Choice<Cond<CertificateCombinator>, HandshakeMsgCombinator3>;
+type HandshakeMsgCombinatorAlias5 = Choice<Cond<EncryptedExtensionsCombinator>, HandshakeMsgCombinator4>;
+type HandshakeMsgCombinatorAlias6 = Choice<Cond<EmptyCombinator>, HandshakeMsgCombinator5>;
+type HandshakeMsgCombinatorAlias7 = Choice<Cond<NewSessionTicketCombinator>, HandshakeMsgCombinator6>;
+type HandshakeMsgCombinatorAlias8 = Choice<Cond<ShOrHrrCombinator>, HandshakeMsgCombinator7>;
+type HandshakeMsgCombinatorAlias9 = Choice<Cond<ClientHelloCombinator>, HandshakeMsgCombinator8>;
+pub struct HandshakeMsgCombinator1(pub HandshakeMsgCombinatorAlias1);
+impl View for HandshakeMsgCombinator1 {
+    type V = SpecHandshakeMsgCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(HandshakeMsgCombinator1, HandshakeMsgCombinatorAlias1);
+
+pub struct HandshakeMsgCombinator2(pub HandshakeMsgCombinatorAlias2);
+impl View for HandshakeMsgCombinator2 {
+    type V = SpecHandshakeMsgCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(HandshakeMsgCombinator2, HandshakeMsgCombinatorAlias2);
+
+pub struct HandshakeMsgCombinator3(pub HandshakeMsgCombinatorAlias3);
+impl View for HandshakeMsgCombinator3 {
+    type V = SpecHandshakeMsgCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(HandshakeMsgCombinator3, HandshakeMsgCombinatorAlias3);
+
+pub struct HandshakeMsgCombinator4(pub HandshakeMsgCombinatorAlias4);
+impl View for HandshakeMsgCombinator4 {
+    type V = SpecHandshakeMsgCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(HandshakeMsgCombinator4, HandshakeMsgCombinatorAlias4);
+
+pub struct HandshakeMsgCombinator5(pub HandshakeMsgCombinatorAlias5);
+impl View for HandshakeMsgCombinator5 {
+    type V = SpecHandshakeMsgCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(HandshakeMsgCombinator5, HandshakeMsgCombinatorAlias5);
+
+pub struct HandshakeMsgCombinator6(pub HandshakeMsgCombinatorAlias6);
+impl View for HandshakeMsgCombinator6 {
+    type V = SpecHandshakeMsgCombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(HandshakeMsgCombinator6, HandshakeMsgCombinatorAlias6);
+
+pub struct HandshakeMsgCombinator7(pub HandshakeMsgCombinatorAlias7);
+impl View for HandshakeMsgCombinator7 {
+    type V = SpecHandshakeMsgCombinatorAlias7;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(HandshakeMsgCombinator7, HandshakeMsgCombinatorAlias7);
+
+pub struct HandshakeMsgCombinator8(pub HandshakeMsgCombinatorAlias8);
+impl View for HandshakeMsgCombinator8 {
+    type V = SpecHandshakeMsgCombinatorAlias8;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(HandshakeMsgCombinator8, HandshakeMsgCombinatorAlias8);
+
+pub struct HandshakeMsgCombinator9(pub HandshakeMsgCombinatorAlias9);
+impl View for HandshakeMsgCombinator9 {
+    type V = SpecHandshakeMsgCombinatorAlias9;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(HandshakeMsgCombinator9, HandshakeMsgCombinatorAlias9);
+
+pub struct HandshakeMsgCombinator(pub HandshakeMsgCombinatorAlias);
+
+impl View for HandshakeMsgCombinator {
+    type V = SpecHandshakeMsgCombinator;
+    open spec fn view(&self) -> Self::V { SpecHandshakeMsgCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HandshakeMsgCombinator {
+    type Type = HandshakeMsg<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type HandshakeMsgCombinatorAlias = AndThen<bytes::Variable, Mapped<HandshakeMsgCombinator9, HandshakeMsgMapper>>;
+
+
+pub open spec fn spec_handshake_msg(length: u24, msg_type: SpecHandshakeType) -> SpecHandshakeMsgCombinator {
+    SpecHandshakeMsgCombinator(AndThen(bytes::Variable((usize::spec_from(length)) as usize), Mapped { inner: Choice(Cond { cond: msg_type == HandshakeType::ClientHello, inner: spec_client_hello() }, Choice(Cond { cond: msg_type == HandshakeType::ServerHello, inner: spec_sh_or_hrr() }, Choice(Cond { cond: msg_type == HandshakeType::NewSessionTicket, inner: spec_new_session_ticket() }, Choice(Cond { cond: msg_type == HandshakeType::EndOfEarlyData, inner: spec_empty() }, Choice(Cond { cond: msg_type == HandshakeType::EncryptedExtensions, inner: spec_encrypted_extensions() }, Choice(Cond { cond: msg_type == HandshakeType::Certificate, inner: spec_certificate() }, Choice(Cond { cond: msg_type == HandshakeType::CertificateRequest, inner: spec_certificate_request() }, Choice(Cond { cond: msg_type == HandshakeType::CertificateVerify, inner: spec_certificate_verify() }, Choice(Cond { cond: msg_type == HandshakeType::Finished, inner: spec_finished(length) }, Cond { cond: msg_type == HandshakeType::KeyUpdate, inner: spec_key_update() }))))))))), mapper: HandshakeMsgMapper }))
+}
+
+pub fn handshake_msg<'a>(length: u24, msg_type: HandshakeType) -> (o: HandshakeMsgCombinator)
+    requires
+        spec_handshake_type().wf(msg_type@),
+
+    ensures o@ == spec_handshake_msg(length@, msg_type@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = HandshakeMsgCombinator(AndThen(bytes::Variable((usize::ex_from(length)) as usize), Mapped { inner: HandshakeMsgCombinator9(Choice::new(Cond { cond: msg_type == HandshakeType::ClientHello, inner: client_hello() }, HandshakeMsgCombinator8(Choice::new(Cond { cond: msg_type == HandshakeType::ServerHello, inner: sh_or_hrr() }, HandshakeMsgCombinator7(Choice::new(Cond { cond: msg_type == HandshakeType::NewSessionTicket, inner: new_session_ticket() }, HandshakeMsgCombinator6(Choice::new(Cond { cond: msg_type == HandshakeType::EndOfEarlyData, inner: empty() }, HandshakeMsgCombinator5(Choice::new(Cond { cond: msg_type == HandshakeType::EncryptedExtensions, inner: encrypted_extensions() }, HandshakeMsgCombinator4(Choice::new(Cond { cond: msg_type == HandshakeType::Certificate, inner: certificate() }, HandshakeMsgCombinator3(Choice::new(Cond { cond: msg_type == HandshakeType::CertificateRequest, inner: certificate_request() }, HandshakeMsgCombinator2(Choice::new(Cond { cond: msg_type == HandshakeType::CertificateVerify, inner: certificate_verify() }, HandshakeMsgCombinator1(Choice::new(Cond { cond: msg_type == HandshakeType::Finished, inner: finished(length) }, Cond { cond: msg_type == HandshakeType::KeyUpdate, inner: key_update() })))))))))))))))))), mapper: HandshakeMsgMapper }));
+    // assert({
+    //     &&& combinator@ == spec_handshake_msg(length@, msg_type@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_handshake_msg<'a>(input: &'a [u8], length: u24, msg_type: HandshakeType) -> (res: PResult<<HandshakeMsgCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+        spec_handshake_type().wf(msg_type@),
+
+    ensures
+        res matches Ok((n, v)) ==> spec_handshake_msg(length@, msg_type@).spec_parse(input@) == Some((n as int, v@)),
+        spec_handshake_msg(length@, msg_type@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_handshake_msg(length@, msg_type@).spec_parse(input@) is None,
+        spec_handshake_msg(length@, msg_type@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = handshake_msg( length, msg_type );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_handshake_msg<'a>(v: <HandshakeMsgCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, length: u24, msg_type: HandshakeType) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_handshake_msg(length@, msg_type@).wf(v@),
+        spec_handshake_type().wf(msg_type@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_handshake_msg(length@, msg_type@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_handshake_msg(length@, msg_type@).spec_serialize(v@))
+        },
+{
+    let combinator = handshake_msg( length, msg_type );
+    combinator.serialize(v, data, pos)
+}
+
+pub fn handshake_msg_len<'a>(v: <HandshakeMsgCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, length: u24, msg_type: HandshakeType) -> (serialize_len: usize)
+    requires
+        spec_handshake_msg(length@, msg_type@).wf(v@),
+        spec_handshake_msg(length@, msg_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_handshake_type().wf(msg_type@),
+
+    ensures
+        serialize_len == spec_handshake_msg(length@, msg_type@).spec_serialize(v@).len(),
+{
+    let combinator = handshake_msg( length, msg_type );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+
+pub struct SpecHandshake {
+    pub msg_type: SpecHandshakeType,
+    pub length: u24,
+    pub msg: SpecHandshakeMsg,
+}
+
+pub type SpecHandshakeInner = ((SpecHandshakeType, u24), SpecHandshakeMsg);
+
+
+impl SpecFrom<SpecHandshake> for SpecHandshakeInner {
+    open spec fn spec_from(m: SpecHandshake) -> SpecHandshakeInner {
+        ((m.msg_type, m.length), m.msg)
+    }
+}
+
+impl SpecFrom<SpecHandshakeInner> for SpecHandshake {
+    open spec fn spec_from(m: SpecHandshakeInner) -> SpecHandshake {
+        let ((msg_type, length), msg) = m;
+        SpecHandshake { msg_type, length, msg }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Handshake<'a> {
+    pub msg_type: HandshakeType,
+    pub length: u24,
+    pub msg: HandshakeMsg<'a>,
+}
+
+impl View for Handshake<'_> {
+    type V = SpecHandshake;
+
+    open spec fn view(&self) -> Self::V {
+        SpecHandshake {
+            msg_type: self.msg_type@,
+            length: self.length@,
+            msg: self.msg@,
+        }
+    }
+}
+pub type HandshakeInner<'a> = ((HandshakeType, u24), HandshakeMsg<'a>);
+
+pub type HandshakeInnerRef<'a> = ((&'a HandshakeType, &'a u24), &'a HandshakeMsg<'a>);
+impl<'a> From<&'a Handshake<'a>> for HandshakeInnerRef<'a> {
+    fn ex_from(m: &'a Handshake) -> HandshakeInnerRef<'a> {
+        ((&m.msg_type, &m.length), &m.msg)
+    }
+}
+
+impl<'a> From<HandshakeInner<'a>> for Handshake<'a> {
+    fn ex_from(m: HandshakeInner) -> Handshake {
+        let ((msg_type, length), msg) = m;
+        Handshake { msg_type, length, msg }
+    }
+}
+
+pub struct HandshakeMapper;
+impl View for HandshakeMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for HandshakeMapper {
+    type Src = SpecHandshakeInner;
+    type Dst = SpecHandshake;
+}
+impl SpecIsoProof for HandshakeMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for HandshakeMapper {
+    type Src = HandshakeInner<'a>;
+    type Dst = Handshake<'a>;
+    type RefSrc = HandshakeInnerRef<'a>;
+}
+
+pub struct SpecHandshakeCombinator(pub SpecHandshakeCombinatorAlias);
+
+impl SpecCombinator for SpecHandshakeCombinator {
+    type Type = SpecHandshake;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecHandshakeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHandshakeCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecHandshakeCombinatorAlias = Mapped<SpecPair<SpecPair<SpecHandshakeTypeCombinator, U24Be>, SpecHandshakeMsgCombinator>, HandshakeMapper>;
+
+pub struct HandshakeCombinator(pub HandshakeCombinatorAlias);
+
+impl View for HandshakeCombinator {
+    type V = SpecHandshakeCombinator;
+    open spec fn view(&self) -> Self::V { SpecHandshakeCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HandshakeCombinator {
+    type Type = Handshake<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type HandshakeCombinatorAlias = Mapped<Pair<Pair<HandshakeTypeCombinator, U24Be, HandshakeCont1>, HandshakeMsgCombinator, HandshakeCont0>, HandshakeMapper>;
+
+
+pub open spec fn spec_handshake() -> SpecHandshakeCombinator {
+    SpecHandshakeCombinator(
+    Mapped {
+        inner: Pair::spec_new(Pair::spec_new(spec_handshake_type(), |deps| spec_handshake_cont1(deps)), |deps| spec_handshake_cont0(deps)),
+        mapper: HandshakeMapper,
+    })
+}
+
+pub open spec fn spec_handshake_cont1(deps: SpecHandshakeType) -> U24Be {
+    let msg_type = deps;
+    U24Be
+}
+
+impl View for HandshakeCont1 {
+    type V = spec_fn(SpecHandshakeType) -> U24Be;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: SpecHandshakeType| {
+            spec_handshake_cont1(deps)
+        }
+    }
+}
+
+pub open spec fn spec_handshake_cont0(deps: (SpecHandshakeType, u24)) -> SpecHandshakeMsgCombinator {
+    let (msg_type, length) = deps;
+    spec_handshake_msg(length, msg_type)
+}
+
+impl View for HandshakeCont0 {
+    type V = spec_fn((SpecHandshakeType, u24)) -> SpecHandshakeMsgCombinator;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: (SpecHandshakeType, u24)| {
+            spec_handshake_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn handshake<'a>() -> (o: HandshakeCombinator)
+    ensures o@ == spec_handshake(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = HandshakeCombinator(
+    Mapped {
+        inner: Pair::new(Pair::new(handshake_type(), HandshakeCont1), HandshakeCont0),
+        mapper: HandshakeMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_handshake()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_handshake<'a>(input: &'a [u8]) -> (res: PResult<<HandshakeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_handshake().spec_parse(input@) == Some((n as int, v@)),
+        spec_handshake().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_handshake().spec_parse(input@) is None,
+        spec_handshake().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = handshake();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_handshake<'a>(v: <HandshakeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_handshake().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_handshake().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_handshake().spec_serialize(v@))
+        },
+{
+    let combinator = handshake();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn handshake_len<'a>(v: <HandshakeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_handshake().wf(v@),
+        spec_handshake().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_handshake().spec_serialize(v@).len(),
+{
+    let combinator = handshake();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct HandshakeCont1;
+type HandshakeCont1Type<'a, 'b> = &'b HandshakeType;
+type HandshakeCont1SType<'a, 'x> = &'x HandshakeType;
+type HandshakeCont1Input<'a, 'b, 'x> = POrSType<HandshakeCont1Type<'a, 'b>, HandshakeCont1SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<HandshakeCont1Input<'a, 'b, 'x>> for HandshakeCont1 {
+    type Output = U24Be;
+
+    open spec fn requires(&self, deps: HandshakeCont1Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_handshake_type()).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: HandshakeCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_handshake_cont1(deps@)
+    }
+
+    fn apply(&self, deps: HandshakeCont1Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let msg_type = deps;
+                let msg_type = *msg_type;
+                U24Be
+            }
+            POrSType::S(deps) => {
+                let msg_type = deps;
+                let msg_type = *msg_type;
+                U24Be
+            }
+        }
+    }
+}
+pub struct HandshakeCont0;
+type HandshakeCont0Type<'a, 'b> = &'b (HandshakeType, u24);
+type HandshakeCont0SType<'a, 'x> = (&'x HandshakeType, &'x u24);
+type HandshakeCont0Input<'a, 'b, 'x> = POrSType<HandshakeCont0Type<'a, 'b>, HandshakeCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<HandshakeCont0Input<'a, 'b, 'x>> for HandshakeCont0 {
+    type Output = HandshakeMsgCombinator;
+
+    open spec fn requires(&self, deps: HandshakeCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Pair::spec_new(spec_handshake_type(), |deps| spec_handshake_cont1(deps))).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: HandshakeCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_handshake_cont0(deps@)
+    }
+
+    fn apply(&self, deps: HandshakeCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let (msg_type, length) = deps;
+                let msg_type = *msg_type;
+                let length = *length;
+                handshake_msg(length, msg_type)
+            }
+            POrSType::S(deps) => {
+                let (msg_type, length) = deps;
+                let msg_type = *msg_type;
+                let length = *length;
+                handshake_msg(length, msg_type)
+            }
+        }
+    }
+}
+                
+
+pub struct SpecZeroByte {
+    pub zero: u8,
+}
+
+pub type SpecZeroByteInner = u8;
+
+
+impl SpecFrom<SpecZeroByte> for SpecZeroByteInner {
+    open spec fn spec_from(m: SpecZeroByte) -> SpecZeroByteInner {
+        m.zero
+    }
+}
+
+impl SpecFrom<SpecZeroByteInner> for SpecZeroByte {
+    open spec fn spec_from(m: SpecZeroByteInner) -> SpecZeroByte {
+        let zero = m;
+        SpecZeroByte { zero }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct ZeroByte {
+    pub zero: u8,
+}
+
+impl View for ZeroByte {
+    type V = SpecZeroByte;
+
+    open spec fn view(&self) -> Self::V {
+        SpecZeroByte {
+            zero: self.zero@,
+        }
+    }
+}
+pub type ZeroByteInner = u8;
+
+pub type ZeroByteInnerRef<'a> = &'a u8;
+impl<'a> From<&'a ZeroByte> for ZeroByteInnerRef<'a> {
+    fn ex_from(m: &'a ZeroByte) -> ZeroByteInnerRef<'a> {
+        &m.zero
+    }
+}
+
+impl From<ZeroByteInner> for ZeroByte {
+    fn ex_from(m: ZeroByteInner) -> ZeroByte {
+        let zero = m;
+        ZeroByte { zero }
+    }
+}
+
+pub struct ZeroByteMapper;
+impl View for ZeroByteMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ZeroByteMapper {
+    type Src = SpecZeroByteInner;
+    type Dst = SpecZeroByte;
+}
+impl SpecIsoProof for ZeroByteMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ZeroByteMapper {
+    type Src = ZeroByteInner;
+    type Dst = ZeroByte;
+    type RefSrc = ZeroByteInnerRef<'a>;
+}
+pub const ZEROBYTEZERO_CONST: u8 = 0;
+
+pub struct SpecZeroByteCombinator(pub SpecZeroByteCombinatorAlias);
+
+impl SpecCombinator for SpecZeroByteCombinator {
+    type Type = SpecZeroByte;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecZeroByteCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecZeroByteCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecZeroByteCombinatorAlias = Mapped<Refined<U8, TagPred<u8>>, ZeroByteMapper>;
+
+pub struct ZeroByteCombinator(pub ZeroByteCombinatorAlias);
+
+impl View for ZeroByteCombinator {
+    type V = SpecZeroByteCombinator;
+    open spec fn view(&self) -> Self::V { SpecZeroByteCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ZeroByteCombinator {
+    type Type = ZeroByte;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ZeroByteCombinatorAlias = Mapped<Refined<U8, TagPred<u8>>, ZeroByteMapper>;
+
+
+pub open spec fn spec_zero_byte() -> SpecZeroByteCombinator {
+    SpecZeroByteCombinator(
+    Mapped {
+        inner: Refined { inner: U8, predicate: TagPred(ZEROBYTEZERO_CONST) },
+        mapper: ZeroByteMapper,
+    })
+}
+
+                
+pub fn zero_byte<'a>() -> (o: ZeroByteCombinator)
+    ensures o@ == spec_zero_byte(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ZeroByteCombinator(
+    Mapped {
+        inner: Refined { inner: U8, predicate: TagPred(ZEROBYTEZERO_CONST) },
+        mapper: ZeroByteMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_zero_byte()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_zero_byte<'a>(input: &'a [u8]) -> (res: PResult<<ZeroByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_zero_byte().spec_parse(input@) == Some((n as int, v@)),
+        spec_zero_byte().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_zero_byte().spec_parse(input@) is None,
+        spec_zero_byte().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = zero_byte();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_zero_byte<'a>(v: <ZeroByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_zero_byte().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_zero_byte().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_zero_byte().spec_serialize(v@))
+        },
+{
+    let combinator = zero_byte();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn zero_byte_len<'a>(v: <ZeroByteCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_zero_byte().wf(v@),
+        spec_zero_byte().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_zero_byte().spec_serialize(v@).len(),
+{
+    let combinator = zero_byte();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecPaddingExtension {
+    pub l: u16,
+    pub padding: Seq<SpecZeroByte>,
+}
+
+pub type SpecPaddingExtensionInner = (u16, Seq<SpecZeroByte>);
+
+
+impl SpecFrom<SpecPaddingExtension> for SpecPaddingExtensionInner {
+    open spec fn spec_from(m: SpecPaddingExtension) -> SpecPaddingExtensionInner {
+        (m.l, m.padding)
+    }
+}
+
+impl SpecFrom<SpecPaddingExtensionInner> for SpecPaddingExtension {
+    open spec fn spec_from(m: SpecPaddingExtensionInner) -> SpecPaddingExtension {
+        let (l, padding) = m;
+        SpecPaddingExtension { l, padding }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct PaddingExtension {
+    pub l: u16,
+    pub padding: RepeatResult<ZeroByte>,
+}
+
+impl View for PaddingExtension {
+    type V = SpecPaddingExtension;
+
+    open spec fn view(&self) -> Self::V {
+        SpecPaddingExtension {
+            l: self.l@,
+            padding: self.padding@,
+        }
+    }
+}
+pub type PaddingExtensionInner = (u16, RepeatResult<ZeroByte>);
+
+pub type PaddingExtensionInnerRef<'a> = (&'a u16, &'a RepeatResult<ZeroByte>);
+impl<'a> From<&'a PaddingExtension> for PaddingExtensionInnerRef<'a> {
+    fn ex_from(m: &'a PaddingExtension) -> PaddingExtensionInnerRef<'a> {
+        (&m.l, &m.padding)
+    }
+}
+
+impl From<PaddingExtensionInner> for PaddingExtension {
+    fn ex_from(m: PaddingExtensionInner) -> PaddingExtension {
+        let (l, padding) = m;
+        PaddingExtension { l, padding }
+    }
+}
+
+pub struct PaddingExtensionMapper;
+impl View for PaddingExtensionMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for PaddingExtensionMapper {
+    type Src = SpecPaddingExtensionInner;
+    type Dst = SpecPaddingExtension;
+}
+impl SpecIsoProof for PaddingExtensionMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for PaddingExtensionMapper {
+    type Src = PaddingExtensionInner;
+    type Dst = PaddingExtension;
+    type RefSrc = PaddingExtensionInnerRef<'a>;
+}
+
+pub struct SpecPaddingExtensionCombinator(pub SpecPaddingExtensionCombinatorAlias);
+
+impl SpecCombinator for SpecPaddingExtensionCombinator {
+    type Type = SpecPaddingExtension;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecPaddingExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPaddingExtensionCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecPaddingExtensionCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecZeroByteCombinator>>>, PaddingExtensionMapper>;
+
+pub struct PaddingExtensionCombinator(pub PaddingExtensionCombinatorAlias);
+
+impl View for PaddingExtensionCombinator {
+    type V = SpecPaddingExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecPaddingExtensionCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PaddingExtensionCombinator {
+    type Type = PaddingExtension;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type PaddingExtensionCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<ZeroByteCombinator>>, PaddingExtensionCont0>, PaddingExtensionMapper>;
+
+
+pub open spec fn spec_padding_extension(ext_len: u16) -> SpecPaddingExtensionCombinator {
+    SpecPaddingExtensionCombinator(
+    Mapped {
+        inner: Pair::spec_new(U16Be, |deps| spec_padding_extension_cont0(ext_len, deps)),
+        mapper: PaddingExtensionMapper,
+    })
+}
+
+pub open spec fn spec_padding_extension_cont0(ext_len: u16, deps: u16) -> AndThen<bytes::Variable, Repeat<SpecZeroByteCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_zero_byte()))
+}
+
+impl View for PaddingExtensionCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecZeroByteCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_padding_extension_cont0(self.ext_len@, deps)
+        }
+    }
+}
+
+pub fn padding_extension<'a>(ext_len: u16) -> (o: PaddingExtensionCombinator)
+
+    ensures o@ == spec_padding_extension(ext_len@),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = PaddingExtensionCombinator(
+    Mapped {
+        inner: Pair::new(U16Be, PaddingExtensionCont0 { ext_len }),
+        mapper: PaddingExtensionMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_padding_extension(ext_len@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_padding_extension<'a>(input: &'a [u8], ext_len: u16) -> (res: PResult<<PaddingExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+
+    ensures
+        res matches Ok((n, v)) ==> spec_padding_extension(ext_len@).spec_parse(input@) == Some((n as int, v@)),
+        spec_padding_extension(ext_len@).spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_padding_extension(ext_len@).spec_parse(input@) is None,
+        spec_padding_extension(ext_len@).spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = padding_extension( ext_len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_padding_extension<'a>(v: <PaddingExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_padding_extension(ext_len@).wf(v@),
+
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_padding_extension(ext_len@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_padding_extension(ext_len@).spec_serialize(v@))
+        },
+{
+    let combinator = padding_extension( ext_len );
+    combinator.serialize(v, data, pos)
+}
+
+pub fn padding_extension_len<'a>(v: <PaddingExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16) -> (serialize_len: usize)
+    requires
+        spec_padding_extension(ext_len@).wf(v@),
+        spec_padding_extension(ext_len@).spec_serialize(v@).len() <= usize::MAX,
+
+    ensures
+        serialize_len == spec_padding_extension(ext_len@).spec_serialize(v@).len(),
+{
+    let combinator = padding_extension( ext_len );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct PaddingExtensionCont0 {
+    pub ext_len: u16,
+}
+type PaddingExtensionCont0Type<'a, 'b> = &'b u16;
+type PaddingExtensionCont0SType<'a, 'x> = &'x u16;
+type PaddingExtensionCont0Input<'a, 'b, 'x> = POrSType<PaddingExtensionCont0Type<'a, 'b>, PaddingExtensionCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<PaddingExtensionCont0Input<'a, 'b, 'x>> for PaddingExtensionCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<ZeroByteCombinator>>;
+
+    open spec fn requires(&self, deps: PaddingExtensionCont0Input<'a, 'b, 'x>) -> bool {        let ext_len = self.ext_len@;
+
+        &&& (U16Be).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: PaddingExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_padding_extension_cont0(self.ext_len@, deps@)
+    }
+
+    fn apply(&self, deps: PaddingExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let ext_len = self.ext_len;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(zero_byte()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let ext_len = self.ext_len;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(zero_byte()))
+            }
         }
     }
 }
 
-impl TryFrom<AlertDescriptionInner> for AlertDescription {
-    type Error = ();
+pub struct SpecExtension {
+    pub extension_type: u16,
+    pub extension_data: SpecOpaque0Ffff,
+}
+
+pub type SpecExtensionInner = (u16, SpecOpaque0Ffff);
+
+
+impl SpecFrom<SpecExtension> for SpecExtensionInner {
+    open spec fn spec_from(m: SpecExtension) -> SpecExtensionInner {
+        (m.extension_type, m.extension_data)
+    }
+}
+
+impl SpecFrom<SpecExtensionInner> for SpecExtension {
+    open spec fn spec_from(m: SpecExtensionInner) -> SpecExtension {
+        let (extension_type, extension_data) = m;
+        SpecExtension { extension_type, extension_data }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-    fn ex_try_from(v: AlertDescriptionInner) -> Result<AlertDescription, ()> {
-        match v {
-            0u8 => Ok(AlertDescription::CloseNotify),
-            10u8 => Ok(AlertDescription::UnexpectedMessage),
-            20u8 => Ok(AlertDescription::BadRecordMac),
-            22u8 => Ok(AlertDescription::RecordOverflow),
-            40u8 => Ok(AlertDescription::HandshakeFailure),
-            42u8 => Ok(AlertDescription::BadCertificate),
-            43u8 => Ok(AlertDescription::UnsupportedCertificate),
-            44u8 => Ok(AlertDescription::CertificateRevoked),
-            45u8 => Ok(AlertDescription::CertificateExpired),
-            46u8 => Ok(AlertDescription::CertificateUnknown),
-            47u8 => Ok(AlertDescription::IllegalParameter),
-            48u8 => Ok(AlertDescription::UnknownCA),
-            49u8 => Ok(AlertDescription::AccessDenied),
-            50u8 => Ok(AlertDescription::DecodeError),
-            51u8 => Ok(AlertDescription::DecryptError),
-            70u8 => Ok(AlertDescription::ProtocolVersion),
-            71u8 => Ok(AlertDescription::InsufficientSecurity),
-            80u8 => Ok(AlertDescription::InternalError),
-            86u8 => Ok(AlertDescription::InappropriateFallback),
-            90u8 => Ok(AlertDescription::UserCanceled),
-            109u8 => Ok(AlertDescription::MissingExtension),
-            110u8 => Ok(AlertDescription::UnsupportedExtension),
-            112u8 => Ok(AlertDescription::UnrecognizedName),
-            113u8 => Ok(AlertDescription::BadCertificateStatusResponse),
-            115u8 => Ok(AlertDescription::UnknownPSKIdentity),
-            116u8 => Ok(AlertDescription::CertificateRequired),
-            120u8 => Ok(AlertDescription::NoApplicationProtocol),
-            _ => Err(()),
+pub struct Extension<'a> {
+    pub extension_type: u16,
+    pub extension_data: Opaque0Ffff<'a>,
+}
+
+impl View for Extension<'_> {
+    type V = SpecExtension;
+
+    open spec fn view(&self) -> Self::V {
+        SpecExtension {
+            extension_type: self.extension_type@,
+            extension_data: self.extension_data@,
         }
     }
 }
+pub type ExtensionInner<'a> = (u16, Opaque0Ffff<'a>);
 
-impl<'a> TryFrom<&'a AlertDescription> for AlertDescriptionInnerRef<'a> {
-    type Error = ();
+pub type ExtensionInnerRef<'a> = (&'a u16, &'a Opaque0Ffff<'a>);
+impl<'a> From<&'a Extension<'a>> for ExtensionInnerRef<'a> {
+    fn ex_from(m: &'a Extension) -> ExtensionInnerRef<'a> {
+        (&m.extension_type, &m.extension_data)
+    }
+}
 
-    fn ex_try_from(v: &'a AlertDescription) -> Result<AlertDescriptionInnerRef<'a>, ()> {
-        match v {
-            AlertDescription::CloseNotify => Ok(&EXEC_AlertDescription_CloseNotify),
-            AlertDescription::UnexpectedMessage => Ok(&EXEC_AlertDescription_UnexpectedMessage),
-            AlertDescription::BadRecordMac => Ok(&EXEC_AlertDescription_BadRecordMac),
-            AlertDescription::RecordOverflow => Ok(&EXEC_AlertDescription_RecordOverflow),
-            AlertDescription::HandshakeFailure => Ok(&EXEC_AlertDescription_HandshakeFailure),
-            AlertDescription::BadCertificate => Ok(&EXEC_AlertDescription_BadCertificate),
-            AlertDescription::UnsupportedCertificate => Ok(&EXEC_AlertDescription_UnsupportedCertificate),
-            AlertDescription::CertificateRevoked => Ok(&EXEC_AlertDescription_CertificateRevoked),
-            AlertDescription::CertificateExpired => Ok(&EXEC_AlertDescription_CertificateExpired),
-            AlertDescription::CertificateUnknown => Ok(&EXEC_AlertDescription_CertificateUnknown),
-            AlertDescription::IllegalParameter => Ok(&EXEC_AlertDescription_IllegalParameter),
-            AlertDescription::UnknownCA => Ok(&EXEC_AlertDescription_UnknownCA),
-            AlertDescription::AccessDenied => Ok(&EXEC_AlertDescription_AccessDenied),
-            AlertDescription::DecodeError => Ok(&EXEC_AlertDescription_DecodeError),
-            AlertDescription::DecryptError => Ok(&EXEC_AlertDescription_DecryptError),
-            AlertDescription::ProtocolVersion => Ok(&EXEC_AlertDescription_ProtocolVersion),
-            AlertDescription::InsufficientSecurity => Ok(&EXEC_AlertDescription_InsufficientSecurity),
-            AlertDescription::InternalError => Ok(&EXEC_AlertDescription_InternalError),
-            AlertDescription::InappropriateFallback => Ok(&EXEC_AlertDescription_InappropriateFallback),
-            AlertDescription::UserCanceled => Ok(&EXEC_AlertDescription_UserCanceled),
-            AlertDescription::MissingExtension => Ok(&EXEC_AlertDescription_MissingExtension),
-            AlertDescription::UnsupportedExtension => Ok(&EXEC_AlertDescription_UnsupportedExtension),
-            AlertDescription::UnrecognizedName => Ok(&EXEC_AlertDescription_UnrecognizedName),
-            AlertDescription::BadCertificateStatusResponse => Ok(&EXEC_AlertDescription_BadCertificateStatusResponse),
-            AlertDescription::UnknownPSKIdentity => Ok(&EXEC_AlertDescription_UnknownPSKIdentity),
-            AlertDescription::CertificateRequired => Ok(&EXEC_AlertDescription_CertificateRequired),
-            AlertDescription::NoApplicationProtocol => Ok(&EXEC_AlertDescription_NoApplicationProtocol),
-        }
+impl<'a> From<ExtensionInner<'a>> for Extension<'a> {
+    fn ex_from(m: ExtensionInner) -> Extension {
+        let (extension_type, extension_data) = m;
+        Extension { extension_type, extension_data }
+    }
+}
+
+pub struct ExtensionMapper;
+impl View for ExtensionMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ExtensionMapper {
+    type Src = SpecExtensionInner;
+    type Dst = SpecExtension;
+}
+impl SpecIsoProof for ExtensionMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ExtensionMapper {
+    type Src = ExtensionInner<'a>;
+    type Dst = Extension<'a>;
+    type RefSrc = ExtensionInnerRef<'a>;
+}
+type SpecExtensionCombinatorAlias1 = (SpecExtensionTypeCombinator, SpecOpaque0FfffCombinator);
+pub struct SpecExtensionCombinator(pub SpecExtensionCombinatorAlias);
+
+impl SpecCombinator for SpecExtensionCombinator {
+    type Type = SpecExtension;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecExtensionCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecExtensionCombinatorAlias = Mapped<SpecExtensionCombinatorAlias1, ExtensionMapper>;
+type ExtensionCombinatorAlias1 = (ExtensionTypeCombinator, Opaque0FfffCombinator);
+pub struct ExtensionCombinator1(pub ExtensionCombinatorAlias1);
+impl View for ExtensionCombinator1 {
+    type V = SpecExtensionCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ExtensionCombinator1, ExtensionCombinatorAlias1);
+
+pub struct ExtensionCombinator(pub ExtensionCombinatorAlias);
+
+impl View for ExtensionCombinator {
+    type V = SpecExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecExtensionCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExtensionCombinator {
+    type Type = Extension<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ExtensionCombinatorAlias = Mapped<ExtensionCombinator1, ExtensionMapper>;
+
+
+pub open spec fn spec_extension() -> SpecExtensionCombinator {
+    SpecExtensionCombinator(
+    Mapped {
+        inner: (spec_extension_type(), spec_opaque_0_ffff()),
+        mapper: ExtensionMapper,
+    })
+}
+
+                
+pub fn extension<'a>() -> (o: ExtensionCombinator)
+    ensures o@ == spec_extension(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ExtensionCombinator(
+    Mapped {
+        inner: ExtensionCombinator1((extension_type(), opaque_0_ffff())),
+        mapper: ExtensionMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_extension<'a>(input: &'a [u8]) -> (res: PResult<<ExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_extension().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_extension().spec_parse(input@) is None,
+        spec_extension().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = extension();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_extension<'a>(v: <ExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_extension().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_extension().spec_serialize(v@))
+        },
+{
+    let combinator = extension();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn extension_len<'a>(v: <ExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_extension().wf(v@),
+        spec_extension().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_extension().spec_serialize(v@).len(),
+{
+    let combinator = extension();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecClientCertTypeServerExtension {
+    pub client_certificate_type: u8,
+}
+
+pub type SpecClientCertTypeServerExtensionInner = u8;
+
+
+impl SpecFrom<SpecClientCertTypeServerExtension> for SpecClientCertTypeServerExtensionInner {
+    open spec fn spec_from(m: SpecClientCertTypeServerExtension) -> SpecClientCertTypeServerExtensionInner {
+        m.client_certificate_type
     }
 }
 
-pub struct AlertDescriptionMapper;
+impl SpecFrom<SpecClientCertTypeServerExtensionInner> for SpecClientCertTypeServerExtension {
+    open spec fn spec_from(m: SpecClientCertTypeServerExtensionInner) -> SpecClientCertTypeServerExtension {
+        let client_certificate_type = m;
+        SpecClientCertTypeServerExtension { client_certificate_type }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-impl View for AlertDescriptionMapper {
-    type V = Self;
+pub struct ClientCertTypeServerExtension {
+    pub client_certificate_type: u8,
+}
+
+impl View for ClientCertTypeServerExtension {
+    type V = SpecClientCertTypeServerExtension;
 
     open spec fn view(&self) -> Self::V {
-        *self
+        SpecClientCertTypeServerExtension {
+            client_certificate_type: self.client_certificate_type@,
+        }
     }
 }
+pub type ClientCertTypeServerExtensionInner = u8;
 
-impl SpecPartialIso for AlertDescriptionMapper {
-    type Src = AlertDescriptionInner;
-    type Dst = AlertDescription;
+pub type ClientCertTypeServerExtensionInnerRef<'a> = &'a u8;
+impl<'a> From<&'a ClientCertTypeServerExtension> for ClientCertTypeServerExtensionInnerRef<'a> {
+    fn ex_from(m: &'a ClientCertTypeServerExtension) -> ClientCertTypeServerExtensionInnerRef<'a> {
+        &m.client_certificate_type
+    }
 }
 
-impl SpecPartialIsoProof for AlertDescriptionMapper {
-    proof fn spec_iso(s: Self::Src) { 
-        assert(
-            Self::spec_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_rev_apply(v) is Ok
-            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
-        });
+impl From<ClientCertTypeServerExtensionInner> for ClientCertTypeServerExtension {
+    fn ex_from(m: ClientCertTypeServerExtensionInner) -> ClientCertTypeServerExtension {
+        let client_certificate_type = m;
+        ClientCertTypeServerExtension { client_certificate_type }
     }
+}
 
-    proof fn spec_iso_rev(s: Self::Dst) { 
-        assert(
-            Self::spec_rev_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_apply(v) is Ok
-            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
-        });
+pub struct ClientCertTypeServerExtensionMapper;
+impl View for ClientCertTypeServerExtensionMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
     }
 }
-
-impl<'a> PartialIso<'a> for AlertDescriptionMapper {
-    type Src = AlertDescriptionInner;
-    type Dst = AlertDescription;
-    type RefSrc = AlertDescriptionInnerRef<'a>;
+impl SpecIso for ClientCertTypeServerExtensionMapper {
+    type Src = SpecClientCertTypeServerExtensionInner;
+    type Dst = SpecClientCertTypeServerExtension;
+}
+impl SpecIsoProof for ClientCertTypeServerExtensionMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ClientCertTypeServerExtensionMapper {
+    type Src = ClientCertTypeServerExtensionInner;
+    type Dst = ClientCertTypeServerExtension;
+    type RefSrc = ClientCertTypeServerExtensionInnerRef<'a>;
 }
 
+pub struct SpecClientCertTypeServerExtensionCombinator(pub SpecClientCertTypeServerExtensionCombinatorAlias);
 
-pub struct SpecAlertDescriptionCombinator(pub SpecAlertDescriptionCombinatorAlias);
-
-impl SpecCombinator for SpecAlertDescriptionCombinator {
-    type Type = SpecAlertDescription;
+impl SpecCombinator for SpecClientCertTypeServerExtensionCombinator {
+    type Type = SpecClientCertTypeServerExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecAlertDescriptionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecAlertDescriptionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecClientCertTypeServerExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecClientCertTypeServerExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecAlertDescriptionCombinatorAlias = TryMap<U8, AlertDescriptionMapper>;
+pub type SpecClientCertTypeServerExtensionCombinatorAlias = Mapped<SpecCertificateTypeCombinator, ClientCertTypeServerExtensionMapper>;
 
-pub struct AlertDescriptionCombinator(pub AlertDescriptionCombinatorAlias);
+pub struct ClientCertTypeServerExtensionCombinator(pub ClientCertTypeServerExtensionCombinatorAlias);
 
-impl View for AlertDescriptionCombinator {
-    type V = SpecAlertDescriptionCombinator;
-    open spec fn view(&self) -> Self::V { SpecAlertDescriptionCombinator(self.0@) }
+impl View for ClientCertTypeServerExtensionCombinator {
+    type V = SpecClientCertTypeServerExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecClientCertTypeServerExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AlertDescriptionCombinator {
-    type Type = AlertDescription;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ClientCertTypeServerExtensionCombinator {
+    type Type = ClientCertTypeServerExtension;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type AlertDescriptionCombinatorAlias = TryMap<U8, AlertDescriptionMapper>;
+}
+pub type ClientCertTypeServerExtensionCombinatorAlias = Mapped<CertificateTypeCombinator, ClientCertTypeServerExtensionMapper>;
 
 
-pub open spec fn spec_alert_description() -> SpecAlertDescriptionCombinator {
-    SpecAlertDescriptionCombinator(TryMap { inner: U8, mapper: AlertDescriptionMapper })
+pub open spec fn spec_client_cert_type_server_extension() -> SpecClientCertTypeServerExtensionCombinator {
+    SpecClientCertTypeServerExtensionCombinator(
+    Mapped {
+        inner: spec_certificate_type(),
+        mapper: ClientCertTypeServerExtensionMapper,
+    })
 }
 
                 
-pub fn alert_description<'a>() -> (o: AlertDescriptionCombinator)
-    ensures o@ == spec_alert_description(),
+pub fn client_cert_type_server_extension<'a>() -> (o: ClientCertTypeServerExtensionCombinator)
+    ensures o@ == spec_client_cert_type_server_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = AlertDescriptionCombinator(TryMap { inner: U8, mapper: AlertDescriptionMapper });
-    assert({
-        &&& combinator@ == spec_alert_description()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ClientCertTypeServerExtensionCombinator(
+    Mapped {
+        inner: certificate_type(),
+        mapper: ClientCertTypeServerExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_client_cert_type_server_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_alert_description<'a>(input: &'a [u8]) -> (res: PResult<<AlertDescriptionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_client_cert_type_server_extension<'a>(input: &'a [u8]) -> (res: PResult<<ClientCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_alert_description().spec_parse(input@) == Some((n as int, v@)),
-        spec_alert_description().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_client_cert_type_server_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_client_cert_type_server_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_alert_description().spec_parse(input@) is None,
-        spec_alert_description().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_client_cert_type_server_extension().spec_parse(input@) is None,
+        spec_client_cert_type_server_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = alert_description();
+    let combinator = client_cert_type_server_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_alert_description<'a>(v: <AlertDescriptionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_client_cert_type_server_extension<'a>(v: <ClientCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_alert_description().wf(v@),
+        spec_client_cert_type_server_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_alert_description().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_alert_description().spec_serialize(v@))
+            &&& n == spec_client_cert_type_server_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_client_cert_type_server_extension().spec_serialize(v@))
         },
 {
-    let combinator = alert_description();
+    let combinator = client_cert_type_server_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn alert_description_len<'a>(v: <AlertDescriptionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn client_cert_type_server_extension_len<'a>(v: <ClientCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_alert_description().wf(v@),
-        spec_alert_description().spec_serialize(v@).len() <= usize::MAX,
+        spec_client_cert_type_server_extension().wf(v@),
+        spec_client_cert_type_server_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_alert_description().spec_serialize(v@).len(),
+        serialize_len == spec_client_cert_type_server_extension().spec_serialize(v@).len(),
 {
-    let combinator = alert_description();
+    let combinator = client_cert_type_server_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecAlert {
-    pub level: SpecAlertLevel,
-    pub description: SpecAlertDescription,
+pub spec const SPEC_ContentType_Invalid: u8 = 0;
+pub spec const SPEC_ContentType_ChangeCipherSpec: u8 = 20;
+pub spec const SPEC_ContentType_Alert: u8 = 21;
+pub spec const SPEC_ContentType_Handshake: u8 = 22;
+pub spec const SPEC_ContentType_ApplicationData: u8 = 23;
+pub exec static EXEC_ContentType_Invalid: u8 ensures EXEC_ContentType_Invalid == SPEC_ContentType_Invalid { 0 }
+pub exec static EXEC_ContentType_ChangeCipherSpec: u8 ensures EXEC_ContentType_ChangeCipherSpec == SPEC_ContentType_ChangeCipherSpec { 20 }
+pub exec static EXEC_ContentType_Alert: u8 ensures EXEC_ContentType_Alert == SPEC_ContentType_Alert { 21 }
+pub exec static EXEC_ContentType_Handshake: u8 ensures EXEC_ContentType_Handshake == SPEC_ContentType_Handshake { 22 }
+pub exec static EXEC_ContentType_ApplicationData: u8 ensures EXEC_ContentType_ApplicationData == SPEC_ContentType_ApplicationData { 23 }
+
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ContentType {
+    Invalid = 0,
+ChangeCipherSpec = 20,
+Alert = 21,
+Handshake = 22,
+ApplicationData = 23
 }
+pub type SpecContentType = ContentType;
 
-pub type SpecAlertInner = (SpecAlertLevel, SpecAlertDescription);
+pub type ContentTypeInner = u8;
 
+pub type ContentTypeInnerRef<'a> = &'a u8;
 
-impl SpecFrom<SpecAlert> for SpecAlertInner {
-    open spec fn spec_from(m: SpecAlert) -> SpecAlertInner {
-        (m.level, m.description)
-    }
-}
+impl View for ContentType {
+    type V = Self;
 
-impl SpecFrom<SpecAlertInner> for SpecAlert {
-    open spec fn spec_from(m: SpecAlertInner) -> SpecAlert {
-        let (level, description) = m;
-        SpecAlert { level, description }
+    open spec fn view(&self) -> Self::V {
+        *self
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Alert {
-    pub level: AlertLevel,
-    pub description: AlertDescription,
+impl SpecTryFrom<ContentTypeInner> for ContentType {
+    type Error = ();
+
+    open spec fn spec_try_from(v: ContentTypeInner) -> Result<ContentType, ()> {
+        match v {
+            0u8 => Ok(ContentType::Invalid),
+            20u8 => Ok(ContentType::ChangeCipherSpec),
+            21u8 => Ok(ContentType::Alert),
+            22u8 => Ok(ContentType::Handshake),
+            23u8 => Ok(ContentType::ApplicationData),
+            _ => Err(()),
+        }
+    }
 }
 
-impl View for Alert {
-    type V = SpecAlert;
+impl SpecTryFrom<ContentType> for ContentTypeInner {
+    type Error = ();
 
-    open spec fn view(&self) -> Self::V {
-        SpecAlert {
-            level: self.level@,
-            description: self.description@,
+    open spec fn spec_try_from(v: ContentType) -> Result<ContentTypeInner, ()> {
+        match v {
+            ContentType::Invalid => Ok(SPEC_ContentType_Invalid),
+            ContentType::ChangeCipherSpec => Ok(SPEC_ContentType_ChangeCipherSpec),
+            ContentType::Alert => Ok(SPEC_ContentType_Alert),
+            ContentType::Handshake => Ok(SPEC_ContentType_Handshake),
+            ContentType::ApplicationData => Ok(SPEC_ContentType_ApplicationData),
         }
     }
 }
-pub type AlertInner = (AlertLevel, AlertDescription);
 
-pub type AlertInnerRef<'a> = (&'a AlertLevel, &'a AlertDescription);
-impl<'a> From<&'a Alert> for AlertInnerRef<'a> {
-    fn ex_from(m: &'a Alert) -> AlertInnerRef<'a> {
-        (&m.level, &m.description)
+impl TryFrom<ContentTypeInner> for ContentType {
+    type Error = ();
+
+    fn ex_try_from(v: ContentTypeInner) -> Result<ContentType, ()> {
+        match v {
+            0u8 => Ok(ContentType::Invalid),
+            20u8 => Ok(ContentType::ChangeCipherSpec),
+            21u8 => Ok(ContentType::Alert),
+            22u8 => Ok(ContentType::Handshake),
+            23u8 => Ok(ContentType::ApplicationData),
+            _ => Err(()),
+        }
     }
 }
 
-impl From<AlertInner> for Alert {
-    fn ex_from(m: AlertInner) -> Alert {
-        let (level, description) = m;
-        Alert { level, description }
+impl<'a> TryFrom<&'a ContentType> for ContentTypeInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a ContentType) -> Result<ContentTypeInnerRef<'a>, ()> {
+        match v {
+            ContentType::Invalid => Ok(&EXEC_ContentType_Invalid),
+            ContentType::ChangeCipherSpec => Ok(&EXEC_ContentType_ChangeCipherSpec),
+            ContentType::Alert => Ok(&EXEC_ContentType_Alert),
+            ContentType::Handshake => Ok(&EXEC_ContentType_Handshake),
+            ContentType::ApplicationData => Ok(&EXEC_ContentType_ApplicationData),
+        }
     }
 }
 
-pub struct AlertMapper;
-impl View for AlertMapper {
+pub struct ContentTypeMapper;
+
+impl View for ContentTypeMapper {
     type V = Self;
+
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for AlertMapper {
-    type Src = SpecAlertInner;
-    type Dst = SpecAlert;
+
+impl SpecPartialIso for ContentTypeMapper {
+    type Src = ContentTypeInner;
+    type Dst = ContentType;
 }
-impl SpecIsoProof for AlertMapper {
+
+impl SpecPartialIsoProof for ContentTypeMapper {
     proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
     }
+
     proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
     }
 }
-impl<'a> Iso<'a> for AlertMapper {
-    type Src = AlertInner;
-    type Dst = Alert;
-    type RefSrc = AlertInnerRef<'a>;
+
+impl<'a> PartialIso<'a> for ContentTypeMapper {
+    type Src = ContentTypeInner;
+    type Dst = ContentType;
+    type RefSrc = ContentTypeInnerRef<'a>;
 }
-type SpecAlertCombinatorAlias1 = (SpecAlertLevelCombinator, SpecAlertDescriptionCombinator);
-pub struct SpecAlertCombinator(pub SpecAlertCombinatorAlias);
 
-impl SpecCombinator for SpecAlertCombinator {
-    type Type = SpecAlert;
+
+pub struct SpecContentTypeCombinator(pub SpecContentTypeCombinatorAlias);
+
+impl SpecCombinator for SpecContentTypeCombinator {
+    type Type = SpecContentType;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecAlertCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecAlertCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecContentTypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecContentTypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecAlertCombinatorAlias = Mapped<SpecAlertCombinatorAlias1, AlertMapper>;
-type AlertCombinatorAlias1 = (AlertLevelCombinator, AlertDescriptionCombinator);
-pub struct AlertCombinator1(pub AlertCombinatorAlias1);
-impl View for AlertCombinator1 {
-    type V = SpecAlertCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(AlertCombinator1, AlertCombinatorAlias1);
+pub type SpecContentTypeCombinatorAlias = TryMap<U8, ContentTypeMapper>;
 
-pub struct AlertCombinator(pub AlertCombinatorAlias);
+pub struct ContentTypeCombinator(pub ContentTypeCombinatorAlias);
 
-impl View for AlertCombinator {
-    type V = SpecAlertCombinator;
-    open spec fn view(&self) -> Self::V { SpecAlertCombinator(self.0@) }
+impl View for ContentTypeCombinator {
+    type V = SpecContentTypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecContentTypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AlertCombinator {
-    type Type = Alert;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ContentTypeCombinator {
+    type Type = ContentType;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type AlertCombinatorAlias = Mapped<AlertCombinator1, AlertMapper>;
+}
+pub type ContentTypeCombinatorAlias = TryMap<U8, ContentTypeMapper>;
 
 
-pub open spec fn spec_alert() -> SpecAlertCombinator {
-    SpecAlertCombinator(
-    Mapped {
-        inner: (spec_alert_level(), spec_alert_description()),
-        mapper: AlertMapper,
-    })
+pub open spec fn spec_content_type() -> SpecContentTypeCombinator {
+    SpecContentTypeCombinator(TryMap { inner: U8, mapper: ContentTypeMapper })
 }
 
                 
-pub fn alert<'a>() -> (o: AlertCombinator)
-    ensures o@ == spec_alert(),
+pub fn content_type<'a>() -> (o: ContentTypeCombinator)
+    ensures o@ == spec_content_type(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = AlertCombinator(
-    Mapped {
-        inner: AlertCombinator1((alert_level(), alert_description())),
-        mapper: AlertMapper,
-    });
-    assert({
-        &&& combinator@ == spec_alert()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ContentTypeCombinator(TryMap { inner: U8, mapper: ContentTypeMapper });
+    // assert({
+    //     &&& combinator@ == spec_content_type()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_alert<'a>(input: &'a [u8]) -> (res: PResult<<AlertCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_content_type<'a>(input: &'a [u8]) -> (res: PResult<<ContentTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_alert().spec_parse(input@) == Some((n as int, v@)),
-        spec_alert().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_content_type().spec_parse(input@) == Some((n as int, v@)),
+        spec_content_type().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_alert().spec_parse(input@) is None,
-        spec_alert().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_content_type().spec_parse(input@) is None,
+        spec_content_type().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = alert();
+    let combinator = content_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_alert<'a>(v: <AlertCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_content_type<'a>(v: <ContentTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_alert().wf(v@),
+        spec_content_type().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_alert().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_alert().spec_serialize(v@))
+            &&& n == spec_content_type().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_content_type().spec_serialize(v@))
         },
 {
-    let combinator = alert();
+    let combinator = content_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn alert_len<'a>(v: <AlertCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn content_type_len<'a>(v: <ContentTypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_alert().wf(v@),
-        spec_alert().spec_serialize(v@).len() <= usize::MAX,
+        spec_content_type().wf(v@),
+        spec_content_type().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_alert().spec_serialize(v@).len(),
+        serialize_len == spec_content_type().spec_serialize(v@).len(),
 {
-    let combinator = alert();
+    let combinator = content_type();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecPaddingExtension {
-    pub l: u16,
-    pub padding: Seq<SpecZeroByte>,
+pub struct SpecTlsPlaintext {
+    pub content_type: SpecContentType,
+    pub legacy_record_version: u16,
+    pub fragment: SpecOpaque0Ffff,
 }
 
-pub type SpecPaddingExtensionInner = (u16, Seq<SpecZeroByte>);
+pub type SpecTlsPlaintextInner = (SpecContentType, (u16, SpecOpaque0Ffff));
 
 
-impl SpecFrom<SpecPaddingExtension> for SpecPaddingExtensionInner {
-    open spec fn spec_from(m: SpecPaddingExtension) -> SpecPaddingExtensionInner {
-        (m.l, m.padding)
+impl SpecFrom<SpecTlsPlaintext> for SpecTlsPlaintextInner {
+    open spec fn spec_from(m: SpecTlsPlaintext) -> SpecTlsPlaintextInner {
+        (m.content_type, (m.legacy_record_version, m.fragment))
     }
 }
 
-impl SpecFrom<SpecPaddingExtensionInner> for SpecPaddingExtension {
-    open spec fn spec_from(m: SpecPaddingExtensionInner) -> SpecPaddingExtension {
-        let (l, padding) = m;
-        SpecPaddingExtension { l, padding }
+impl SpecFrom<SpecTlsPlaintextInner> for SpecTlsPlaintext {
+    open spec fn spec_from(m: SpecTlsPlaintextInner) -> SpecTlsPlaintext {
+        let (content_type, (legacy_record_version, fragment)) = m;
+        SpecTlsPlaintext { content_type, legacy_record_version, fragment }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct PaddingExtension {
-    pub l: u16,
-    pub padding: RepeatResult<ZeroByte>,
+pub struct TlsPlaintext<'a> {
+    pub content_type: ContentType,
+    pub legacy_record_version: u16,
+    pub fragment: Opaque0Ffff<'a>,
 }
 
-impl View for PaddingExtension {
-    type V = SpecPaddingExtension;
+impl View for TlsPlaintext<'_> {
+    type V = SpecTlsPlaintext;
 
     open spec fn view(&self) -> Self::V {
-        SpecPaddingExtension {
-            l: self.l@,
-            padding: self.padding@,
+        SpecTlsPlaintext {
+            content_type: self.content_type@,
+            legacy_record_version: self.legacy_record_version@,
+            fragment: self.fragment@,
         }
     }
 }
-pub type PaddingExtensionInner = (u16, RepeatResult<ZeroByte>);
+pub type TlsPlaintextInner<'a> = (ContentType, (u16, Opaque0Ffff<'a>));
 
-pub type PaddingExtensionInnerRef<'a> = (&'a u16, &'a RepeatResult<ZeroByte>);
-impl<'a> From<&'a PaddingExtension> for PaddingExtensionInnerRef<'a> {
-    fn ex_from(m: &'a PaddingExtension) -> PaddingExtensionInnerRef<'a> {
-        (&m.l, &m.padding)
+pub type TlsPlaintextInnerRef<'a> = (&'a ContentType, (&'a u16, &'a Opaque0Ffff<'a>));
+impl<'a> From<&'a TlsPlaintext<'a>> for TlsPlaintextInnerRef<'a> {
+    fn ex_from(m: &'a TlsPlaintext) -> TlsPlaintextInnerRef<'a> {
+        (&m.content_type, (&m.legacy_record_version, &m.fragment))
     }
 }
 
-impl From<PaddingExtensionInner> for PaddingExtension {
-    fn ex_from(m: PaddingExtensionInner) -> PaddingExtension {
-        let (l, padding) = m;
-        PaddingExtension { l, padding }
+impl<'a> From<TlsPlaintextInner<'a>> for TlsPlaintext<'a> {
+    fn ex_from(m: TlsPlaintextInner) -> TlsPlaintext {
+        let (content_type, (legacy_record_version, fragment)) = m;
+        TlsPlaintext { content_type, legacy_record_version, fragment }
     }
 }
 
-pub struct PaddingExtensionMapper;
-impl View for PaddingExtensionMapper {
+pub struct TlsPlaintextMapper;
+impl View for TlsPlaintextMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for PaddingExtensionMapper {
-    type Src = SpecPaddingExtensionInner;
-    type Dst = SpecPaddingExtension;
+impl SpecIso for TlsPlaintextMapper {
+    type Src = SpecTlsPlaintextInner;
+    type Dst = SpecTlsPlaintext;
 }
-impl SpecIsoProof for PaddingExtensionMapper {
+impl SpecIsoProof for TlsPlaintextMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -22683,554 +23002,732 @@ impl SpecIsoProof for PaddingExtensionMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for PaddingExtensionMapper {
-    type Src = PaddingExtensionInner;
-    type Dst = PaddingExtension;
-    type RefSrc = PaddingExtensionInnerRef<'a>;
+impl<'a> Iso<'a> for TlsPlaintextMapper {
+    type Src = TlsPlaintextInner<'a>;
+    type Dst = TlsPlaintext<'a>;
+    type RefSrc = TlsPlaintextInnerRef<'a>;
 }
+type SpecTlsPlaintextCombinatorAlias1 = (SpecProtocolVersionCombinator, SpecOpaque0FfffCombinator);
+type SpecTlsPlaintextCombinatorAlias2 = (SpecContentTypeCombinator, SpecTlsPlaintextCombinatorAlias1);
+pub struct SpecTlsPlaintextCombinator(pub SpecTlsPlaintextCombinatorAlias);
 
-pub struct SpecPaddingExtensionCombinator(pub SpecPaddingExtensionCombinatorAlias);
-
-impl SpecCombinator for SpecPaddingExtensionCombinator {
-    type Type = SpecPaddingExtension;
+impl SpecCombinator for SpecTlsPlaintextCombinator {
+    type Type = SpecTlsPlaintext;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecPaddingExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecPaddingExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTlsPlaintextCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTlsPlaintextCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecPaddingExtensionCombinatorAlias = Mapped<SpecPair<U16Be, AndThen<bytes::Variable, Repeat<SpecZeroByteCombinator>>>, PaddingExtensionMapper>;
+pub type SpecTlsPlaintextCombinatorAlias = Mapped<SpecTlsPlaintextCombinatorAlias2, TlsPlaintextMapper>;
+type TlsPlaintextCombinatorAlias1 = (ProtocolVersionCombinator, Opaque0FfffCombinator);
+type TlsPlaintextCombinatorAlias2 = (ContentTypeCombinator, TlsPlaintextCombinator1);
+pub struct TlsPlaintextCombinator1(pub TlsPlaintextCombinatorAlias1);
+impl View for TlsPlaintextCombinator1 {
+    type V = SpecTlsPlaintextCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TlsPlaintextCombinator1, TlsPlaintextCombinatorAlias1);
 
-pub struct PaddingExtensionCombinator(pub PaddingExtensionCombinatorAlias);
+pub struct TlsPlaintextCombinator2(pub TlsPlaintextCombinatorAlias2);
+impl View for TlsPlaintextCombinator2 {
+    type V = SpecTlsPlaintextCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TlsPlaintextCombinator2, TlsPlaintextCombinatorAlias2);
 
-impl View for PaddingExtensionCombinator {
-    type V = SpecPaddingExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecPaddingExtensionCombinator(self.0@) }
+pub struct TlsPlaintextCombinator(pub TlsPlaintextCombinatorAlias);
+
+impl View for TlsPlaintextCombinator {
+    type V = SpecTlsPlaintextCombinator;
+    open spec fn view(&self) -> Self::V { SpecTlsPlaintextCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PaddingExtensionCombinator {
-    type Type = PaddingExtension;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TlsPlaintextCombinator {
+    type Type = TlsPlaintext<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type PaddingExtensionCombinatorAlias = Mapped<Pair<U16Be, AndThen<bytes::Variable, Repeat<ZeroByteCombinator>>, PaddingExtensionCont0>, PaddingExtensionMapper>;
-
-
-pub open spec fn spec_padding_extension(ext_len: u16) -> SpecPaddingExtensionCombinator {
-    SpecPaddingExtensionCombinator(
-    Mapped {
-        inner: Pair::spec_new(U16Be, |deps| spec_padding_extension_cont0(deps)),
-        mapper: PaddingExtensionMapper,
-    })
-}
-
-pub open spec fn spec_padding_extension_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecZeroByteCombinator>> {
-    let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_zero_byte()))
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
 }
+pub type TlsPlaintextCombinatorAlias = Mapped<TlsPlaintextCombinator2, TlsPlaintextMapper>;
 
-impl View for PaddingExtensionCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecZeroByteCombinator>>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_padding_extension_cont0(deps)
-        }
-    }
+pub open spec fn spec_tls_plaintext() -> SpecTlsPlaintextCombinator {
+    SpecTlsPlaintextCombinator(
+    Mapped {
+        inner: (spec_content_type(), (spec_protocol_version(), spec_opaque_0_ffff())),
+        mapper: TlsPlaintextMapper,
+    })
 }
 
-pub fn padding_extension<'a>(ext_len: u16) -> (o: PaddingExtensionCombinator)
-    ensures o@ == spec_padding_extension(ext_len@),
+                
+pub fn tls_plaintext<'a>() -> (o: TlsPlaintextCombinator)
+    ensures o@ == spec_tls_plaintext(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = PaddingExtensionCombinator(
+    let combinator = TlsPlaintextCombinator(
     Mapped {
-        inner: Pair::new(U16Be, PaddingExtensionCont0),
-        mapper: PaddingExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_padding_extension(ext_len@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: TlsPlaintextCombinator2((content_type(), TlsPlaintextCombinator1((protocol_version(), opaque_0_ffff())))),
+        mapper: TlsPlaintextMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_tls_plaintext()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_padding_extension<'a>(input: &'a [u8], ext_len: u16) -> (res: PResult<<PaddingExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_tls_plaintext<'a>(input: &'a [u8]) -> (res: PResult<<TlsPlaintextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_padding_extension(ext_len@).spec_parse(input@) == Some((n as int, v@)),
-        spec_padding_extension(ext_len@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_tls_plaintext().spec_parse(input@) == Some((n as int, v@)),
+        spec_tls_plaintext().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_padding_extension(ext_len@).spec_parse(input@) is None,
-        spec_padding_extension(ext_len@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_tls_plaintext().spec_parse(input@) is None,
+        spec_tls_plaintext().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = padding_extension( ext_len );
+    let combinator = tls_plaintext();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_padding_extension<'a>(v: <PaddingExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, ext_len: u16) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_tls_plaintext<'a>(v: <TlsPlaintextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_padding_extension(ext_len@).wf(v@),
+        spec_tls_plaintext().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_padding_extension(ext_len@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_padding_extension(ext_len@).spec_serialize(v@))
+            &&& n == spec_tls_plaintext().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_tls_plaintext().spec_serialize(v@))
         },
 {
-    let combinator = padding_extension( ext_len );
-    combinator.serialize(v, data, pos)
+    let combinator = tls_plaintext();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn padding_extension_len<'a>(v: <PaddingExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, ext_len: u16) -> (serialize_len: usize)
+pub fn tls_plaintext_len<'a>(v: <TlsPlaintextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_padding_extension(ext_len@).wf(v@),
-        spec_padding_extension(ext_len@).spec_serialize(v@).len() <= usize::MAX,
+        spec_tls_plaintext().wf(v@),
+        spec_tls_plaintext().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_padding_extension(ext_len@).spec_serialize(v@).len(),
+        serialize_len == spec_tls_plaintext().spec_serialize(v@).len(),
 {
-    let combinator = padding_extension( ext_len );
+    let combinator = tls_plaintext();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct PaddingExtensionCont0;
-type PaddingExtensionCont0Type<'a, 'b> = &'b u16;
-type PaddingExtensionCont0SType<'a, 'x> = &'x u16;
-type PaddingExtensionCont0Input<'a, 'b, 'x> = POrSType<PaddingExtensionCont0Type<'a, 'b>, PaddingExtensionCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<PaddingExtensionCont0Input<'a, 'b, 'x>> for PaddingExtensionCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<ZeroByteCombinator>>;
-
-    open spec fn requires(&self, deps: PaddingExtensionCont0Input<'a, 'b, 'x>) -> bool { true }
+                
 
-    open spec fn ensures(&self, deps: PaddingExtensionCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_padding_extension_cont0(deps@)
-    }
+pub spec const SPEC_AlertDescription_CloseNotify: u8 = 0;
+pub spec const SPEC_AlertDescription_UnexpectedMessage: u8 = 10;
+pub spec const SPEC_AlertDescription_BadRecordMac: u8 = 20;
+pub spec const SPEC_AlertDescription_RecordOverflow: u8 = 22;
+pub spec const SPEC_AlertDescription_HandshakeFailure: u8 = 40;
+pub spec const SPEC_AlertDescription_BadCertificate: u8 = 42;
+pub spec const SPEC_AlertDescription_UnsupportedCertificate: u8 = 43;
+pub spec const SPEC_AlertDescription_CertificateRevoked: u8 = 44;
+pub spec const SPEC_AlertDescription_CertificateExpired: u8 = 45;
+pub spec const SPEC_AlertDescription_CertificateUnknown: u8 = 46;
+pub spec const SPEC_AlertDescription_IllegalParameter: u8 = 47;
+pub spec const SPEC_AlertDescription_UnknownCA: u8 = 48;
+pub spec const SPEC_AlertDescription_AccessDenied: u8 = 49;
+pub spec const SPEC_AlertDescription_DecodeError: u8 = 50;
+pub spec const SPEC_AlertDescription_DecryptError: u8 = 51;
+pub spec const SPEC_AlertDescription_ProtocolVersion: u8 = 70;
+pub spec const SPEC_AlertDescription_InsufficientSecurity: u8 = 71;
+pub spec const SPEC_AlertDescription_InternalError: u8 = 80;
+pub spec const SPEC_AlertDescription_InappropriateFallback: u8 = 86;
+pub spec const SPEC_AlertDescription_UserCanceled: u8 = 90;
+pub spec const SPEC_AlertDescription_MissingExtension: u8 = 109;
+pub spec const SPEC_AlertDescription_UnsupportedExtension: u8 = 110;
+pub spec const SPEC_AlertDescription_UnrecognizedName: u8 = 112;
+pub spec const SPEC_AlertDescription_BadCertificateStatusResponse: u8 = 113;
+pub spec const SPEC_AlertDescription_UnknownPSKIdentity: u8 = 115;
+pub spec const SPEC_AlertDescription_CertificateRequired: u8 = 116;
+pub spec const SPEC_AlertDescription_NoApplicationProtocol: u8 = 120;
+pub exec static EXEC_AlertDescription_CloseNotify: u8 ensures EXEC_AlertDescription_CloseNotify == SPEC_AlertDescription_CloseNotify { 0 }
+pub exec static EXEC_AlertDescription_UnexpectedMessage: u8 ensures EXEC_AlertDescription_UnexpectedMessage == SPEC_AlertDescription_UnexpectedMessage { 10 }
+pub exec static EXEC_AlertDescription_BadRecordMac: u8 ensures EXEC_AlertDescription_BadRecordMac == SPEC_AlertDescription_BadRecordMac { 20 }
+pub exec static EXEC_AlertDescription_RecordOverflow: u8 ensures EXEC_AlertDescription_RecordOverflow == SPEC_AlertDescription_RecordOverflow { 22 }
+pub exec static EXEC_AlertDescription_HandshakeFailure: u8 ensures EXEC_AlertDescription_HandshakeFailure == SPEC_AlertDescription_HandshakeFailure { 40 }
+pub exec static EXEC_AlertDescription_BadCertificate: u8 ensures EXEC_AlertDescription_BadCertificate == SPEC_AlertDescription_BadCertificate { 42 }
+pub exec static EXEC_AlertDescription_UnsupportedCertificate: u8 ensures EXEC_AlertDescription_UnsupportedCertificate == SPEC_AlertDescription_UnsupportedCertificate { 43 }
+pub exec static EXEC_AlertDescription_CertificateRevoked: u8 ensures EXEC_AlertDescription_CertificateRevoked == SPEC_AlertDescription_CertificateRevoked { 44 }
+pub exec static EXEC_AlertDescription_CertificateExpired: u8 ensures EXEC_AlertDescription_CertificateExpired == SPEC_AlertDescription_CertificateExpired { 45 }
+pub exec static EXEC_AlertDescription_CertificateUnknown: u8 ensures EXEC_AlertDescription_CertificateUnknown == SPEC_AlertDescription_CertificateUnknown { 46 }
+pub exec static EXEC_AlertDescription_IllegalParameter: u8 ensures EXEC_AlertDescription_IllegalParameter == SPEC_AlertDescription_IllegalParameter { 47 }
+pub exec static EXEC_AlertDescription_UnknownCA: u8 ensures EXEC_AlertDescription_UnknownCA == SPEC_AlertDescription_UnknownCA { 48 }
+pub exec static EXEC_AlertDescription_AccessDenied: u8 ensures EXEC_AlertDescription_AccessDenied == SPEC_AlertDescription_AccessDenied { 49 }
+pub exec static EXEC_AlertDescription_DecodeError: u8 ensures EXEC_AlertDescription_DecodeError == SPEC_AlertDescription_DecodeError { 50 }
+pub exec static EXEC_AlertDescription_DecryptError: u8 ensures EXEC_AlertDescription_DecryptError == SPEC_AlertDescription_DecryptError { 51 }
+pub exec static EXEC_AlertDescription_ProtocolVersion: u8 ensures EXEC_AlertDescription_ProtocolVersion == SPEC_AlertDescription_ProtocolVersion { 70 }
+pub exec static EXEC_AlertDescription_InsufficientSecurity: u8 ensures EXEC_AlertDescription_InsufficientSecurity == SPEC_AlertDescription_InsufficientSecurity { 71 }
+pub exec static EXEC_AlertDescription_InternalError: u8 ensures EXEC_AlertDescription_InternalError == SPEC_AlertDescription_InternalError { 80 }
+pub exec static EXEC_AlertDescription_InappropriateFallback: u8 ensures EXEC_AlertDescription_InappropriateFallback == SPEC_AlertDescription_InappropriateFallback { 86 }
+pub exec static EXEC_AlertDescription_UserCanceled: u8 ensures EXEC_AlertDescription_UserCanceled == SPEC_AlertDescription_UserCanceled { 90 }
+pub exec static EXEC_AlertDescription_MissingExtension: u8 ensures EXEC_AlertDescription_MissingExtension == SPEC_AlertDescription_MissingExtension { 109 }
+pub exec static EXEC_AlertDescription_UnsupportedExtension: u8 ensures EXEC_AlertDescription_UnsupportedExtension == SPEC_AlertDescription_UnsupportedExtension { 110 }
+pub exec static EXEC_AlertDescription_UnrecognizedName: u8 ensures EXEC_AlertDescription_UnrecognizedName == SPEC_AlertDescription_UnrecognizedName { 112 }
+pub exec static EXEC_AlertDescription_BadCertificateStatusResponse: u8 ensures EXEC_AlertDescription_BadCertificateStatusResponse == SPEC_AlertDescription_BadCertificateStatusResponse { 113 }
+pub exec static EXEC_AlertDescription_UnknownPSKIdentity: u8 ensures EXEC_AlertDescription_UnknownPSKIdentity == SPEC_AlertDescription_UnknownPSKIdentity { 115 }
+pub exec static EXEC_AlertDescription_CertificateRequired: u8 ensures EXEC_AlertDescription_CertificateRequired == SPEC_AlertDescription_CertificateRequired { 116 }
+pub exec static EXEC_AlertDescription_NoApplicationProtocol: u8 ensures EXEC_AlertDescription_NoApplicationProtocol == SPEC_AlertDescription_NoApplicationProtocol { 120 }
 
-    fn apply(&self, deps: PaddingExtensionCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(zero_byte()))
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(zero_byte()))
-            }
-        }
-    }
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum AlertDescription {
+    CloseNotify = 0,
+UnexpectedMessage = 10,
+BadRecordMac = 20,
+RecordOverflow = 22,
+HandshakeFailure = 40,
+BadCertificate = 42,
+UnsupportedCertificate = 43,
+CertificateRevoked = 44,
+CertificateExpired = 45,
+CertificateUnknown = 46,
+IllegalParameter = 47,
+UnknownCA = 48,
+AccessDenied = 49,
+DecodeError = 50,
+DecryptError = 51,
+ProtocolVersion = 70,
+InsufficientSecurity = 71,
+InternalError = 80,
+InappropriateFallback = 86,
+UserCanceled = 90,
+MissingExtension = 109,
+UnsupportedExtension = 110,
+UnrecognizedName = 112,
+BadCertificateStatusResponse = 113,
+UnknownPSKIdentity = 115,
+CertificateRequired = 116,
+NoApplicationProtocol = 120
 }
+pub type SpecAlertDescription = AlertDescription;
 
-pub struct SpecHeartbeatExtension {
-    pub mode: u8,
-}
+pub type AlertDescriptionInner = u8;
 
-pub type SpecHeartbeatExtensionInner = u8;
+pub type AlertDescriptionInnerRef<'a> = &'a u8;
 
+impl View for AlertDescription {
+    type V = Self;
 
-impl SpecFrom<SpecHeartbeatExtension> for SpecHeartbeatExtensionInner {
-    open spec fn spec_from(m: SpecHeartbeatExtension) -> SpecHeartbeatExtensionInner {
-        m.mode
+    open spec fn view(&self) -> Self::V {
+        *self
     }
 }
 
-impl SpecFrom<SpecHeartbeatExtensionInner> for SpecHeartbeatExtension {
-    open spec fn spec_from(m: SpecHeartbeatExtensionInner) -> SpecHeartbeatExtension {
-        let mode = m;
-        SpecHeartbeatExtension { mode }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
+impl SpecTryFrom<AlertDescriptionInner> for AlertDescription {
+    type Error = ();
 
-pub struct HeartbeatExtension {
-    pub mode: u8,
+    open spec fn spec_try_from(v: AlertDescriptionInner) -> Result<AlertDescription, ()> {
+        match v {
+            0u8 => Ok(AlertDescription::CloseNotify),
+            10u8 => Ok(AlertDescription::UnexpectedMessage),
+            20u8 => Ok(AlertDescription::BadRecordMac),
+            22u8 => Ok(AlertDescription::RecordOverflow),
+            40u8 => Ok(AlertDescription::HandshakeFailure),
+            42u8 => Ok(AlertDescription::BadCertificate),
+            43u8 => Ok(AlertDescription::UnsupportedCertificate),
+            44u8 => Ok(AlertDescription::CertificateRevoked),
+            45u8 => Ok(AlertDescription::CertificateExpired),
+            46u8 => Ok(AlertDescription::CertificateUnknown),
+            47u8 => Ok(AlertDescription::IllegalParameter),
+            48u8 => Ok(AlertDescription::UnknownCA),
+            49u8 => Ok(AlertDescription::AccessDenied),
+            50u8 => Ok(AlertDescription::DecodeError),
+            51u8 => Ok(AlertDescription::DecryptError),
+            70u8 => Ok(AlertDescription::ProtocolVersion),
+            71u8 => Ok(AlertDescription::InsufficientSecurity),
+            80u8 => Ok(AlertDescription::InternalError),
+            86u8 => Ok(AlertDescription::InappropriateFallback),
+            90u8 => Ok(AlertDescription::UserCanceled),
+            109u8 => Ok(AlertDescription::MissingExtension),
+            110u8 => Ok(AlertDescription::UnsupportedExtension),
+            112u8 => Ok(AlertDescription::UnrecognizedName),
+            113u8 => Ok(AlertDescription::BadCertificateStatusResponse),
+            115u8 => Ok(AlertDescription::UnknownPSKIdentity),
+            116u8 => Ok(AlertDescription::CertificateRequired),
+            120u8 => Ok(AlertDescription::NoApplicationProtocol),
+            _ => Err(()),
+        }
+    }
 }
 
-impl View for HeartbeatExtension {
-    type V = SpecHeartbeatExtension;
+impl SpecTryFrom<AlertDescription> for AlertDescriptionInner {
+    type Error = ();
 
-    open spec fn view(&self) -> Self::V {
-        SpecHeartbeatExtension {
-            mode: self.mode@,
+    open spec fn spec_try_from(v: AlertDescription) -> Result<AlertDescriptionInner, ()> {
+        match v {
+            AlertDescription::CloseNotify => Ok(SPEC_AlertDescription_CloseNotify),
+            AlertDescription::UnexpectedMessage => Ok(SPEC_AlertDescription_UnexpectedMessage),
+            AlertDescription::BadRecordMac => Ok(SPEC_AlertDescription_BadRecordMac),
+            AlertDescription::RecordOverflow => Ok(SPEC_AlertDescription_RecordOverflow),
+            AlertDescription::HandshakeFailure => Ok(SPEC_AlertDescription_HandshakeFailure),
+            AlertDescription::BadCertificate => Ok(SPEC_AlertDescription_BadCertificate),
+            AlertDescription::UnsupportedCertificate => Ok(SPEC_AlertDescription_UnsupportedCertificate),
+            AlertDescription::CertificateRevoked => Ok(SPEC_AlertDescription_CertificateRevoked),
+            AlertDescription::CertificateExpired => Ok(SPEC_AlertDescription_CertificateExpired),
+            AlertDescription::CertificateUnknown => Ok(SPEC_AlertDescription_CertificateUnknown),
+            AlertDescription::IllegalParameter => Ok(SPEC_AlertDescription_IllegalParameter),
+            AlertDescription::UnknownCA => Ok(SPEC_AlertDescription_UnknownCA),
+            AlertDescription::AccessDenied => Ok(SPEC_AlertDescription_AccessDenied),
+            AlertDescription::DecodeError => Ok(SPEC_AlertDescription_DecodeError),
+            AlertDescription::DecryptError => Ok(SPEC_AlertDescription_DecryptError),
+            AlertDescription::ProtocolVersion => Ok(SPEC_AlertDescription_ProtocolVersion),
+            AlertDescription::InsufficientSecurity => Ok(SPEC_AlertDescription_InsufficientSecurity),
+            AlertDescription::InternalError => Ok(SPEC_AlertDescription_InternalError),
+            AlertDescription::InappropriateFallback => Ok(SPEC_AlertDescription_InappropriateFallback),
+            AlertDescription::UserCanceled => Ok(SPEC_AlertDescription_UserCanceled),
+            AlertDescription::MissingExtension => Ok(SPEC_AlertDescription_MissingExtension),
+            AlertDescription::UnsupportedExtension => Ok(SPEC_AlertDescription_UnsupportedExtension),
+            AlertDescription::UnrecognizedName => Ok(SPEC_AlertDescription_UnrecognizedName),
+            AlertDescription::BadCertificateStatusResponse => Ok(SPEC_AlertDescription_BadCertificateStatusResponse),
+            AlertDescription::UnknownPSKIdentity => Ok(SPEC_AlertDescription_UnknownPSKIdentity),
+            AlertDescription::CertificateRequired => Ok(SPEC_AlertDescription_CertificateRequired),
+            AlertDescription::NoApplicationProtocol => Ok(SPEC_AlertDescription_NoApplicationProtocol),
         }
     }
 }
-pub type HeartbeatExtensionInner = u8;
 
-pub type HeartbeatExtensionInnerRef<'a> = &'a u8;
-impl<'a> From<&'a HeartbeatExtension> for HeartbeatExtensionInnerRef<'a> {
-    fn ex_from(m: &'a HeartbeatExtension) -> HeartbeatExtensionInnerRef<'a> {
-        &m.mode
+impl TryFrom<AlertDescriptionInner> for AlertDescription {
+    type Error = ();
+
+    fn ex_try_from(v: AlertDescriptionInner) -> Result<AlertDescription, ()> {
+        match v {
+            0u8 => Ok(AlertDescription::CloseNotify),
+            10u8 => Ok(AlertDescription::UnexpectedMessage),
+            20u8 => Ok(AlertDescription::BadRecordMac),
+            22u8 => Ok(AlertDescription::RecordOverflow),
+            40u8 => Ok(AlertDescription::HandshakeFailure),
+            42u8 => Ok(AlertDescription::BadCertificate),
+            43u8 => Ok(AlertDescription::UnsupportedCertificate),
+            44u8 => Ok(AlertDescription::CertificateRevoked),
+            45u8 => Ok(AlertDescription::CertificateExpired),
+            46u8 => Ok(AlertDescription::CertificateUnknown),
+            47u8 => Ok(AlertDescription::IllegalParameter),
+            48u8 => Ok(AlertDescription::UnknownCA),
+            49u8 => Ok(AlertDescription::AccessDenied),
+            50u8 => Ok(AlertDescription::DecodeError),
+            51u8 => Ok(AlertDescription::DecryptError),
+            70u8 => Ok(AlertDescription::ProtocolVersion),
+            71u8 => Ok(AlertDescription::InsufficientSecurity),
+            80u8 => Ok(AlertDescription::InternalError),
+            86u8 => Ok(AlertDescription::InappropriateFallback),
+            90u8 => Ok(AlertDescription::UserCanceled),
+            109u8 => Ok(AlertDescription::MissingExtension),
+            110u8 => Ok(AlertDescription::UnsupportedExtension),
+            112u8 => Ok(AlertDescription::UnrecognizedName),
+            113u8 => Ok(AlertDescription::BadCertificateStatusResponse),
+            115u8 => Ok(AlertDescription::UnknownPSKIdentity),
+            116u8 => Ok(AlertDescription::CertificateRequired),
+            120u8 => Ok(AlertDescription::NoApplicationProtocol),
+            _ => Err(()),
+        }
     }
 }
 
-impl From<HeartbeatExtensionInner> for HeartbeatExtension {
-    fn ex_from(m: HeartbeatExtensionInner) -> HeartbeatExtension {
-        let mode = m;
-        HeartbeatExtension { mode }
+impl<'a> TryFrom<&'a AlertDescription> for AlertDescriptionInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a AlertDescription) -> Result<AlertDescriptionInnerRef<'a>, ()> {
+        match v {
+            AlertDescription::CloseNotify => Ok(&EXEC_AlertDescription_CloseNotify),
+            AlertDescription::UnexpectedMessage => Ok(&EXEC_AlertDescription_UnexpectedMessage),
+            AlertDescription::BadRecordMac => Ok(&EXEC_AlertDescription_BadRecordMac),
+            AlertDescription::RecordOverflow => Ok(&EXEC_AlertDescription_RecordOverflow),
+            AlertDescription::HandshakeFailure => Ok(&EXEC_AlertDescription_HandshakeFailure),
+            AlertDescription::BadCertificate => Ok(&EXEC_AlertDescription_BadCertificate),
+            AlertDescription::UnsupportedCertificate => Ok(&EXEC_AlertDescription_UnsupportedCertificate),
+            AlertDescription::CertificateRevoked => Ok(&EXEC_AlertDescription_CertificateRevoked),
+            AlertDescription::CertificateExpired => Ok(&EXEC_AlertDescription_CertificateExpired),
+            AlertDescription::CertificateUnknown => Ok(&EXEC_AlertDescription_CertificateUnknown),
+            AlertDescription::IllegalParameter => Ok(&EXEC_AlertDescription_IllegalParameter),
+            AlertDescription::UnknownCA => Ok(&EXEC_AlertDescription_UnknownCA),
+            AlertDescription::AccessDenied => Ok(&EXEC_AlertDescription_AccessDenied),
+            AlertDescription::DecodeError => Ok(&EXEC_AlertDescription_DecodeError),
+            AlertDescription::DecryptError => Ok(&EXEC_AlertDescription_DecryptError),
+            AlertDescription::ProtocolVersion => Ok(&EXEC_AlertDescription_ProtocolVersion),
+            AlertDescription::InsufficientSecurity => Ok(&EXEC_AlertDescription_InsufficientSecurity),
+            AlertDescription::InternalError => Ok(&EXEC_AlertDescription_InternalError),
+            AlertDescription::InappropriateFallback => Ok(&EXEC_AlertDescription_InappropriateFallback),
+            AlertDescription::UserCanceled => Ok(&EXEC_AlertDescription_UserCanceled),
+            AlertDescription::MissingExtension => Ok(&EXEC_AlertDescription_MissingExtension),
+            AlertDescription::UnsupportedExtension => Ok(&EXEC_AlertDescription_UnsupportedExtension),
+            AlertDescription::UnrecognizedName => Ok(&EXEC_AlertDescription_UnrecognizedName),
+            AlertDescription::BadCertificateStatusResponse => Ok(&EXEC_AlertDescription_BadCertificateStatusResponse),
+            AlertDescription::UnknownPSKIdentity => Ok(&EXEC_AlertDescription_UnknownPSKIdentity),
+            AlertDescription::CertificateRequired => Ok(&EXEC_AlertDescription_CertificateRequired),
+            AlertDescription::NoApplicationProtocol => Ok(&EXEC_AlertDescription_NoApplicationProtocol),
+        }
     }
 }
 
-pub struct HeartbeatExtensionMapper;
-impl View for HeartbeatExtensionMapper {
+pub struct AlertDescriptionMapper;
+
+impl View for AlertDescriptionMapper {
     type V = Self;
+
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for HeartbeatExtensionMapper {
-    type Src = SpecHeartbeatExtensionInner;
-    type Dst = SpecHeartbeatExtension;
+
+impl SpecPartialIso for AlertDescriptionMapper {
+    type Src = AlertDescriptionInner;
+    type Dst = AlertDescription;
 }
-impl SpecIsoProof for HeartbeatExtensionMapper {
+
+impl SpecPartialIsoProof for AlertDescriptionMapper {
     proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
     }
+
     proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
     }
 }
-impl<'a> Iso<'a> for HeartbeatExtensionMapper {
-    type Src = HeartbeatExtensionInner;
-    type Dst = HeartbeatExtension;
-    type RefSrc = HeartbeatExtensionInnerRef<'a>;
+
+impl<'a> PartialIso<'a> for AlertDescriptionMapper {
+    type Src = AlertDescriptionInner;
+    type Dst = AlertDescription;
+    type RefSrc = AlertDescriptionInnerRef<'a>;
 }
 
-pub struct SpecHeartbeatExtensionCombinator(pub SpecHeartbeatExtensionCombinatorAlias);
 
-impl SpecCombinator for SpecHeartbeatExtensionCombinator {
-    type Type = SpecHeartbeatExtension;
+pub struct SpecAlertDescriptionCombinator(pub SpecAlertDescriptionCombinatorAlias);
+
+impl SpecCombinator for SpecAlertDescriptionCombinator {
+    type Type = SpecAlertDescription;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecHeartbeatExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecHeartbeatExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecAlertDescriptionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecAlertDescriptionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecHeartbeatExtensionCombinatorAlias = Mapped<SpecHeartbeatModeCombinator, HeartbeatExtensionMapper>;
+pub type SpecAlertDescriptionCombinatorAlias = TryMap<U8, AlertDescriptionMapper>;
 
-pub struct HeartbeatExtensionCombinator(pub HeartbeatExtensionCombinatorAlias);
+pub struct AlertDescriptionCombinator(pub AlertDescriptionCombinatorAlias);
 
-impl View for HeartbeatExtensionCombinator {
-    type V = SpecHeartbeatExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecHeartbeatExtensionCombinator(self.0@) }
+impl View for AlertDescriptionCombinator {
+    type V = SpecAlertDescriptionCombinator;
+    open spec fn view(&self) -> Self::V { SpecAlertDescriptionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeartbeatExtensionCombinator {
-    type Type = HeartbeatExtension;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AlertDescriptionCombinator {
+    type Type = AlertDescription;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type HeartbeatExtensionCombinatorAlias = Mapped<HeartbeatModeCombinator, HeartbeatExtensionMapper>;
+}
+pub type AlertDescriptionCombinatorAlias = TryMap<U8, AlertDescriptionMapper>;
 
 
-pub open spec fn spec_heartbeat_extension() -> SpecHeartbeatExtensionCombinator {
-    SpecHeartbeatExtensionCombinator(
-    Mapped {
-        inner: spec_heartbeat_mode(),
-        mapper: HeartbeatExtensionMapper,
-    })
+pub open spec fn spec_alert_description() -> SpecAlertDescriptionCombinator {
+    SpecAlertDescriptionCombinator(TryMap { inner: U8, mapper: AlertDescriptionMapper })
 }
 
                 
-pub fn heartbeat_extension<'a>() -> (o: HeartbeatExtensionCombinator)
-    ensures o@ == spec_heartbeat_extension(),
+pub fn alert_description<'a>() -> (o: AlertDescriptionCombinator)
+    ensures o@ == spec_alert_description(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = HeartbeatExtensionCombinator(
-    Mapped {
-        inner: heartbeat_mode(),
-        mapper: HeartbeatExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_heartbeat_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = AlertDescriptionCombinator(TryMap { inner: U8, mapper: AlertDescriptionMapper });
+    // assert({
+    //     &&& combinator@ == spec_alert_description()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_heartbeat_extension<'a>(input: &'a [u8]) -> (res: PResult<<HeartbeatExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_alert_description<'a>(input: &'a [u8]) -> (res: PResult<<AlertDescriptionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_heartbeat_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_heartbeat_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_alert_description().spec_parse(input@) == Some((n as int, v@)),
+        spec_alert_description().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_heartbeat_extension().spec_parse(input@) is None,
-        spec_heartbeat_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_alert_description().spec_parse(input@) is None,
+        spec_alert_description().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = heartbeat_extension();
+    let combinator = alert_description();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_heartbeat_extension<'a>(v: <HeartbeatExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_alert_description<'a>(v: <AlertDescriptionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_heartbeat_extension().wf(v@),
+        spec_alert_description().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_heartbeat_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_heartbeat_extension().spec_serialize(v@))
+            &&& n == spec_alert_description().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_alert_description().spec_serialize(v@))
         },
 {
-    let combinator = heartbeat_extension();
+    let combinator = alert_description();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn heartbeat_extension_len<'a>(v: <HeartbeatExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn alert_description_len<'a>(v: <AlertDescriptionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_heartbeat_extension().wf(v@),
-        spec_heartbeat_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_alert_description().wf(v@),
+        spec_alert_description().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_heartbeat_extension().spec_serialize(v@).len(),
+        serialize_len == spec_alert_description().spec_serialize(v@).len(),
 {
-    let combinator = heartbeat_extension();
+    let combinator = alert_description();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub type SpecUnknownExtension = SpecOpaque0Ffff;
-pub type UnknownExtension<'a> = Opaque0Ffff<'a>;
-pub type UnknownExtensionRef<'a> = &'a Opaque0Ffff<'a>;
+pub type SpecSrtpProtectionProfile = Seq<u8>;
+pub type SrtpProtectionProfile<'a> = &'a [u8];
+pub type SrtpProtectionProfileRef<'a> = &'a &'a [u8];
 
 
-pub struct SpecUnknownExtensionCombinator(pub SpecUnknownExtensionCombinatorAlias);
+pub struct SpecSrtpProtectionProfileCombinator(pub SpecSrtpProtectionProfileCombinatorAlias);
 
-impl SpecCombinator for SpecUnknownExtensionCombinator {
-    type Type = SpecUnknownExtension;
+impl SpecCombinator for SpecSrtpProtectionProfileCombinator {
+    type Type = SpecSrtpProtectionProfile;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecUnknownExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecUnknownExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSrtpProtectionProfileCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSrtpProtectionProfileCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecUnknownExtensionCombinatorAlias = SpecOpaque0FfffCombinator;
+pub type SpecSrtpProtectionProfileCombinatorAlias = bytes::Fixed<2>;
 
-pub struct UnknownExtensionCombinator(pub UnknownExtensionCombinatorAlias);
+pub struct SrtpProtectionProfileCombinator(pub SrtpProtectionProfileCombinatorAlias);
 
-impl View for UnknownExtensionCombinator {
-    type V = SpecUnknownExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecUnknownExtensionCombinator(self.0@) }
+impl View for SrtpProtectionProfileCombinator {
+    type V = SpecSrtpProtectionProfileCombinator;
+    open spec fn view(&self) -> Self::V { SpecSrtpProtectionProfileCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for UnknownExtensionCombinator {
-    type Type = UnknownExtension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SrtpProtectionProfileCombinator {
+    type Type = SrtpProtectionProfile<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type UnknownExtensionCombinatorAlias = Opaque0FfffCombinator;
+}
+pub type SrtpProtectionProfileCombinatorAlias = bytes::Fixed<2>;
 
 
-pub open spec fn spec_unknown_extension() -> SpecUnknownExtensionCombinator {
-    SpecUnknownExtensionCombinator(spec_opaque_0_ffff())
+pub open spec fn spec_srtp_protection_profile() -> SpecSrtpProtectionProfileCombinator {
+    SpecSrtpProtectionProfileCombinator(bytes::Fixed::<2>)
 }
 
                 
-pub fn unknown_extension<'a>() -> (o: UnknownExtensionCombinator)
-    ensures o@ == spec_unknown_extension(),
+pub fn srtp_protection_profile<'a>() -> (o: SrtpProtectionProfileCombinator)
+    ensures o@ == spec_srtp_protection_profile(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = UnknownExtensionCombinator(opaque_0_ffff());
-    assert({
-        &&& combinator@ == spec_unknown_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = SrtpProtectionProfileCombinator(bytes::Fixed::<2>);
+    // assert({
+    //     &&& combinator@ == spec_srtp_protection_profile()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_unknown_extension<'a>(input: &'a [u8]) -> (res: PResult<<UnknownExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_srtp_protection_profile<'a>(input: &'a [u8]) -> (res: PResult<<SrtpProtectionProfileCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_unknown_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_unknown_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_srtp_protection_profile().spec_parse(input@) == Some((n as int, v@)),
+        spec_srtp_protection_profile().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_unknown_extension().spec_parse(input@) is None,
-        spec_unknown_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_srtp_protection_profile().spec_parse(input@) is None,
+        spec_srtp_protection_profile().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = unknown_extension();
+    let combinator = srtp_protection_profile();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_unknown_extension<'a>(v: <UnknownExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_srtp_protection_profile<'a>(v: <SrtpProtectionProfileCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_unknown_extension().wf(v@),
+        spec_srtp_protection_profile().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_unknown_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_unknown_extension().spec_serialize(v@))
+            &&& n == spec_srtp_protection_profile().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_srtp_protection_profile().spec_serialize(v@))
         },
 {
-    let combinator = unknown_extension();
+    let combinator = srtp_protection_profile();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn unknown_extension_len<'a>(v: <UnknownExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn srtp_protection_profile_len<'a>(v: <SrtpProtectionProfileCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_unknown_extension().wf(v@),
-        spec_unknown_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_srtp_protection_profile().wf(v@),
+        spec_srtp_protection_profile().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_unknown_extension().spec_serialize(v@).len(),
+        serialize_len == spec_srtp_protection_profile().spec_serialize(v@).len(),
 {
-    let combinator = unknown_extension();
+    let combinator = srtp_protection_profile();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecCertificateEntry {
-    pub data: SpecCertificateEntryData,
-    pub extensions: SpecCertificateExtensions,
+pub struct SpecSrtpProtectionProfiles {
+    pub l: u16,
+    pub list: Seq<SpecSrtpProtectionProfile>,
 }
 
-pub type SpecCertificateEntryInner = (SpecCertificateEntryData, SpecCertificateExtensions);
+pub type SpecSrtpProtectionProfilesInner = (u16, Seq<SpecSrtpProtectionProfile>);
 
 
-impl SpecFrom<SpecCertificateEntry> for SpecCertificateEntryInner {
-    open spec fn spec_from(m: SpecCertificateEntry) -> SpecCertificateEntryInner {
-        (m.data, m.extensions)
+impl SpecFrom<SpecSrtpProtectionProfiles> for SpecSrtpProtectionProfilesInner {
+    open spec fn spec_from(m: SpecSrtpProtectionProfiles) -> SpecSrtpProtectionProfilesInner {
+        (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecCertificateEntryInner> for SpecCertificateEntry {
-    open spec fn spec_from(m: SpecCertificateEntryInner) -> SpecCertificateEntry {
-        let (data, extensions) = m;
-        SpecCertificateEntry { data, extensions }
+impl SpecFrom<SpecSrtpProtectionProfilesInner> for SpecSrtpProtectionProfiles {
+    open spec fn spec_from(m: SpecSrtpProtectionProfilesInner) -> SpecSrtpProtectionProfiles {
+        let (l, list) = m;
+        SpecSrtpProtectionProfiles { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CertificateEntry<'a> {
-    pub data: CertificateEntryData<'a>,
-    pub extensions: CertificateExtensions<'a>,
+pub struct SrtpProtectionProfiles<'a> {
+    pub l: u16,
+    pub list: RepeatResult<SrtpProtectionProfile<'a>>,
 }
 
-impl View for CertificateEntry<'_> {
-    type V = SpecCertificateEntry;
+impl View for SrtpProtectionProfiles<'_> {
+    type V = SpecSrtpProtectionProfiles;
 
     open spec fn view(&self) -> Self::V {
-        SpecCertificateEntry {
-            data: self.data@,
-            extensions: self.extensions@,
+        SpecSrtpProtectionProfiles {
+            l: self.l@,
+            list: self.list@,
         }
     }
 }
-pub type CertificateEntryInner<'a> = (CertificateEntryData<'a>, CertificateExtensions<'a>);
+pub type SrtpProtectionProfilesInner<'a> = (u16, RepeatResult<SrtpProtectionProfile<'a>>);
 
-pub type CertificateEntryInnerRef<'a> = (&'a CertificateEntryData<'a>, &'a CertificateExtensions<'a>);
-impl<'a> From<&'a CertificateEntry<'a>> for CertificateEntryInnerRef<'a> {
-    fn ex_from(m: &'a CertificateEntry) -> CertificateEntryInnerRef<'a> {
-        (&m.data, &m.extensions)
+pub type SrtpProtectionProfilesInnerRef<'a> = (&'a u16, &'a RepeatResult<SrtpProtectionProfile<'a>>);
+impl<'a> From<&'a SrtpProtectionProfiles<'a>> for SrtpProtectionProfilesInnerRef<'a> {
+    fn ex_from(m: &'a SrtpProtectionProfiles) -> SrtpProtectionProfilesInnerRef<'a> {
+        (&m.l, &m.list)
     }
 }
 
-impl<'a> From<CertificateEntryInner<'a>> for CertificateEntry<'a> {
-    fn ex_from(m: CertificateEntryInner) -> CertificateEntry {
-        let (data, extensions) = m;
-        CertificateEntry { data, extensions }
+impl<'a> From<SrtpProtectionProfilesInner<'a>> for SrtpProtectionProfiles<'a> {
+    fn ex_from(m: SrtpProtectionProfilesInner) -> SrtpProtectionProfiles {
+        let (l, list) = m;
+        SrtpProtectionProfiles { l, list }
     }
 }
 
-pub struct CertificateEntryMapper;
-impl View for CertificateEntryMapper {
+pub struct SrtpProtectionProfilesMapper;
+impl View for SrtpProtectionProfilesMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateEntryMapper {
-    type Src = SpecCertificateEntryInner;
-    type Dst = SpecCertificateEntry;
+impl SpecIso for SrtpProtectionProfilesMapper {
+    type Src = SpecSrtpProtectionProfilesInner;
+    type Dst = SpecSrtpProtectionProfiles;
 }
-impl SpecIsoProof for CertificateEntryMapper {
+impl SpecIsoProof for SrtpProtectionProfilesMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -23238,529 +23735,572 @@ impl SpecIsoProof for CertificateEntryMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateEntryMapper {
-    type Src = CertificateEntryInner<'a>;
-    type Dst = CertificateEntry<'a>;
-    type RefSrc = CertificateEntryInnerRef<'a>;
+impl<'a> Iso<'a> for SrtpProtectionProfilesMapper {
+    type Src = SrtpProtectionProfilesInner<'a>;
+    type Dst = SrtpProtectionProfiles<'a>;
+    type RefSrc = SrtpProtectionProfilesInnerRef<'a>;
 }
-type SpecCertificateEntryCombinatorAlias1 = (SpecCertificateEntryDataCombinator, SpecCertificateExtensionsCombinator);
-pub struct SpecCertificateEntryCombinator(pub SpecCertificateEntryCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateEntryCombinator {
-    type Type = SpecCertificateEntry;
+pub struct SpecSrtpProtectionProfilesCombinator(pub SpecSrtpProtectionProfilesCombinatorAlias);
+
+impl SpecCombinator for SpecSrtpProtectionProfilesCombinator {
+    type Type = SpecSrtpProtectionProfiles;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateEntryCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateEntryCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSrtpProtectionProfilesCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSrtpProtectionProfilesCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateEntryCombinatorAlias = Mapped<SpecCertificateEntryCombinatorAlias1, CertificateEntryMapper>;
-type CertificateEntryCombinatorAlias1 = (CertificateEntryDataCombinator, CertificateExtensionsCombinator);
-pub struct CertificateEntryCombinator1(pub CertificateEntryCombinatorAlias1);
-impl View for CertificateEntryCombinator1 {
-    type V = SpecCertificateEntryCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CertificateEntryCombinator1, CertificateEntryCombinatorAlias1);
+pub type SpecSrtpProtectionProfilesCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<SpecSrtpProtectionProfileCombinator>>>, SrtpProtectionProfilesMapper>;
 
-pub struct CertificateEntryCombinator(pub CertificateEntryCombinatorAlias);
+pub struct SrtpProtectionProfilesCombinator(pub SrtpProtectionProfilesCombinatorAlias);
 
-impl View for CertificateEntryCombinator {
-    type V = SpecCertificateEntryCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateEntryCombinator(self.0@) }
+impl View for SrtpProtectionProfilesCombinator {
+    type V = SpecSrtpProtectionProfilesCombinator;
+    open spec fn view(&self) -> Self::V { SpecSrtpProtectionProfilesCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateEntryCombinator {
-    type Type = CertificateEntry<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SrtpProtectionProfilesCombinator {
+    type Type = SrtpProtectionProfiles<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateEntryCombinatorAlias = Mapped<CertificateEntryCombinator1, CertificateEntryMapper>;
+}
+pub type SrtpProtectionProfilesCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<SrtpProtectionProfileCombinator>>, SrtpProtectionProfilesCont0>, SrtpProtectionProfilesMapper>;
 
 
-pub open spec fn spec_certificate_entry(cert_type: u8) -> SpecCertificateEntryCombinator {
-    SpecCertificateEntryCombinator(
+pub open spec fn spec_srtp_protection_profiles() -> SpecSrtpProtectionProfilesCombinator {
+    SpecSrtpProtectionProfilesCombinator(
     Mapped {
-        inner: (spec_certificate_entry_data(cert_type), spec_certificate_extensions()),
-        mapper: CertificateEntryMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, |deps| spec_srtp_protection_profiles_cont0(deps)),
+        mapper: SrtpProtectionProfilesMapper,
     })
 }
 
-pub fn certificate_entry<'a>(cert_type: u8) -> (o: CertificateEntryCombinator)
-    ensures o@ == spec_certificate_entry(cert_type@),
+pub open spec fn spec_srtp_protection_profiles_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecSrtpProtectionProfileCombinator>> {
+    let l = deps;
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_srtp_protection_profile()))
+}
+
+impl View for SrtpProtectionProfilesCont0 {
+    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecSrtpProtectionProfileCombinator>>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u16| {
+            spec_srtp_protection_profiles_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn srtp_protection_profiles<'a>() -> (o: SrtpProtectionProfilesCombinator)
+    ensures o@ == spec_srtp_protection_profiles(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateEntryCombinator(
+    let combinator = SrtpProtectionProfilesCombinator(
     Mapped {
-        inner: CertificateEntryCombinator1((certificate_entry_data(cert_type), certificate_extensions())),
-        mapper: CertificateEntryMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_entry(cert_type@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, SrtpProtectionProfilesCont0),
+        mapper: SrtpProtectionProfilesMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_srtp_protection_profiles()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_entry<'a>(input: &'a [u8], cert_type: u8) -> (res: PResult<<CertificateEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_srtp_protection_profiles<'a>(input: &'a [u8]) -> (res: PResult<<SrtpProtectionProfilesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_entry(cert_type@).spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_entry(cert_type@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_srtp_protection_profiles().spec_parse(input@) == Some((n as int, v@)),
+        spec_srtp_protection_profiles().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_entry(cert_type@).spec_parse(input@) is None,
-        spec_certificate_entry(cert_type@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_srtp_protection_profiles().spec_parse(input@) is None,
+        spec_srtp_protection_profiles().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_entry( cert_type );
+    let combinator = srtp_protection_profiles();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_entry<'a>(v: <CertificateEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, cert_type: u8) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_srtp_protection_profiles<'a>(v: <SrtpProtectionProfilesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_entry(cert_type@).wf(v@),
+        spec_srtp_protection_profiles().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_entry(cert_type@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_entry(cert_type@).spec_serialize(v@))
+            &&& n == spec_srtp_protection_profiles().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_srtp_protection_profiles().spec_serialize(v@))
         },
 {
-    let combinator = certificate_entry( cert_type );
-    combinator.serialize(v, data, pos)
+    let combinator = srtp_protection_profiles();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn srtp_protection_profiles_len<'a>(v: <SrtpProtectionProfilesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_srtp_protection_profiles().wf(v@),
+        spec_srtp_protection_profiles().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_srtp_protection_profiles().spec_serialize(v@).len(),
+{
+    let combinator = srtp_protection_profiles();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct SrtpProtectionProfilesCont0;
+type SrtpProtectionProfilesCont0Type<'a, 'b> = &'b u16;
+type SrtpProtectionProfilesCont0SType<'a, 'x> = &'x u16;
+type SrtpProtectionProfilesCont0Input<'a, 'b, 'x> = POrSType<SrtpProtectionProfilesCont0Type<'a, 'b>, SrtpProtectionProfilesCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<SrtpProtectionProfilesCont0Input<'a, 'b, 'x>> for SrtpProtectionProfilesCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<SrtpProtectionProfileCombinator>>;
+
+    open spec fn requires(&self, deps: SrtpProtectionProfilesCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate8195707947578446211 }).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: SrtpProtectionProfilesCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_srtp_protection_profiles_cont0(deps@)
+    }
+
+    fn apply(&self, deps: SrtpProtectionProfilesCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(srtp_protection_profile()))
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(srtp_protection_profile()))
+            }
+        }
+    }
+}
+                
+
+pub struct SpecUseSrtpData {
+    pub profiles: SpecSrtpProtectionProfiles,
+    pub srtp_mki: SpecOpaque0Ff,
+}
+
+pub type SpecUseSrtpDataInner = (SpecSrtpProtectionProfiles, SpecOpaque0Ff);
+
+
+impl SpecFrom<SpecUseSrtpData> for SpecUseSrtpDataInner {
+    open spec fn spec_from(m: SpecUseSrtpData) -> SpecUseSrtpDataInner {
+        (m.profiles, m.srtp_mki)
+    }
+}
+
+impl SpecFrom<SpecUseSrtpDataInner> for SpecUseSrtpData {
+    open spec fn spec_from(m: SpecUseSrtpDataInner) -> SpecUseSrtpData {
+        let (profiles, srtp_mki) = m;
+        SpecUseSrtpData { profiles, srtp_mki }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct UseSrtpData<'a> {
+    pub profiles: SrtpProtectionProfiles<'a>,
+    pub srtp_mki: Opaque0Ff<'a>,
+}
+
+impl View for UseSrtpData<'_> {
+    type V = SpecUseSrtpData;
+
+    open spec fn view(&self) -> Self::V {
+        SpecUseSrtpData {
+            profiles: self.profiles@,
+            srtp_mki: self.srtp_mki@,
+        }
+    }
 }
+pub type UseSrtpDataInner<'a> = (SrtpProtectionProfiles<'a>, Opaque0Ff<'a>);
 
-pub fn certificate_entry_len<'a>(v: <CertificateEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, cert_type: u8) -> (serialize_len: usize)
-    requires
-        spec_certificate_entry(cert_type@).wf(v@),
-        spec_certificate_entry(cert_type@).spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_certificate_entry(cert_type@).spec_serialize(v@).len(),
-{
-    let combinator = certificate_entry( cert_type );
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+pub type UseSrtpDataInnerRef<'a> = (&'a SrtpProtectionProfiles<'a>, &'a Opaque0Ff<'a>);
+impl<'a> From<&'a UseSrtpData<'a>> for UseSrtpDataInnerRef<'a> {
+    fn ex_from(m: &'a UseSrtpData) -> UseSrtpDataInnerRef<'a> {
+        (&m.profiles, &m.srtp_mki)
+    }
 }
 
-pub type SpecSrtpProtectionProfile = Seq<u8>;
-pub type SrtpProtectionProfile<'a> = &'a [u8];
-pub type SrtpProtectionProfileRef<'a> = &'a &'a [u8];
-
+impl<'a> From<UseSrtpDataInner<'a>> for UseSrtpData<'a> {
+    fn ex_from(m: UseSrtpDataInner) -> UseSrtpData {
+        let (profiles, srtp_mki) = m;
+        UseSrtpData { profiles, srtp_mki }
+    }
+}
 
-pub struct SpecSrtpProtectionProfileCombinator(pub SpecSrtpProtectionProfileCombinatorAlias);
+pub struct UseSrtpDataMapper;
+impl View for UseSrtpDataMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for UseSrtpDataMapper {
+    type Src = SpecUseSrtpDataInner;
+    type Dst = SpecUseSrtpData;
+}
+impl SpecIsoProof for UseSrtpDataMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for UseSrtpDataMapper {
+    type Src = UseSrtpDataInner<'a>;
+    type Dst = UseSrtpData<'a>;
+    type RefSrc = UseSrtpDataInnerRef<'a>;
+}
+type SpecUseSrtpDataCombinatorAlias1 = (SpecSrtpProtectionProfilesCombinator, SpecOpaque0FfCombinator);
+pub struct SpecUseSrtpDataCombinator(pub SpecUseSrtpDataCombinatorAlias);
 
-impl SpecCombinator for SpecSrtpProtectionProfileCombinator {
-    type Type = SpecSrtpProtectionProfile;
+impl SpecCombinator for SpecUseSrtpDataCombinator {
+    type Type = SpecUseSrtpData;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecSrtpProtectionProfileCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSrtpProtectionProfileCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecUseSrtpDataCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecUseSrtpDataCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecSrtpProtectionProfileCombinatorAlias = bytes::Fixed<2>;
+pub type SpecUseSrtpDataCombinatorAlias = Mapped<SpecUseSrtpDataCombinatorAlias1, UseSrtpDataMapper>;
+type UseSrtpDataCombinatorAlias1 = (SrtpProtectionProfilesCombinator, Opaque0FfCombinator);
+pub struct UseSrtpDataCombinator1(pub UseSrtpDataCombinatorAlias1);
+impl View for UseSrtpDataCombinator1 {
+    type V = SpecUseSrtpDataCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(UseSrtpDataCombinator1, UseSrtpDataCombinatorAlias1);
 
-pub struct SrtpProtectionProfileCombinator(pub SrtpProtectionProfileCombinatorAlias);
+pub struct UseSrtpDataCombinator(pub UseSrtpDataCombinatorAlias);
 
-impl View for SrtpProtectionProfileCombinator {
-    type V = SpecSrtpProtectionProfileCombinator;
-    open spec fn view(&self) -> Self::V { SpecSrtpProtectionProfileCombinator(self.0@) }
+impl View for UseSrtpDataCombinator {
+    type V = SpecUseSrtpDataCombinator;
+    open spec fn view(&self) -> Self::V { SpecUseSrtpDataCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SrtpProtectionProfileCombinator {
-    type Type = SrtpProtectionProfile<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for UseSrtpDataCombinator {
+    type Type = UseSrtpData<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SrtpProtectionProfileCombinatorAlias = bytes::Fixed<2>;
+}
+pub type UseSrtpDataCombinatorAlias = Mapped<UseSrtpDataCombinator1, UseSrtpDataMapper>;
 
 
-pub open spec fn spec_srtp_protection_profile() -> SpecSrtpProtectionProfileCombinator {
-    SpecSrtpProtectionProfileCombinator(bytes::Fixed::<2>)
+pub open spec fn spec_use_srtp_data() -> SpecUseSrtpDataCombinator {
+    SpecUseSrtpDataCombinator(
+    Mapped {
+        inner: (spec_srtp_protection_profiles(), spec_opaque_0_ff()),
+        mapper: UseSrtpDataMapper,
+    })
 }
 
                 
-pub fn srtp_protection_profile<'a>() -> (o: SrtpProtectionProfileCombinator)
-    ensures o@ == spec_srtp_protection_profile(),
+pub fn use_srtp_data<'a>() -> (o: UseSrtpDataCombinator)
+    ensures o@ == spec_use_srtp_data(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = SrtpProtectionProfileCombinator(bytes::Fixed::<2>);
-    assert({
-        &&& combinator@ == spec_srtp_protection_profile()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = UseSrtpDataCombinator(
+    Mapped {
+        inner: UseSrtpDataCombinator1((srtp_protection_profiles(), opaque_0_ff())),
+        mapper: UseSrtpDataMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_use_srtp_data()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_srtp_protection_profile<'a>(input: &'a [u8]) -> (res: PResult<<SrtpProtectionProfileCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_use_srtp_data<'a>(input: &'a [u8]) -> (res: PResult<<UseSrtpDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_srtp_protection_profile().spec_parse(input@) == Some((n as int, v@)),
-        spec_srtp_protection_profile().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_use_srtp_data().spec_parse(input@) == Some((n as int, v@)),
+        spec_use_srtp_data().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_srtp_protection_profile().spec_parse(input@) is None,
-        spec_srtp_protection_profile().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_use_srtp_data().spec_parse(input@) is None,
+        spec_use_srtp_data().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = srtp_protection_profile();
+    let combinator = use_srtp_data();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_srtp_protection_profile<'a>(v: <SrtpProtectionProfileCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_use_srtp_data<'a>(v: <UseSrtpDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_srtp_protection_profile().wf(v@),
+        spec_use_srtp_data().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_srtp_protection_profile().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_srtp_protection_profile().spec_serialize(v@))
+            &&& n == spec_use_srtp_data().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_use_srtp_data().spec_serialize(v@))
         },
 {
-    let combinator = srtp_protection_profile();
+    let combinator = use_srtp_data();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn srtp_protection_profile_len<'a>(v: <SrtpProtectionProfileCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn use_srtp_data_len<'a>(v: <UseSrtpDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_srtp_protection_profile().wf(v@),
-        spec_srtp_protection_profile().spec_serialize(v@).len() <= usize::MAX,
+        spec_use_srtp_data().wf(v@),
+        spec_use_srtp_data().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_srtp_protection_profile().spec_serialize(v@).len(),
+        serialize_len == spec_use_srtp_data().spec_serialize(v@).len(),
 {
-    let combinator = srtp_protection_profile();
+    let combinator = use_srtp_data();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
+pub type SpecFinishedOpaque = Seq<u8>;
+pub type FinishedOpaque<'a> = &'a [u8];
+pub type FinishedOpaqueRef<'a> = &'a &'a [u8];
 
-pub struct SpecExtension {
-    pub extension_type: u16,
-    pub extension_data: SpecOpaque0Ffff,
-}
-
-pub type SpecExtensionInner = (u16, SpecOpaque0Ffff);
-
-
-impl SpecFrom<SpecExtension> for SpecExtensionInner {
-    open spec fn spec_from(m: SpecExtension) -> SpecExtensionInner {
-        (m.extension_type, m.extension_data)
-    }
-}
-
-impl SpecFrom<SpecExtensionInner> for SpecExtension {
-    open spec fn spec_from(m: SpecExtensionInner) -> SpecExtension {
-        let (extension_type, extension_data) = m;
-        SpecExtension { extension_type, extension_data }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct Extension<'a> {
-    pub extension_type: u16,
-    pub extension_data: Opaque0Ffff<'a>,
-}
-
-impl View for Extension<'_> {
-    type V = SpecExtension;
-
-    open spec fn view(&self) -> Self::V {
-        SpecExtension {
-            extension_type: self.extension_type@,
-            extension_data: self.extension_data@,
-        }
-    }
-}
-pub type ExtensionInner<'a> = (u16, Opaque0Ffff<'a>);
-
-pub type ExtensionInnerRef<'a> = (&'a u16, &'a Opaque0Ffff<'a>);
-impl<'a> From<&'a Extension<'a>> for ExtensionInnerRef<'a> {
-    fn ex_from(m: &'a Extension) -> ExtensionInnerRef<'a> {
-        (&m.extension_type, &m.extension_data)
-    }
-}
-
-impl<'a> From<ExtensionInner<'a>> for Extension<'a> {
-    fn ex_from(m: ExtensionInner) -> Extension {
-        let (extension_type, extension_data) = m;
-        Extension { extension_type, extension_data }
-    }
-}
 
-pub struct ExtensionMapper;
-impl View for ExtensionMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ExtensionMapper {
-    type Src = SpecExtensionInner;
-    type Dst = SpecExtension;
-}
-impl SpecIsoProof for ExtensionMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for ExtensionMapper {
-    type Src = ExtensionInner<'a>;
-    type Dst = Extension<'a>;
-    type RefSrc = ExtensionInnerRef<'a>;
-}
-type SpecExtensionCombinatorAlias1 = (SpecExtensionTypeCombinator, SpecOpaque0FfffCombinator);
-pub struct SpecExtensionCombinator(pub SpecExtensionCombinatorAlias);
+pub struct SpecFinishedOpaqueCombinator(pub SpecFinishedOpaqueCombinatorAlias);
 
-impl SpecCombinator for SpecExtensionCombinator {
-    type Type = SpecExtension;
+impl SpecCombinator for SpecFinishedOpaqueCombinator {
+    type Type = SpecFinishedOpaque;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecFinishedOpaqueCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecFinishedOpaqueCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecExtensionCombinatorAlias = Mapped<SpecExtensionCombinatorAlias1, ExtensionMapper>;
-type ExtensionCombinatorAlias1 = (ExtensionTypeCombinator, Opaque0FfffCombinator);
-pub struct ExtensionCombinator1(pub ExtensionCombinatorAlias1);
-impl View for ExtensionCombinator1 {
-    type V = SpecExtensionCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ExtensionCombinator1, ExtensionCombinatorAlias1);
+pub type SpecFinishedOpaqueCombinatorAlias = bytes::Variable;
 
-pub struct ExtensionCombinator(pub ExtensionCombinatorAlias);
+pub struct FinishedOpaqueCombinator(pub FinishedOpaqueCombinatorAlias);
 
-impl View for ExtensionCombinator {
-    type V = SpecExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecExtensionCombinator(self.0@) }
+impl View for FinishedOpaqueCombinator {
+    type V = SpecFinishedOpaqueCombinator;
+    open spec fn view(&self) -> Self::V { SpecFinishedOpaqueCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExtensionCombinator {
-    type Type = Extension<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FinishedOpaqueCombinator {
+    type Type = FinishedOpaque<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ExtensionCombinatorAlias = Mapped<ExtensionCombinator1, ExtensionMapper>;
+}
+pub type FinishedOpaqueCombinatorAlias = bytes::Variable;
 
 
-pub open spec fn spec_extension() -> SpecExtensionCombinator {
-    SpecExtensionCombinator(
-    Mapped {
-        inner: (spec_extension_type(), spec_opaque_0_ffff()),
-        mapper: ExtensionMapper,
-    })
+pub open spec fn spec_finished_opaque(digest_size: u24) -> SpecFinishedOpaqueCombinator {
+    SpecFinishedOpaqueCombinator(bytes::Variable((usize::spec_from(digest_size)) as usize))
 }
 
-                
-pub fn extension<'a>() -> (o: ExtensionCombinator)
-    ensures o@ == spec_extension(),
+pub fn finished_opaque<'a>(digest_size: u24) -> (o: FinishedOpaqueCombinator)
+
+    ensures o@ == spec_finished_opaque(digest_size@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ExtensionCombinator(
-    Mapped {
-        inner: ExtensionCombinator1((extension_type(), opaque_0_ffff())),
-        mapper: ExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = FinishedOpaqueCombinator(bytes::Variable((usize::ex_from(digest_size)) as usize));
+    // assert({
+    //     &&& combinator@ == spec_finished_opaque(digest_size@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_extension<'a>(input: &'a [u8]) -> (res: PResult<<ExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_finished_opaque<'a>(input: &'a [u8], digest_size: u24) -> (res: PResult<<FinishedOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
-        res matches Ok((n, v)) ==> spec_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_finished_opaque(digest_size@).spec_parse(input@) == Some((n as int, v@)),
+        spec_finished_opaque(digest_size@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_extension().spec_parse(input@) is None,
-        spec_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_finished_opaque(digest_size@).spec_parse(input@) is None,
+        spec_finished_opaque(digest_size@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = extension();
+    let combinator = finished_opaque( digest_size );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_extension<'a>(v: <ExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_finished_opaque<'a>(v: <FinishedOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, digest_size: u24) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_extension().wf(v@),
+        spec_finished_opaque(digest_size@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_extension().spec_serialize(v@))
+            &&& n == spec_finished_opaque(digest_size@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_finished_opaque(digest_size@).spec_serialize(v@))
         },
 {
-    let combinator = extension();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = finished_opaque( digest_size );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn extension_len<'a>(v: <ExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn finished_opaque_len<'a>(v: <FinishedOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, digest_size: u24) -> (serialize_len: usize)
     requires
-        spec_extension().wf(v@),
-        spec_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_finished_opaque(digest_size@).wf(v@),
+        spec_finished_opaque(digest_size@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
-        serialize_len == spec_extension().spec_serialize(v@).len(),
+        serialize_len == spec_finished_opaque(digest_size@).spec_serialize(v@).len(),
 {
-    let combinator = extension();
+    let combinator = finished_opaque( digest_size );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
 
-pub struct SpecCertificateList {
-    pub l: u24,
-    pub list: Seq<SpecCertificateEntryOpaque>,
+pub struct SpecOpaque2Ffff {
+    pub l: u16,
+    pub data: Seq<u8>,
 }
 
-pub type SpecCertificateListInner = (u24, Seq<SpecCertificateEntryOpaque>);
+pub type SpecOpaque2FfffInner = (u16, Seq<u8>);
 
 
-impl SpecFrom<SpecCertificateList> for SpecCertificateListInner {
-    open spec fn spec_from(m: SpecCertificateList) -> SpecCertificateListInner {
-        (m.l, m.list)
+impl SpecFrom<SpecOpaque2Ffff> for SpecOpaque2FfffInner {
+    open spec fn spec_from(m: SpecOpaque2Ffff) -> SpecOpaque2FfffInner {
+        (m.l, m.data)
     }
 }
 
-impl SpecFrom<SpecCertificateListInner> for SpecCertificateList {
-    open spec fn spec_from(m: SpecCertificateListInner) -> SpecCertificateList {
-        let (l, list) = m;
-        SpecCertificateList { l, list }
+impl SpecFrom<SpecOpaque2FfffInner> for SpecOpaque2Ffff {
+    open spec fn spec_from(m: SpecOpaque2FfffInner) -> SpecOpaque2Ffff {
+        let (l, data) = m;
+        SpecOpaque2Ffff { l, data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CertificateList<'a> {
-    pub l: u24,
-    pub list: RepeatResult<CertificateEntryOpaque<'a>>,
+pub struct Opaque2Ffff<'a> {
+    pub l: u16,
+    pub data: &'a [u8],
 }
 
-impl View for CertificateList<'_> {
-    type V = SpecCertificateList;
+impl View for Opaque2Ffff<'_> {
+    type V = SpecOpaque2Ffff;
 
     open spec fn view(&self) -> Self::V {
-        SpecCertificateList {
+        SpecOpaque2Ffff {
             l: self.l@,
-            list: self.list@,
+            data: self.data@,
         }
     }
 }
-pub type CertificateListInner<'a> = (u24, RepeatResult<CertificateEntryOpaque<'a>>);
+pub type Opaque2FfffInner<'a> = (u16, &'a [u8]);
 
-pub type CertificateListInnerRef<'a> = (&'a u24, &'a RepeatResult<CertificateEntryOpaque<'a>>);
-impl<'a> From<&'a CertificateList<'a>> for CertificateListInnerRef<'a> {
-    fn ex_from(m: &'a CertificateList) -> CertificateListInnerRef<'a> {
-        (&m.l, &m.list)
+pub type Opaque2FfffInnerRef<'a> = (&'a u16, &'a &'a [u8]);
+impl<'a> From<&'a Opaque2Ffff<'a>> for Opaque2FfffInnerRef<'a> {
+    fn ex_from(m: &'a Opaque2Ffff) -> Opaque2FfffInnerRef<'a> {
+        (&m.l, &m.data)
     }
 }
 
-impl<'a> From<CertificateListInner<'a>> for CertificateList<'a> {
-    fn ex_from(m: CertificateListInner) -> CertificateList {
-        let (l, list) = m;
-        CertificateList { l, list }
+impl<'a> From<Opaque2FfffInner<'a>> for Opaque2Ffff<'a> {
+    fn ex_from(m: Opaque2FfffInner) -> Opaque2Ffff {
+        let (l, data) = m;
+        Opaque2Ffff { l, data }
     }
 }
 
-pub struct CertificateListMapper;
-impl View for CertificateListMapper {
+pub struct Opaque2FfffMapper;
+impl View for Opaque2FfffMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateListMapper {
-    type Src = SpecCertificateListInner;
-    type Dst = SpecCertificateList;
+impl SpecIso for Opaque2FfffMapper {
+    type Src = SpecOpaque2FfffInner;
+    type Dst = SpecOpaque2Ffff;
 }
-impl SpecIsoProof for CertificateListMapper {
+impl SpecIsoProof for Opaque2FfffMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -23768,241 +24308,265 @@ impl SpecIsoProof for CertificateListMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateListMapper {
-    type Src = CertificateListInner<'a>;
-    type Dst = CertificateList<'a>;
-    type RefSrc = CertificateListInnerRef<'a>;
+impl<'a> Iso<'a> for Opaque2FfffMapper {
+    type Src = Opaque2FfffInner<'a>;
+    type Dst = Opaque2Ffff<'a>;
+    type RefSrc = Opaque2FfffInnerRef<'a>;
 }
 
-pub struct SpecCertificateListCombinator(pub SpecCertificateListCombinatorAlias);
+pub struct SpecOpaque2FfffCombinator(pub SpecOpaque2FfffCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateListCombinator {
-    type Type = SpecCertificateList;
+impl SpecCombinator for SpecOpaque2FfffCombinator {
+    type Type = SpecOpaque2Ffff;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateListCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateListCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOpaque2FfffCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOpaque2FfffCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateListCombinatorAlias = Mapped<SpecPair<U24Be, AndThen<bytes::Variable, Repeat<SpecCertificateEntryOpaqueCombinator>>>, CertificateListMapper>;
+pub type SpecOpaque2FfffCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate3016150102856496288>, bytes::Variable>, Opaque2FfffMapper>;
+pub struct Predicate3016150102856496288;
+impl View for Predicate3016150102856496288 {
+    type V = Self;
 
-pub struct CertificateListCombinator(pub CertificateListCombinatorAlias);
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u16> for Predicate3016150102856496288 {
+    fn apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 2 && i <= 65535)
+    }
+}
+impl SpecPred<u16> for Predicate3016150102856496288 {
+    open spec fn spec_apply(&self, i: &u16) -> bool {
+        let i = (*i);
+        (i >= 2 && i <= 65535)
+    }
+}
 
-impl View for CertificateListCombinator {
-    type V = SpecCertificateListCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateListCombinator(self.0@) }
+pub struct Opaque2FfffCombinator(pub Opaque2FfffCombinatorAlias);
+
+impl View for Opaque2FfffCombinator {
+    type V = SpecOpaque2FfffCombinator;
+    open spec fn view(&self) -> Self::V { SpecOpaque2FfffCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateListCombinator {
-    type Type = CertificateList<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque2FfffCombinator {
+    type Type = Opaque2Ffff<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateListCombinatorAlias = Mapped<Pair<U24Be, AndThen<bytes::Variable, Repeat<CertificateEntryOpaqueCombinator>>, CertificateListCont0>, CertificateListMapper>;
+}
+pub type Opaque2FfffCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate3016150102856496288>, bytes::Variable, Opaque2FfffCont0>, Opaque2FfffMapper>;
 
 
-pub open spec fn spec_certificate_list() -> SpecCertificateListCombinator {
-    SpecCertificateListCombinator(
+pub open spec fn spec_opaque_2_ffff() -> SpecOpaque2FfffCombinator {
+    SpecOpaque2FfffCombinator(
     Mapped {
-        inner: Pair::spec_new(U24Be, |deps| spec_certificate_list_cont0(deps)),
-        mapper: CertificateListMapper,
+        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate3016150102856496288 }, |deps| spec_opaque2_ffff_cont0(deps)),
+        mapper: Opaque2FfffMapper,
     })
 }
 
-pub open spec fn spec_certificate_list_cont0(deps: u24) -> AndThen<bytes::Variable, Repeat<SpecCertificateEntryOpaqueCombinator>> {
+pub open spec fn spec_opaque2_ffff_cont0(deps: u16) -> bytes::Variable {
     let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_certificate_entry_opaque()))
+    bytes::Variable((usize::spec_from(l)) as usize)
 }
 
-impl View for CertificateListCont0 {
-    type V = spec_fn(u24) -> AndThen<bytes::Variable, Repeat<SpecCertificateEntryOpaqueCombinator>>;
+impl View for Opaque2FfffCont0 {
+    type V = spec_fn(u16) -> bytes::Variable;
 
     open spec fn view(&self) -> Self::V {
-        |deps: u24| {
-            spec_certificate_list_cont0(deps)
+        |deps: u16| {
+            spec_opaque2_ffff_cont0(deps)
         }
     }
 }
 
                 
-pub fn certificate_list<'a>() -> (o: CertificateListCombinator)
-    ensures o@ == spec_certificate_list(),
+pub fn opaque_2_ffff<'a>() -> (o: Opaque2FfffCombinator)
+    ensures o@ == spec_opaque_2_ffff(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateListCombinator(
+    let combinator = Opaque2FfffCombinator(
     Mapped {
-        inner: Pair::new(U24Be, CertificateListCont0),
-        mapper: CertificateListMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_list()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate3016150102856496288 }, Opaque2FfffCont0),
+        mapper: Opaque2FfffMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_opaque_2_ffff()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_list<'a>(input: &'a [u8]) -> (res: PResult<<CertificateListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_opaque_2_ffff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque2FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_list().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_list().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_opaque_2_ffff().spec_parse(input@) == Some((n as int, v@)),
+        spec_opaque_2_ffff().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_list().spec_parse(input@) is None,
-        spec_certificate_list().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_opaque_2_ffff().spec_parse(input@) is None,
+        spec_opaque_2_ffff().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_list();
+    let combinator = opaque_2_ffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_list<'a>(v: <CertificateListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_opaque_2_ffff<'a>(v: <Opaque2FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_list().wf(v@),
+        spec_opaque_2_ffff().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_list().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_list().spec_serialize(v@))
+            &&& n == spec_opaque_2_ffff().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_2_ffff().spec_serialize(v@))
         },
 {
-    let combinator = certificate_list();
+    let combinator = opaque_2_ffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_list_len<'a>(v: <CertificateListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn opaque_2_ffff_len<'a>(v: <Opaque2FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_list().wf(v@),
-        spec_certificate_list().spec_serialize(v@).len() <= usize::MAX,
+        spec_opaque_2_ffff().wf(v@),
+        spec_opaque_2_ffff().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_list().spec_serialize(v@).len(),
+        serialize_len == spec_opaque_2_ffff().spec_serialize(v@).len(),
 {
-    let combinator = certificate_list();
+    let combinator = opaque_2_ffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct CertificateListCont0;
-type CertificateListCont0Type<'a, 'b> = &'b u24;
-type CertificateListCont0SType<'a, 'x> = &'x u24;
-type CertificateListCont0Input<'a, 'b, 'x> = POrSType<CertificateListCont0Type<'a, 'b>, CertificateListCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CertificateListCont0Input<'a, 'b, 'x>> for CertificateListCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<CertificateEntryOpaqueCombinator>>;
+pub struct Opaque2FfffCont0;
+type Opaque2FfffCont0Type<'a, 'b> = &'b u16;
+type Opaque2FfffCont0SType<'a, 'x> = &'x u16;
+type Opaque2FfffCont0Input<'a, 'b, 'x> = POrSType<Opaque2FfffCont0Type<'a, 'b>, Opaque2FfffCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Opaque2FfffCont0Input<'a, 'b, 'x>> for Opaque2FfffCont0 {
+    type Output = bytes::Variable;
 
-    open spec fn requires(&self, deps: CertificateListCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: Opaque2FfffCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U16Be, predicate: Predicate3016150102856496288 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: CertificateListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_certificate_list_cont0(deps@)
+    open spec fn ensures(&self, deps: Opaque2FfffCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_opaque2_ffff_cont0(deps@)
     }
 
-    fn apply(&self, deps: CertificateListCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: Opaque2FfffCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(certificate_entry_opaque()))
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(certificate_entry_opaque()))
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
 
-pub struct SpecCertificate {
-    pub certificate_request_context: SpecOpaque0Ff,
-    pub certificate_list: SpecCertificateList,
+pub struct SpecAlert {
+    pub level: SpecAlertLevel,
+    pub description: SpecAlertDescription,
 }
 
-pub type SpecCertificateInner = (SpecOpaque0Ff, SpecCertificateList);
+pub type SpecAlertInner = (SpecAlertLevel, SpecAlertDescription);
 
 
-impl SpecFrom<SpecCertificate> for SpecCertificateInner {
-    open spec fn spec_from(m: SpecCertificate) -> SpecCertificateInner {
-        (m.certificate_request_context, m.certificate_list)
+impl SpecFrom<SpecAlert> for SpecAlertInner {
+    open spec fn spec_from(m: SpecAlert) -> SpecAlertInner {
+        (m.level, m.description)
     }
 }
 
-impl SpecFrom<SpecCertificateInner> for SpecCertificate {
-    open spec fn spec_from(m: SpecCertificateInner) -> SpecCertificate {
-        let (certificate_request_context, certificate_list) = m;
-        SpecCertificate { certificate_request_context, certificate_list }
+impl SpecFrom<SpecAlertInner> for SpecAlert {
+    open spec fn spec_from(m: SpecAlertInner) -> SpecAlert {
+        let (level, description) = m;
+        SpecAlert { level, description }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Certificate<'a> {
-    pub certificate_request_context: Opaque0Ff<'a>,
-    pub certificate_list: CertificateList<'a>,
+pub struct Alert {
+    pub level: AlertLevel,
+    pub description: AlertDescription,
 }
 
-impl View for Certificate<'_> {
-    type V = SpecCertificate;
+impl View for Alert {
+    type V = SpecAlert;
 
     open spec fn view(&self) -> Self::V {
-        SpecCertificate {
-            certificate_request_context: self.certificate_request_context@,
-            certificate_list: self.certificate_list@,
+        SpecAlert {
+            level: self.level@,
+            description: self.description@,
         }
     }
 }
-pub type CertificateInner<'a> = (Opaque0Ff<'a>, CertificateList<'a>);
+pub type AlertInner = (AlertLevel, AlertDescription);
 
-pub type CertificateInnerRef<'a> = (&'a Opaque0Ff<'a>, &'a CertificateList<'a>);
-impl<'a> From<&'a Certificate<'a>> for CertificateInnerRef<'a> {
-    fn ex_from(m: &'a Certificate) -> CertificateInnerRef<'a> {
-        (&m.certificate_request_context, &m.certificate_list)
+pub type AlertInnerRef<'a> = (&'a AlertLevel, &'a AlertDescription);
+impl<'a> From<&'a Alert> for AlertInnerRef<'a> {
+    fn ex_from(m: &'a Alert) -> AlertInnerRef<'a> {
+        (&m.level, &m.description)
     }
 }
 
-impl<'a> From<CertificateInner<'a>> for Certificate<'a> {
-    fn ex_from(m: CertificateInner) -> Certificate {
-        let (certificate_request_context, certificate_list) = m;
-        Certificate { certificate_request_context, certificate_list }
+impl From<AlertInner> for Alert {
+    fn ex_from(m: AlertInner) -> Alert {
+        let (level, description) = m;
+        Alert { level, description }
     }
 }
 
-pub struct CertificateMapper;
-impl View for CertificateMapper {
+pub struct AlertMapper;
+impl View for AlertMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateMapper {
-    type Src = SpecCertificateInner;
-    type Dst = SpecCertificate;
+impl SpecIso for AlertMapper {
+    type Src = SpecAlertInner;
+    type Dst = SpecAlert;
 }
-impl SpecIsoProof for CertificateMapper {
+impl SpecIsoProof for AlertMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -24010,206 +24574,203 @@ impl SpecIsoProof for CertificateMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateMapper {
-    type Src = CertificateInner<'a>;
-    type Dst = Certificate<'a>;
-    type RefSrc = CertificateInnerRef<'a>;
+impl<'a> Iso<'a> for AlertMapper {
+    type Src = AlertInner;
+    type Dst = Alert;
+    type RefSrc = AlertInnerRef<'a>;
 }
-type SpecCertificateCombinatorAlias1 = (SpecOpaque0FfCombinator, SpecCertificateListCombinator);
-pub struct SpecCertificateCombinator(pub SpecCertificateCombinatorAlias);
+type SpecAlertCombinatorAlias1 = (SpecAlertLevelCombinator, SpecAlertDescriptionCombinator);
+pub struct SpecAlertCombinator(pub SpecAlertCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateCombinator {
-    type Type = SpecCertificate;
+impl SpecCombinator for SpecAlertCombinator {
+    type Type = SpecAlert;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecAlertCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecAlertCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCertificateCombinatorAlias = Mapped<SpecCertificateCombinatorAlias1, CertificateMapper>;
-type CertificateCombinatorAlias1 = (Opaque0FfCombinator, CertificateListCombinator);
-pub struct CertificateCombinator1(pub CertificateCombinatorAlias1);
-impl View for CertificateCombinator1 {
-    type V = SpecCertificateCombinatorAlias1;
+pub type SpecAlertCombinatorAlias = Mapped<SpecAlertCombinatorAlias1, AlertMapper>;
+type AlertCombinatorAlias1 = (AlertLevelCombinator, AlertDescriptionCombinator);
+pub struct AlertCombinator1(pub AlertCombinatorAlias1);
+impl View for AlertCombinator1 {
+    type V = SpecAlertCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(CertificateCombinator1, CertificateCombinatorAlias1);
+impl_wrapper_combinator!(AlertCombinator1, AlertCombinatorAlias1);
 
-pub struct CertificateCombinator(pub CertificateCombinatorAlias);
+pub struct AlertCombinator(pub AlertCombinatorAlias);
 
-impl View for CertificateCombinator {
-    type V = SpecCertificateCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateCombinator(self.0@) }
+impl View for AlertCombinator {
+    type V = SpecAlertCombinator;
+    open spec fn view(&self) -> Self::V { SpecAlertCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateCombinator {
-    type Type = Certificate<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for AlertCombinator {
+    type Type = Alert;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateCombinatorAlias = Mapped<CertificateCombinator1, CertificateMapper>;
+}
+pub type AlertCombinatorAlias = Mapped<AlertCombinator1, AlertMapper>;
 
 
-pub open spec fn spec_certificate() -> SpecCertificateCombinator {
-    SpecCertificateCombinator(
+pub open spec fn spec_alert() -> SpecAlertCombinator {
+    SpecAlertCombinator(
     Mapped {
-        inner: (spec_opaque_0_ff(), spec_certificate_list()),
-        mapper: CertificateMapper,
+        inner: (spec_alert_level(), spec_alert_description()),
+        mapper: AlertMapper,
     })
 }
 
                 
-pub fn certificate<'a>() -> (o: CertificateCombinator)
-    ensures o@ == spec_certificate(),
+pub fn alert<'a>() -> (o: AlertCombinator)
+    ensures o@ == spec_alert(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateCombinator(
+    let combinator = AlertCombinator(
     Mapped {
-        inner: CertificateCombinator1((opaque_0_ff(), certificate_list())),
-        mapper: CertificateMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: AlertCombinator1((alert_level(), alert_description())),
+        mapper: AlertMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_alert()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate<'a>(input: &'a [u8]) -> (res: PResult<<CertificateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_alert<'a>(input: &'a [u8]) -> (res: PResult<<AlertCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_alert().spec_parse(input@) == Some((n as int, v@)),
+        spec_alert().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate().spec_parse(input@) is None,
-        spec_certificate().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_alert().spec_parse(input@) is None,
+        spec_alert().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate();
+    let combinator = alert();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate<'a>(v: <CertificateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_alert<'a>(v: <AlertCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate().wf(v@),
+        spec_alert().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate().spec_serialize(v@))
+            &&& n == spec_alert().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_alert().spec_serialize(v@))
         },
 {
-    let combinator = certificate();
+    let combinator = alert();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_len<'a>(v: <CertificateCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn alert_len<'a>(v: <AlertCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate().wf(v@),
-        spec_certificate().spec_serialize(v@).len() <= usize::MAX,
+        spec_alert().wf(v@),
+        spec_alert().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate().spec_serialize(v@).len(),
+        serialize_len == spec_alert().spec_serialize(v@).len(),
 {
-    let combinator = certificate();
+    let combinator = alert();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecCertificateVerify {
-    pub algorithm: u16,
-    pub signature: SpecOpaque0Ffff,
+pub struct SpecServerCertTypeServerExtension {
+    pub server_certificate_type: u8,
 }
 
-pub type SpecCertificateVerifyInner = (u16, SpecOpaque0Ffff);
+pub type SpecServerCertTypeServerExtensionInner = u8;
 
 
-impl SpecFrom<SpecCertificateVerify> for SpecCertificateVerifyInner {
-    open spec fn spec_from(m: SpecCertificateVerify) -> SpecCertificateVerifyInner {
-        (m.algorithm, m.signature)
+impl SpecFrom<SpecServerCertTypeServerExtension> for SpecServerCertTypeServerExtensionInner {
+    open spec fn spec_from(m: SpecServerCertTypeServerExtension) -> SpecServerCertTypeServerExtensionInner {
+        m.server_certificate_type
     }
 }
 
-impl SpecFrom<SpecCertificateVerifyInner> for SpecCertificateVerify {
-    open spec fn spec_from(m: SpecCertificateVerifyInner) -> SpecCertificateVerify {
-        let (algorithm, signature) = m;
-        SpecCertificateVerify { algorithm, signature }
+impl SpecFrom<SpecServerCertTypeServerExtensionInner> for SpecServerCertTypeServerExtension {
+    open spec fn spec_from(m: SpecServerCertTypeServerExtensionInner) -> SpecServerCertTypeServerExtension {
+        let server_certificate_type = m;
+        SpecServerCertTypeServerExtension { server_certificate_type }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CertificateVerify<'a> {
-    pub algorithm: u16,
-    pub signature: Opaque0Ffff<'a>,
+pub struct ServerCertTypeServerExtension {
+    pub server_certificate_type: u8,
 }
 
-impl View for CertificateVerify<'_> {
-    type V = SpecCertificateVerify;
+impl View for ServerCertTypeServerExtension {
+    type V = SpecServerCertTypeServerExtension;
 
     open spec fn view(&self) -> Self::V {
-        SpecCertificateVerify {
-            algorithm: self.algorithm@,
-            signature: self.signature@,
+        SpecServerCertTypeServerExtension {
+            server_certificate_type: self.server_certificate_type@,
         }
     }
 }
-pub type CertificateVerifyInner<'a> = (u16, Opaque0Ffff<'a>);
+pub type ServerCertTypeServerExtensionInner = u8;
 
-pub type CertificateVerifyInnerRef<'a> = (&'a u16, &'a Opaque0Ffff<'a>);
-impl<'a> From<&'a CertificateVerify<'a>> for CertificateVerifyInnerRef<'a> {
-    fn ex_from(m: &'a CertificateVerify) -> CertificateVerifyInnerRef<'a> {
-        (&m.algorithm, &m.signature)
+pub type ServerCertTypeServerExtensionInnerRef<'a> = &'a u8;
+impl<'a> From<&'a ServerCertTypeServerExtension> for ServerCertTypeServerExtensionInnerRef<'a> {
+    fn ex_from(m: &'a ServerCertTypeServerExtension) -> ServerCertTypeServerExtensionInnerRef<'a> {
+        &m.server_certificate_type
     }
 }
 
-impl<'a> From<CertificateVerifyInner<'a>> for CertificateVerify<'a> {
-    fn ex_from(m: CertificateVerifyInner) -> CertificateVerify {
-        let (algorithm, signature) = m;
-        CertificateVerify { algorithm, signature }
+impl From<ServerCertTypeServerExtensionInner> for ServerCertTypeServerExtension {
+    fn ex_from(m: ServerCertTypeServerExtensionInner) -> ServerCertTypeServerExtension {
+        let server_certificate_type = m;
+        ServerCertTypeServerExtension { server_certificate_type }
     }
 }
 
-pub struct CertificateVerifyMapper;
-impl View for CertificateVerifyMapper {
+pub struct ServerCertTypeServerExtensionMapper;
+impl View for ServerCertTypeServerExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CertificateVerifyMapper {
-    type Src = SpecCertificateVerifyInner;
-    type Dst = SpecCertificateVerify;
+impl SpecIso for ServerCertTypeServerExtensionMapper {
+    type Src = SpecServerCertTypeServerExtensionInner;
+    type Dst = SpecServerCertTypeServerExtension;
 }
-impl SpecIsoProof for CertificateVerifyMapper {
+impl SpecIsoProof for ServerCertTypeServerExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -24217,555 +24778,444 @@ impl SpecIsoProof for CertificateVerifyMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CertificateVerifyMapper {
-    type Src = CertificateVerifyInner<'a>;
-    type Dst = CertificateVerify<'a>;
-    type RefSrc = CertificateVerifyInnerRef<'a>;
+impl<'a> Iso<'a> for ServerCertTypeServerExtensionMapper {
+    type Src = ServerCertTypeServerExtensionInner;
+    type Dst = ServerCertTypeServerExtension;
+    type RefSrc = ServerCertTypeServerExtensionInnerRef<'a>;
 }
-type SpecCertificateVerifyCombinatorAlias1 = (SpecSignatureSchemeCombinator, SpecOpaque0FfffCombinator);
-pub struct SpecCertificateVerifyCombinator(pub SpecCertificateVerifyCombinatorAlias);
 
-impl SpecCombinator for SpecCertificateVerifyCombinator {
-    type Type = SpecCertificateVerify;
+pub struct SpecServerCertTypeServerExtensionCombinator(pub SpecServerCertTypeServerExtensionCombinatorAlias);
+
+impl SpecCombinator for SpecServerCertTypeServerExtensionCombinator {
+    type Type = SpecServerCertTypeServerExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCertificateVerifyCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCertificateVerifyCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecServerCertTypeServerExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecServerCertTypeServerExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
-}
-pub type SpecCertificateVerifyCombinatorAlias = Mapped<SpecCertificateVerifyCombinatorAlias1, CertificateVerifyMapper>;
-type CertificateVerifyCombinatorAlias1 = (SignatureSchemeCombinator, Opaque0FfffCombinator);
-pub struct CertificateVerifyCombinator1(pub CertificateVerifyCombinatorAlias1);
-impl View for CertificateVerifyCombinator1 {
-    type V = SpecCertificateVerifyCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
 }
-impl_wrapper_combinator!(CertificateVerifyCombinator1, CertificateVerifyCombinatorAlias1);
+pub type SpecServerCertTypeServerExtensionCombinatorAlias = Mapped<SpecCertificateTypeCombinator, ServerCertTypeServerExtensionMapper>;
 
-pub struct CertificateVerifyCombinator(pub CertificateVerifyCombinatorAlias);
+pub struct ServerCertTypeServerExtensionCombinator(pub ServerCertTypeServerExtensionCombinatorAlias);
 
-impl View for CertificateVerifyCombinator {
-    type V = SpecCertificateVerifyCombinator;
-    open spec fn view(&self) -> Self::V { SpecCertificateVerifyCombinator(self.0@) }
+impl View for ServerCertTypeServerExtensionCombinator {
+    type V = SpecServerCertTypeServerExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecServerCertTypeServerExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateVerifyCombinator {
-    type Type = CertificateVerify<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerCertTypeServerExtensionCombinator {
+    type Type = ServerCertTypeServerExtension;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CertificateVerifyCombinatorAlias = Mapped<CertificateVerifyCombinator1, CertificateVerifyMapper>;
+}
+pub type ServerCertTypeServerExtensionCombinatorAlias = Mapped<CertificateTypeCombinator, ServerCertTypeServerExtensionMapper>;
 
 
-pub open spec fn spec_certificate_verify() -> SpecCertificateVerifyCombinator {
-    SpecCertificateVerifyCombinator(
+pub open spec fn spec_server_cert_type_server_extension() -> SpecServerCertTypeServerExtensionCombinator {
+    SpecServerCertTypeServerExtensionCombinator(
     Mapped {
-        inner: (spec_signature_scheme(), spec_opaque_0_ffff()),
-        mapper: CertificateVerifyMapper,
+        inner: spec_certificate_type(),
+        mapper: ServerCertTypeServerExtensionMapper,
     })
 }
 
                 
-pub fn certificate_verify<'a>() -> (o: CertificateVerifyCombinator)
-    ensures o@ == spec_certificate_verify(),
+pub fn server_cert_type_server_extension<'a>() -> (o: ServerCertTypeServerExtensionCombinator)
+    ensures o@ == spec_server_cert_type_server_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CertificateVerifyCombinator(
+    let combinator = ServerCertTypeServerExtensionCombinator(
     Mapped {
-        inner: CertificateVerifyCombinator1((signature_scheme(), opaque_0_ffff())),
-        mapper: CertificateVerifyMapper,
-    });
-    assert({
-        &&& combinator@ == spec_certificate_verify()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: certificate_type(),
+        mapper: ServerCertTypeServerExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_server_cert_type_server_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_certificate_verify<'a>(input: &'a [u8]) -> (res: PResult<<CertificateVerifyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_server_cert_type_server_extension<'a>(input: &'a [u8]) -> (res: PResult<<ServerCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_certificate_verify().spec_parse(input@) == Some((n as int, v@)),
-        spec_certificate_verify().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_server_cert_type_server_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_server_cert_type_server_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_certificate_verify().spec_parse(input@) is None,
-        spec_certificate_verify().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_server_cert_type_server_extension().spec_parse(input@) is None,
+        spec_server_cert_type_server_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = certificate_verify();
+    let combinator = server_cert_type_server_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_certificate_verify<'a>(v: <CertificateVerifyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_server_cert_type_server_extension<'a>(v: <ServerCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_certificate_verify().wf(v@),
+        spec_server_cert_type_server_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_certificate_verify().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_verify().spec_serialize(v@))
+            &&& n == spec_server_cert_type_server_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_server_cert_type_server_extension().spec_serialize(v@))
         },
 {
-    let combinator = certificate_verify();
+    let combinator = server_cert_type_server_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn certificate_verify_len<'a>(v: <CertificateVerifyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn server_cert_type_server_extension_len<'a>(v: <ServerCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_certificate_verify().wf(v@),
-        spec_certificate_verify().spec_serialize(v@).len() <= usize::MAX,
+        spec_server_cert_type_server_extension().wf(v@),
+        spec_server_cert_type_server_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_certificate_verify().spec_serialize(v@).len(),
+        serialize_len == spec_server_cert_type_server_extension().spec_serialize(v@).len(),
 {
-    let combinator = certificate_verify();
+    let combinator = server_cert_type_server_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
+pub type SpecUnknownExtension = SpecOpaque0Ffff;
+pub type UnknownExtension<'a> = Opaque0Ffff<'a>;
+pub type UnknownExtensionRef<'a> = &'a Opaque0Ffff<'a>;
 
-pub enum SpecHandshakeMsg {
-    ClientHello(SpecClientHello),
-    ServerHello(SpecShOrHrr),
-    NewSessionTicket(SpecNewSessionTicket),
-    EndOfEarlyData(SpecEmpty),
-    EncryptedExtensions(SpecEncryptedExtensions),
-    Certificate(SpecCertificate),
-    CertificateRequest(SpecCertificateRequest),
-    CertificateVerify(SpecCertificateVerify),
-    Finished(SpecFinished),
-    KeyUpdate(SpecKeyUpdate),
-}
-
-pub type SpecHandshakeMsgInner = Either<SpecClientHello, Either<SpecShOrHrr, Either<SpecNewSessionTicket, Either<SpecEmpty, Either<SpecEncryptedExtensions, Either<SpecCertificate, Either<SpecCertificateRequest, Either<SpecCertificateVerify, Either<SpecFinished, SpecKeyUpdate>>>>>>>>>;
 
-impl SpecFrom<SpecHandshakeMsg> for SpecHandshakeMsgInner {
-    open spec fn spec_from(m: SpecHandshakeMsg) -> SpecHandshakeMsgInner {
-        match m {
-            SpecHandshakeMsg::ClientHello(m) => Either::Left(m),
-            SpecHandshakeMsg::ServerHello(m) => Either::Right(Either::Left(m)),
-            SpecHandshakeMsg::NewSessionTicket(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecHandshakeMsg::EndOfEarlyData(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            SpecHandshakeMsg::EncryptedExtensions(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            SpecHandshakeMsg::Certificate(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            SpecHandshakeMsg::CertificateRequest(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
-            SpecHandshakeMsg::CertificateVerify(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
-            SpecHandshakeMsg::Finished(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
-            SpecHandshakeMsg::KeyUpdate(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))),
-        }
-    }
+pub struct SpecUnknownExtensionCombinator(pub SpecUnknownExtensionCombinatorAlias);
 
+impl SpecCombinator for SpecUnknownExtensionCombinator {
+    type Type = SpecUnknownExtension;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
 }
-
-                
-impl SpecFrom<SpecHandshakeMsgInner> for SpecHandshakeMsg {
-    open spec fn spec_from(m: SpecHandshakeMsgInner) -> SpecHandshakeMsg {
-        match m {
-            Either::Left(m) => SpecHandshakeMsg::ClientHello(m),
-            Either::Right(Either::Left(m)) => SpecHandshakeMsg::ServerHello(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecHandshakeMsg::NewSessionTicket(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecHandshakeMsg::EndOfEarlyData(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecHandshakeMsg::EncryptedExtensions(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecHandshakeMsg::Certificate(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => SpecHandshakeMsg::CertificateRequest(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => SpecHandshakeMsg::CertificateVerify(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => SpecHandshakeMsg::Finished(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))) => SpecHandshakeMsg::KeyUpdate(m),
-        }
-    }
-
+impl SecureSpecCombinator for SpecUnknownExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecUnknownExtensionCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
 }
+pub type SpecUnknownExtensionCombinatorAlias = SpecOpaque0FfffCombinator;
 
+pub struct UnknownExtensionCombinator(pub UnknownExtensionCombinatorAlias);
 
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum HandshakeMsg<'a> {
-    ClientHello(ClientHello<'a>),
-    ServerHello(ShOrHrr<'a>),
-    NewSessionTicket(NewSessionTicket<'a>),
-    EndOfEarlyData(Empty<'a>),
-    EncryptedExtensions(EncryptedExtensions<'a>),
-    Certificate(Certificate<'a>),
-    CertificateRequest(CertificateRequest<'a>),
-    CertificateVerify(CertificateVerify<'a>),
-    Finished(Finished<'a>),
-    KeyUpdate(KeyUpdate),
+impl View for UnknownExtensionCombinator {
+    type V = SpecUnknownExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecUnknownExtensionCombinator(self.0@) }
 }
-
-pub type HandshakeMsgInner<'a> = Either<ClientHello<'a>, Either<ShOrHrr<'a>, Either<NewSessionTicket<'a>, Either<Empty<'a>, Either<EncryptedExtensions<'a>, Either<Certificate<'a>, Either<CertificateRequest<'a>, Either<CertificateVerify<'a>, Either<Finished<'a>, KeyUpdate>>>>>>>>>;
-
-pub type HandshakeMsgInnerRef<'a> = Either<&'a ClientHello<'a>, Either<&'a ShOrHrr<'a>, Either<&'a NewSessionTicket<'a>, Either<&'a Empty<'a>, Either<&'a EncryptedExtensions<'a>, Either<&'a Certificate<'a>, Either<&'a CertificateRequest<'a>, Either<&'a CertificateVerify<'a>, Either<&'a Finished<'a>, &'a KeyUpdate>>>>>>>>>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for UnknownExtensionCombinator {
+    type Type = UnknownExtension<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type UnknownExtensionCombinatorAlias = Opaque0FfffCombinator;
 
 
-impl<'a> View for HandshakeMsg<'a> {
-    type V = SpecHandshakeMsg;
-    open spec fn view(&self) -> Self::V {
-        match self {
-            HandshakeMsg::ClientHello(m) => SpecHandshakeMsg::ClientHello(m@),
-            HandshakeMsg::ServerHello(m) => SpecHandshakeMsg::ServerHello(m@),
-            HandshakeMsg::NewSessionTicket(m) => SpecHandshakeMsg::NewSessionTicket(m@),
-            HandshakeMsg::EndOfEarlyData(m) => SpecHandshakeMsg::EndOfEarlyData(m@),
-            HandshakeMsg::EncryptedExtensions(m) => SpecHandshakeMsg::EncryptedExtensions(m@),
-            HandshakeMsg::Certificate(m) => SpecHandshakeMsg::Certificate(m@),
-            HandshakeMsg::CertificateRequest(m) => SpecHandshakeMsg::CertificateRequest(m@),
-            HandshakeMsg::CertificateVerify(m) => SpecHandshakeMsg::CertificateVerify(m@),
-            HandshakeMsg::Finished(m) => SpecHandshakeMsg::Finished(m@),
-            HandshakeMsg::KeyUpdate(m) => SpecHandshakeMsg::KeyUpdate(m@),
-        }
-    }
+pub open spec fn spec_unknown_extension() -> SpecUnknownExtensionCombinator {
+    SpecUnknownExtensionCombinator(spec_opaque_0_ffff())
 }
 
+                
+pub fn unknown_extension<'a>() -> (o: UnknownExtensionCombinator)
+    ensures o@ == spec_unknown_extension(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = UnknownExtensionCombinator(opaque_0_ffff());
+    // assert({
+    //     &&& combinator@ == spec_unknown_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
 
-impl<'a> From<&'a HandshakeMsg<'a>> for HandshakeMsgInnerRef<'a> {
-    fn ex_from(m: &'a HandshakeMsg<'a>) -> HandshakeMsgInnerRef<'a> {
-        match m {
-            HandshakeMsg::ClientHello(m) => Either::Left(m),
-            HandshakeMsg::ServerHello(m) => Either::Right(Either::Left(m)),
-            HandshakeMsg::NewSessionTicket(m) => Either::Right(Either::Right(Either::Left(m))),
-            HandshakeMsg::EndOfEarlyData(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            HandshakeMsg::EncryptedExtensions(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            HandshakeMsg::Certificate(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            HandshakeMsg::CertificateRequest(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
-            HandshakeMsg::CertificateVerify(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))),
-            HandshakeMsg::Finished(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))),
-            HandshakeMsg::KeyUpdate(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))),
-        }
-    }
-
+pub fn parse_unknown_extension<'a>(input: &'a [u8]) -> (res: PResult<<UnknownExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_unknown_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_unknown_extension().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_unknown_extension().spec_parse(input@) is None,
+        spec_unknown_extension().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = unknown_extension();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-impl<'a> From<HandshakeMsgInner<'a>> for HandshakeMsg<'a> {
-    fn ex_from(m: HandshakeMsgInner<'a>) -> HandshakeMsg<'a> {
-        match m {
-            Either::Left(m) => HandshakeMsg::ClientHello(m),
-            Either::Right(Either::Left(m)) => HandshakeMsg::ServerHello(m),
-            Either::Right(Either::Right(Either::Left(m))) => HandshakeMsg::NewSessionTicket(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => HandshakeMsg::EndOfEarlyData(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => HandshakeMsg::EncryptedExtensions(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => HandshakeMsg::Certificate(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => HandshakeMsg::CertificateRequest(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))))) => HandshakeMsg::CertificateVerify(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))))) => HandshakeMsg::Finished(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))))) => HandshakeMsg::KeyUpdate(m),
-        }
-    }
-    
+pub fn serialize_unknown_extension<'a>(v: <UnknownExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_unknown_extension().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_unknown_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_unknown_extension().spec_serialize(v@))
+        },
+{
+    let combinator = unknown_extension();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-
-pub struct HandshakeMsgMapper;
-impl View for HandshakeMsgMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for HandshakeMsgMapper {
-    type Src = SpecHandshakeMsgInner;
-    type Dst = SpecHandshakeMsg;
-}
-impl SpecIsoProof for HandshakeMsgMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
+pub fn unknown_extension_len<'a>(v: <UnknownExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_unknown_extension().wf(v@),
+        spec_unknown_extension().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_unknown_extension().spec_serialize(v@).len(),
+{
+    let combinator = unknown_extension();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
-impl<'a> Iso<'a> for HandshakeMsgMapper {
-    type Src = HandshakeMsgInner<'a>;
-    type Dst = HandshakeMsg<'a>;
-    type RefSrc = HandshakeMsgInnerRef<'a>;
+
+                
+pub mod DigestSize {
+    use super::*;
+    pub spec const SPEC_Hash12: u32 = 12;
+    pub spec const SPEC_Hash20: u32 = 20;
+    pub spec const SPEC_Sha256: u32 = 32;
+    pub spec const SPEC_Sha384: u32 = 48;
+    pub spec const SPEC_Sha512: u32 = 64;
+    pub spec const SPEC_Max: u32 = 16777215;
+    pub exec const Hash12: u32 ensures Hash12 == SPEC_Hash12 { 12 }
+    pub exec const Hash20: u32 ensures Hash20 == SPEC_Hash20 { 20 }
+    pub exec const Sha256: u32 ensures Sha256 == SPEC_Sha256 { 32 }
+    pub exec const Sha384: u32 ensures Sha384 == SPEC_Sha384 { 48 }
+    pub exec const Sha512: u32 ensures Sha512 == SPEC_Sha512 { 64 }
+    pub exec const Max: u32 ensures Max == SPEC_Max { 16777215 }
 }
 
-type SpecHandshakeMsgCombinatorAlias1 = Choice<Cond<SpecFinishedCombinator>, Cond<SpecKeyUpdateCombinator>>;
-type SpecHandshakeMsgCombinatorAlias2 = Choice<Cond<SpecCertificateVerifyCombinator>, SpecHandshakeMsgCombinatorAlias1>;
-type SpecHandshakeMsgCombinatorAlias3 = Choice<Cond<SpecCertificateRequestCombinator>, SpecHandshakeMsgCombinatorAlias2>;
-type SpecHandshakeMsgCombinatorAlias4 = Choice<Cond<SpecCertificateCombinator>, SpecHandshakeMsgCombinatorAlias3>;
-type SpecHandshakeMsgCombinatorAlias5 = Choice<Cond<SpecEncryptedExtensionsCombinator>, SpecHandshakeMsgCombinatorAlias4>;
-type SpecHandshakeMsgCombinatorAlias6 = Choice<Cond<SpecEmptyCombinator>, SpecHandshakeMsgCombinatorAlias5>;
-type SpecHandshakeMsgCombinatorAlias7 = Choice<Cond<SpecNewSessionTicketCombinator>, SpecHandshakeMsgCombinatorAlias6>;
-type SpecHandshakeMsgCombinatorAlias8 = Choice<Cond<SpecShOrHrrCombinator>, SpecHandshakeMsgCombinatorAlias7>;
-type SpecHandshakeMsgCombinatorAlias9 = Choice<Cond<SpecClientHelloCombinator>, SpecHandshakeMsgCombinatorAlias8>;
-pub struct SpecHandshakeMsgCombinator(pub SpecHandshakeMsgCombinatorAlias);
 
-impl SpecCombinator for SpecHandshakeMsgCombinator {
-    type Type = SpecHandshakeMsg;
+pub struct SpecDigestSizeCombinator(pub SpecDigestSizeCombinatorAlias);
+
+impl SpecCombinator for SpecDigestSizeCombinator {
+    type Type = u24;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecHandshakeMsgCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecHandshakeMsgCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecDigestSizeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDigestSizeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecHandshakeMsgCombinatorAlias = AndThen<bytes::Variable, Mapped<SpecHandshakeMsgCombinatorAlias9, HandshakeMsgMapper>>;
-type HandshakeMsgCombinatorAlias1 = Choice<Cond<FinishedCombinator>, Cond<KeyUpdateCombinator>>;
-type HandshakeMsgCombinatorAlias2 = Choice<Cond<CertificateVerifyCombinator>, HandshakeMsgCombinator1>;
-type HandshakeMsgCombinatorAlias3 = Choice<Cond<CertificateRequestCombinator>, HandshakeMsgCombinator2>;
-type HandshakeMsgCombinatorAlias4 = Choice<Cond<CertificateCombinator>, HandshakeMsgCombinator3>;
-type HandshakeMsgCombinatorAlias5 = Choice<Cond<EncryptedExtensionsCombinator>, HandshakeMsgCombinator4>;
-type HandshakeMsgCombinatorAlias6 = Choice<Cond<EmptyCombinator>, HandshakeMsgCombinator5>;
-type HandshakeMsgCombinatorAlias7 = Choice<Cond<NewSessionTicketCombinator>, HandshakeMsgCombinator6>;
-type HandshakeMsgCombinatorAlias8 = Choice<Cond<ShOrHrrCombinator>, HandshakeMsgCombinator7>;
-type HandshakeMsgCombinatorAlias9 = Choice<Cond<ClientHelloCombinator>, HandshakeMsgCombinator8>;
-pub struct HandshakeMsgCombinator1(pub HandshakeMsgCombinatorAlias1);
-impl View for HandshakeMsgCombinator1 {
-    type V = SpecHandshakeMsgCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HandshakeMsgCombinator1, HandshakeMsgCombinatorAlias1);
-
-pub struct HandshakeMsgCombinator2(pub HandshakeMsgCombinatorAlias2);
-impl View for HandshakeMsgCombinator2 {
-    type V = SpecHandshakeMsgCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HandshakeMsgCombinator2, HandshakeMsgCombinatorAlias2);
-
-pub struct HandshakeMsgCombinator3(pub HandshakeMsgCombinatorAlias3);
-impl View for HandshakeMsgCombinator3 {
-    type V = SpecHandshakeMsgCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HandshakeMsgCombinator3, HandshakeMsgCombinatorAlias3);
-
-pub struct HandshakeMsgCombinator4(pub HandshakeMsgCombinatorAlias4);
-impl View for HandshakeMsgCombinator4 {
-    type V = SpecHandshakeMsgCombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HandshakeMsgCombinator4, HandshakeMsgCombinatorAlias4);
-
-pub struct HandshakeMsgCombinator5(pub HandshakeMsgCombinatorAlias5);
-impl View for HandshakeMsgCombinator5 {
-    type V = SpecHandshakeMsgCombinatorAlias5;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HandshakeMsgCombinator5, HandshakeMsgCombinatorAlias5);
-
-pub struct HandshakeMsgCombinator6(pub HandshakeMsgCombinatorAlias6);
-impl View for HandshakeMsgCombinator6 {
-    type V = SpecHandshakeMsgCombinatorAlias6;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HandshakeMsgCombinator6, HandshakeMsgCombinatorAlias6);
-
-pub struct HandshakeMsgCombinator7(pub HandshakeMsgCombinatorAlias7);
-impl View for HandshakeMsgCombinator7 {
-    type V = SpecHandshakeMsgCombinatorAlias7;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HandshakeMsgCombinator7, HandshakeMsgCombinatorAlias7);
-
-pub struct HandshakeMsgCombinator8(pub HandshakeMsgCombinatorAlias8);
-impl View for HandshakeMsgCombinator8 {
-    type V = SpecHandshakeMsgCombinatorAlias8;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HandshakeMsgCombinator8, HandshakeMsgCombinatorAlias8);
-
-pub struct HandshakeMsgCombinator9(pub HandshakeMsgCombinatorAlias9);
-impl View for HandshakeMsgCombinator9 {
-    type V = SpecHandshakeMsgCombinatorAlias9;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(HandshakeMsgCombinator9, HandshakeMsgCombinatorAlias9);
+pub type SpecDigestSizeCombinatorAlias = U24Be;
 
-pub struct HandshakeMsgCombinator(pub HandshakeMsgCombinatorAlias);
+pub struct DigestSizeCombinator(pub DigestSizeCombinatorAlias);
 
-impl View for HandshakeMsgCombinator {
-    type V = SpecHandshakeMsgCombinator;
-    open spec fn view(&self) -> Self::V { SpecHandshakeMsgCombinator(self.0@) }
+impl View for DigestSizeCombinator {
+    type V = SpecDigestSizeCombinator;
+    open spec fn view(&self) -> Self::V { SpecDigestSizeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HandshakeMsgCombinator {
-    type Type = HandshakeMsg<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DigestSizeCombinator {
+    type Type = u24;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type HandshakeMsgCombinatorAlias = AndThen<bytes::Variable, Mapped<HandshakeMsgCombinator9, HandshakeMsgMapper>>;
+}
+pub type DigestSizeCombinatorAlias = U24Be;
 
 
-pub open spec fn spec_handshake_msg(length: u24, msg_type: SpecHandshakeType) -> SpecHandshakeMsgCombinator {
-    SpecHandshakeMsgCombinator(AndThen(bytes::Variable(length.spec_into()), Mapped { inner: Choice(Cond { cond: msg_type == HandshakeType::ClientHello, inner: spec_client_hello() }, Choice(Cond { cond: msg_type == HandshakeType::ServerHello, inner: spec_sh_or_hrr() }, Choice(Cond { cond: msg_type == HandshakeType::NewSessionTicket, inner: spec_new_session_ticket() }, Choice(Cond { cond: msg_type == HandshakeType::EndOfEarlyData, inner: spec_empty() }, Choice(Cond { cond: msg_type == HandshakeType::EncryptedExtensions, inner: spec_encrypted_extensions() }, Choice(Cond { cond: msg_type == HandshakeType::Certificate, inner: spec_certificate() }, Choice(Cond { cond: msg_type == HandshakeType::CertificateRequest, inner: spec_certificate_request() }, Choice(Cond { cond: msg_type == HandshakeType::CertificateVerify, inner: spec_certificate_verify() }, Choice(Cond { cond: msg_type == HandshakeType::Finished, inner: spec_finished(length) }, Cond { cond: msg_type == HandshakeType::KeyUpdate, inner: spec_key_update() }))))))))), mapper: HandshakeMsgMapper }))
+pub open spec fn spec_digest_size() -> SpecDigestSizeCombinator {
+    SpecDigestSizeCombinator(U24Be)
 }
 
-pub fn handshake_msg<'a>(length: u24, msg_type: HandshakeType) -> (o: HandshakeMsgCombinator)
-    ensures o@ == spec_handshake_msg(length@, msg_type@),
+                
+pub fn digest_size<'a>() -> (o: DigestSizeCombinator)
+    ensures o@ == spec_digest_size(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = HandshakeMsgCombinator(AndThen(bytes::Variable(length.ex_into()), Mapped { inner: HandshakeMsgCombinator9(Choice::new(Cond { cond: msg_type == HandshakeType::ClientHello, inner: client_hello() }, HandshakeMsgCombinator8(Choice::new(Cond { cond: msg_type == HandshakeType::ServerHello, inner: sh_or_hrr() }, HandshakeMsgCombinator7(Choice::new(Cond { cond: msg_type == HandshakeType::NewSessionTicket, inner: new_session_ticket() }, HandshakeMsgCombinator6(Choice::new(Cond { cond: msg_type == HandshakeType::EndOfEarlyData, inner: empty() }, HandshakeMsgCombinator5(Choice::new(Cond { cond: msg_type == HandshakeType::EncryptedExtensions, inner: encrypted_extensions() }, HandshakeMsgCombinator4(Choice::new(Cond { cond: msg_type == HandshakeType::Certificate, inner: certificate() }, HandshakeMsgCombinator3(Choice::new(Cond { cond: msg_type == HandshakeType::CertificateRequest, inner: certificate_request() }, HandshakeMsgCombinator2(Choice::new(Cond { cond: msg_type == HandshakeType::CertificateVerify, inner: certificate_verify() }, HandshakeMsgCombinator1(Choice::new(Cond { cond: msg_type == HandshakeType::Finished, inner: finished(length) }, Cond { cond: msg_type == HandshakeType::KeyUpdate, inner: key_update() })))))))))))))))))), mapper: HandshakeMsgMapper }));
-    assert({
-        &&& combinator@ == spec_handshake_msg(length@, msg_type@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = DigestSizeCombinator(U24Be);
+    // assert({
+    //     &&& combinator@ == spec_digest_size()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_handshake_msg<'a>(input: &'a [u8], length: u24, msg_type: HandshakeType) -> (res: PResult<<HandshakeMsgCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_digest_size<'a>(input: &'a [u8]) -> (res: PResult<<DigestSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_handshake_msg(length@, msg_type@).spec_parse(input@) == Some((n as int, v@)),
-        spec_handshake_msg(length@, msg_type@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_digest_size().spec_parse(input@) == Some((n as int, v@)),
+        spec_digest_size().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_handshake_msg(length@, msg_type@).spec_parse(input@) is None,
-        spec_handshake_msg(length@, msg_type@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_digest_size().spec_parse(input@) is None,
+        spec_digest_size().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = handshake_msg( length, msg_type );
+    let combinator = digest_size();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_handshake_msg<'a>(v: <HandshakeMsgCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, length: u24, msg_type: HandshakeType) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_digest_size<'a>(v: <DigestSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_handshake_msg(length@, msg_type@).wf(v@),
+        spec_digest_size().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_handshake_msg(length@, msg_type@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_handshake_msg(length@, msg_type@).spec_serialize(v@))
+            &&& n == spec_digest_size().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_digest_size().spec_serialize(v@))
         },
 {
-    let combinator = handshake_msg( length, msg_type );
-    combinator.serialize(v, data, pos)
+    let combinator = digest_size();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn handshake_msg_len<'a>(v: <HandshakeMsgCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, length: u24, msg_type: HandshakeType) -> (serialize_len: usize)
+pub fn digest_size_len<'a>(v: <DigestSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_handshake_msg(length@, msg_type@).wf(v@),
-        spec_handshake_msg(length@, msg_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_digest_size().wf(v@),
+        spec_digest_size().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_handshake_msg(length@, msg_type@).spec_serialize(v@).len(),
+        serialize_len == spec_digest_size().spec_serialize(v@).len(),
 {
-    let combinator = handshake_msg( length, msg_type );
+    let combinator = digest_size();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+                
 
-pub struct SpecHandshake {
-    pub msg_type: SpecHandshakeType,
-    pub length: u24,
-    pub msg: SpecHandshakeMsg,
+pub struct SpecHeartbeatExtension {
+    pub mode: u8,
 }
 
-pub type SpecHandshakeInner = ((SpecHandshakeType, u24), SpecHandshakeMsg);
+pub type SpecHeartbeatExtensionInner = u8;
 
 
-impl SpecFrom<SpecHandshake> for SpecHandshakeInner {
-    open spec fn spec_from(m: SpecHandshake) -> SpecHandshakeInner {
-        ((m.msg_type, m.length), m.msg)
+impl SpecFrom<SpecHeartbeatExtension> for SpecHeartbeatExtensionInner {
+    open spec fn spec_from(m: SpecHeartbeatExtension) -> SpecHeartbeatExtensionInner {
+        m.mode
     }
 }
 
-impl SpecFrom<SpecHandshakeInner> for SpecHandshake {
-    open spec fn spec_from(m: SpecHandshakeInner) -> SpecHandshake {
-        let ((msg_type, length), msg) = m;
-        SpecHandshake { msg_type, length, msg }
+impl SpecFrom<SpecHeartbeatExtensionInner> for SpecHeartbeatExtension {
+    open spec fn spec_from(m: SpecHeartbeatExtensionInner) -> SpecHeartbeatExtension {
+        let mode = m;
+        SpecHeartbeatExtension { mode }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Handshake<'a> {
-    pub msg_type: HandshakeType,
-    pub length: u24,
-    pub msg: HandshakeMsg<'a>,
+pub struct HeartbeatExtension {
+    pub mode: u8,
 }
 
-impl View for Handshake<'_> {
-    type V = SpecHandshake;
+impl View for HeartbeatExtension {
+    type V = SpecHeartbeatExtension;
 
     open spec fn view(&self) -> Self::V {
-        SpecHandshake {
-            msg_type: self.msg_type@,
-            length: self.length@,
-            msg: self.msg@,
+        SpecHeartbeatExtension {
+            mode: self.mode@,
         }
     }
 }
-pub type HandshakeInner<'a> = ((HandshakeType, u24), HandshakeMsg<'a>);
+pub type HeartbeatExtensionInner = u8;
 
-pub type HandshakeInnerRef<'a> = ((&'a HandshakeType, &'a u24), &'a HandshakeMsg<'a>);
-impl<'a> From<&'a Handshake<'a>> for HandshakeInnerRef<'a> {
-    fn ex_from(m: &'a Handshake) -> HandshakeInnerRef<'a> {
-        ((&m.msg_type, &m.length), &m.msg)
+pub type HeartbeatExtensionInnerRef<'a> = &'a u8;
+impl<'a> From<&'a HeartbeatExtension> for HeartbeatExtensionInnerRef<'a> {
+    fn ex_from(m: &'a HeartbeatExtension) -> HeartbeatExtensionInnerRef<'a> {
+        &m.mode
     }
 }
 
-impl<'a> From<HandshakeInner<'a>> for Handshake<'a> {
-    fn ex_from(m: HandshakeInner) -> Handshake {
-        let ((msg_type, length), msg) = m;
-        Handshake { msg_type, length, msg }
+impl From<HeartbeatExtensionInner> for HeartbeatExtension {
+    fn ex_from(m: HeartbeatExtensionInner) -> HeartbeatExtension {
+        let mode = m;
+        HeartbeatExtension { mode }
     }
 }
 
-pub struct HandshakeMapper;
-impl View for HandshakeMapper {
+pub struct HeartbeatExtensionMapper;
+impl View for HeartbeatExtensionMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for HandshakeMapper {
-    type Src = SpecHandshakeInner;
-    type Dst = SpecHandshake;
+impl SpecIso for HeartbeatExtensionMapper {
+    type Src = SpecHeartbeatExtensionInner;
+    type Dst = SpecHeartbeatExtension;
 }
-impl SpecIsoProof for HandshakeMapper {
+impl SpecIsoProof for HeartbeatExtensionMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -24773,525 +25223,323 @@ impl SpecIsoProof for HandshakeMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for HandshakeMapper {
-    type Src = HandshakeInner<'a>;
-    type Dst = Handshake<'a>;
-    type RefSrc = HandshakeInnerRef<'a>;
+impl<'a> Iso<'a> for HeartbeatExtensionMapper {
+    type Src = HeartbeatExtensionInner;
+    type Dst = HeartbeatExtension;
+    type RefSrc = HeartbeatExtensionInnerRef<'a>;
 }
 
-pub struct SpecHandshakeCombinator(pub SpecHandshakeCombinatorAlias);
+pub struct SpecHeartbeatExtensionCombinator(pub SpecHeartbeatExtensionCombinatorAlias);
 
-impl SpecCombinator for SpecHandshakeCombinator {
-    type Type = SpecHandshake;
+impl SpecCombinator for SpecHeartbeatExtensionCombinator {
+    type Type = SpecHeartbeatExtension;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecHandshakeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecHandshakeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecHeartbeatExtensionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecHeartbeatExtensionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecHandshakeCombinatorAlias = Mapped<SpecPair<SpecPair<SpecHandshakeTypeCombinator, U24Be>, SpecHandshakeMsgCombinator>, HandshakeMapper>;
+pub type SpecHeartbeatExtensionCombinatorAlias = Mapped<SpecHeartbeatModeCombinator, HeartbeatExtensionMapper>;
 
-pub struct HandshakeCombinator(pub HandshakeCombinatorAlias);
+pub struct HeartbeatExtensionCombinator(pub HeartbeatExtensionCombinatorAlias);
 
-impl View for HandshakeCombinator {
-    type V = SpecHandshakeCombinator;
-    open spec fn view(&self) -> Self::V { SpecHandshakeCombinator(self.0@) }
+impl View for HeartbeatExtensionCombinator {
+    type V = SpecHeartbeatExtensionCombinator;
+    open spec fn view(&self) -> Self::V { SpecHeartbeatExtensionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HandshakeCombinator {
-    type Type = Handshake<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for HeartbeatExtensionCombinator {
+    type Type = HeartbeatExtension;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type HandshakeCombinatorAlias = Mapped<Pair<Pair<HandshakeTypeCombinator, U24Be, HandshakeCont1>, HandshakeMsgCombinator, HandshakeCont0>, HandshakeMapper>;
+}
+pub type HeartbeatExtensionCombinatorAlias = Mapped<HeartbeatModeCombinator, HeartbeatExtensionMapper>;
 
 
-pub open spec fn spec_handshake() -> SpecHandshakeCombinator {
-    SpecHandshakeCombinator(
+pub open spec fn spec_heartbeat_extension() -> SpecHeartbeatExtensionCombinator {
+    SpecHeartbeatExtensionCombinator(
     Mapped {
-        inner: Pair::spec_new(Pair::spec_new(spec_handshake_type(), |deps| spec_handshake_cont1(deps)), |deps| spec_handshake_cont0(deps)),
-        mapper: HandshakeMapper,
+        inner: spec_heartbeat_mode(),
+        mapper: HeartbeatExtensionMapper,
     })
 }
 
-pub open spec fn spec_handshake_cont1(deps: SpecHandshakeType) -> U24Be {
-    let msg_type = deps;
-    U24Be
-}
-
-impl View for HandshakeCont1 {
-    type V = spec_fn(SpecHandshakeType) -> U24Be;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: SpecHandshakeType| {
-            spec_handshake_cont1(deps)
-        }
-    }
-}
-
-pub open spec fn spec_handshake_cont0(deps: (SpecHandshakeType, u24)) -> SpecHandshakeMsgCombinator {
-    let (msg_type, length) = deps;
-    spec_handshake_msg(length, msg_type)
-}
-
-impl View for HandshakeCont0 {
-    type V = spec_fn((SpecHandshakeType, u24)) -> SpecHandshakeMsgCombinator;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: (SpecHandshakeType, u24)| {
-            spec_handshake_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn handshake<'a>() -> (o: HandshakeCombinator)
-    ensures o@ == spec_handshake(),
+pub fn heartbeat_extension<'a>() -> (o: HeartbeatExtensionCombinator)
+    ensures o@ == spec_heartbeat_extension(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = HandshakeCombinator(
+    let combinator = HeartbeatExtensionCombinator(
     Mapped {
-        inner: Pair::new(Pair::new(handshake_type(), HandshakeCont1), HandshakeCont0),
-        mapper: HandshakeMapper,
-    });
-    assert({
-        &&& combinator@ == spec_handshake()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: heartbeat_mode(),
+        mapper: HeartbeatExtensionMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_heartbeat_extension()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_handshake<'a>(input: &'a [u8]) -> (res: PResult<<HandshakeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_heartbeat_extension<'a>(input: &'a [u8]) -> (res: PResult<<HeartbeatExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_handshake().spec_parse(input@) == Some((n as int, v@)),
-        spec_handshake().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_heartbeat_extension().spec_parse(input@) == Some((n as int, v@)),
+        spec_heartbeat_extension().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_handshake().spec_parse(input@) is None,
-        spec_handshake().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_heartbeat_extension().spec_parse(input@) is None,
+        spec_heartbeat_extension().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = handshake();
+    let combinator = heartbeat_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_handshake<'a>(v: <HandshakeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_heartbeat_extension<'a>(v: <HeartbeatExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_handshake().wf(v@),
+        spec_heartbeat_extension().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_handshake().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_handshake().spec_serialize(v@))
+            &&& n == spec_heartbeat_extension().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_heartbeat_extension().spec_serialize(v@))
         },
 {
-    let combinator = handshake();
+    let combinator = heartbeat_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn handshake_len<'a>(v: <HandshakeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn heartbeat_extension_len<'a>(v: <HeartbeatExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_handshake().wf(v@),
-        spec_handshake().spec_serialize(v@).len() <= usize::MAX,
+        spec_heartbeat_extension().wf(v@),
+        spec_heartbeat_extension().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_handshake().spec_serialize(v@).len(),
+        serialize_len == spec_heartbeat_extension().spec_serialize(v@).len(),
 {
-    let combinator = handshake();
+    let combinator = heartbeat_extension();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct HandshakeCont1;
-type HandshakeCont1Type<'a, 'b> = &'b HandshakeType;
-type HandshakeCont1SType<'a, 'x> = &'x HandshakeType;
-type HandshakeCont1Input<'a, 'b, 'x> = POrSType<HandshakeCont1Type<'a, 'b>, HandshakeCont1SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<HandshakeCont1Input<'a, 'b, 'x>> for HandshakeCont1 {
-    type Output = U24Be;
-
-    open spec fn requires(&self, deps: HandshakeCont1Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: HandshakeCont1Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_handshake_cont1(deps@)
-    }
-
-    fn apply(&self, deps: HandshakeCont1Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let msg_type = *deps;
-                U24Be
-            }
-            POrSType::S(deps) => {
-                let msg_type = deps;
-                let msg_type = *msg_type;
-                U24Be
-            }
-        }
-    }
-}
-pub struct HandshakeCont0;
-type HandshakeCont0Type<'a, 'b> = &'b (HandshakeType, u24);
-type HandshakeCont0SType<'a, 'x> = (&'x HandshakeType, &'x u24);
-type HandshakeCont0Input<'a, 'b, 'x> = POrSType<HandshakeCont0Type<'a, 'b>, HandshakeCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<HandshakeCont0Input<'a, 'b, 'x>> for HandshakeCont0 {
-    type Output = HandshakeMsgCombinator;
-
-    open spec fn requires(&self, deps: HandshakeCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: HandshakeCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_handshake_cont0(deps@)
-    }
-
-    fn apply(&self, deps: HandshakeCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let (msg_type, length) = *deps;
-                handshake_msg(length, msg_type)
-            }
-            POrSType::S(deps) => {
-                let (msg_type, length) = deps;
-                let (msg_type, length) = (*msg_type, *length);
-                handshake_msg(length, msg_type)
-            }
-        }
-    }
-}
-                
-
-pub struct SpecOpaque0Ffffff {
-    pub l: u24,
-    pub data: Seq<u8>,
-}
-
-pub type SpecOpaque0FfffffInner = (u24, Seq<u8>);
-
-
-impl SpecFrom<SpecOpaque0Ffffff> for SpecOpaque0FfffffInner {
-    open spec fn spec_from(m: SpecOpaque0Ffffff) -> SpecOpaque0FfffffInner {
-        (m.l, m.data)
-    }
-}
-
-impl SpecFrom<SpecOpaque0FfffffInner> for SpecOpaque0Ffffff {
-    open spec fn spec_from(m: SpecOpaque0FfffffInner) -> SpecOpaque0Ffffff {
-        let (l, data) = m;
-        SpecOpaque0Ffffff { l, data }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct Opaque0Ffffff<'a> {
-    pub l: u24,
-    pub data: &'a [u8],
-}
-
-impl View for Opaque0Ffffff<'_> {
-    type V = SpecOpaque0Ffffff;
-
-    open spec fn view(&self) -> Self::V {
-        SpecOpaque0Ffffff {
-            l: self.l@,
-            data: self.data@,
-        }
-    }
-}
-pub type Opaque0FfffffInner<'a> = (u24, &'a [u8]);
-
-pub type Opaque0FfffffInnerRef<'a> = (&'a u24, &'a &'a [u8]);
-impl<'a> From<&'a Opaque0Ffffff<'a>> for Opaque0FfffffInnerRef<'a> {
-    fn ex_from(m: &'a Opaque0Ffffff) -> Opaque0FfffffInnerRef<'a> {
-        (&m.l, &m.data)
-    }
-}
-
-impl<'a> From<Opaque0FfffffInner<'a>> for Opaque0Ffffff<'a> {
-    fn ex_from(m: Opaque0FfffffInner) -> Opaque0Ffffff {
-        let (l, data) = m;
-        Opaque0Ffffff { l, data }
-    }
-}
-
-pub struct Opaque0FfffffMapper;
-impl View for Opaque0FfffffMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for Opaque0FfffffMapper {
-    type Src = SpecOpaque0FfffffInner;
-    type Dst = SpecOpaque0Ffffff;
-}
-impl SpecIsoProof for Opaque0FfffffMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for Opaque0FfffffMapper {
-    type Src = Opaque0FfffffInner<'a>;
-    type Dst = Opaque0Ffffff<'a>;
-    type RefSrc = Opaque0FfffffInnerRef<'a>;
+                
+pub mod EcPointFormat {
+    use super::*;
+    pub spec const SPEC_Uncompressed: u8 = 0;
+    pub spec const SPEC_AnsiX962CompressedPrime: u8 = 1;
+    pub spec const SPEC_AnsiX962CompressedChar2: u8 = 2;
+    pub exec const Uncompressed: u8 ensures Uncompressed == SPEC_Uncompressed { 0 }
+    pub exec const AnsiX962CompressedPrime: u8 ensures AnsiX962CompressedPrime == SPEC_AnsiX962CompressedPrime { 1 }
+    pub exec const AnsiX962CompressedChar2: u8 ensures AnsiX962CompressedChar2 == SPEC_AnsiX962CompressedChar2 { 2 }
 }
 
-pub struct SpecOpaque0FfffffCombinator(pub SpecOpaque0FfffffCombinatorAlias);
 
-impl SpecCombinator for SpecOpaque0FfffffCombinator {
-    type Type = SpecOpaque0Ffffff;
+pub struct SpecEcPointFormatCombinator(pub SpecEcPointFormatCombinatorAlias);
+
+impl SpecCombinator for SpecEcPointFormatCombinator {
+    type Type = u8;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOpaque0FfffffCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOpaque0FfffffCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecEcPointFormatCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEcPointFormatCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOpaque0FfffffCombinatorAlias = Mapped<SpecPair<U24Be, bytes::Variable>, Opaque0FfffffMapper>;
+pub type SpecEcPointFormatCombinatorAlias = U8;
 
-pub struct Opaque0FfffffCombinator(pub Opaque0FfffffCombinatorAlias);
+pub struct EcPointFormatCombinator(pub EcPointFormatCombinatorAlias);
 
-impl View for Opaque0FfffffCombinator {
-    type V = SpecOpaque0FfffffCombinator;
-    open spec fn view(&self) -> Self::V { SpecOpaque0FfffffCombinator(self.0@) }
+impl View for EcPointFormatCombinator {
+    type V = SpecEcPointFormatCombinator;
+    open spec fn view(&self) -> Self::V { SpecEcPointFormatCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque0FfffffCombinator {
-    type Type = Opaque0Ffffff<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EcPointFormatCombinator {
+    type Type = u8;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type Opaque0FfffffCombinatorAlias = Mapped<Pair<U24Be, bytes::Variable, Opaque0FfffffCont0>, Opaque0FfffffMapper>;
-
-
-pub open spec fn spec_opaque_0_ffffff() -> SpecOpaque0FfffffCombinator {
-    SpecOpaque0FfffffCombinator(
-    Mapped {
-        inner: Pair::spec_new(U24Be, |deps| spec_opaque0_ffffff_cont0(deps)),
-        mapper: Opaque0FfffffMapper,
-    })
-}
-
-pub open spec fn spec_opaque0_ffffff_cont0(deps: u24) -> bytes::Variable {
-    let l = deps;
-    bytes::Variable(l.spec_into())
 }
+pub type EcPointFormatCombinatorAlias = U8;
 
-impl View for Opaque0FfffffCont0 {
-    type V = spec_fn(u24) -> bytes::Variable;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u24| {
-            spec_opaque0_ffffff_cont0(deps)
-        }
-    }
+pub open spec fn spec_ec_point_format() -> SpecEcPointFormatCombinator {
+    SpecEcPointFormatCombinator(U8)
 }
 
                 
-pub fn opaque_0_ffffff<'a>() -> (o: Opaque0FfffffCombinator)
-    ensures o@ == spec_opaque_0_ffffff(),
+pub fn ec_point_format<'a>() -> (o: EcPointFormatCombinator)
+    ensures o@ == spec_ec_point_format(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = Opaque0FfffffCombinator(
-    Mapped {
-        inner: Pair::new(U24Be, Opaque0FfffffCont0),
-        mapper: Opaque0FfffffMapper,
-    });
-    assert({
-        &&& combinator@ == spec_opaque_0_ffffff()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = EcPointFormatCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_ec_point_format()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_opaque_0_ffffff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque0FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_ec_point_format<'a>(input: &'a [u8]) -> (res: PResult<<EcPointFormatCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_opaque_0_ffffff().spec_parse(input@) == Some((n as int, v@)),
-        spec_opaque_0_ffffff().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_ec_point_format().spec_parse(input@) == Some((n as int, v@)),
+        spec_ec_point_format().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_opaque_0_ffffff().spec_parse(input@) is None,
-        spec_opaque_0_ffffff().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_ec_point_format().spec_parse(input@) is None,
+        spec_ec_point_format().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = opaque_0_ffffff();
+    let combinator = ec_point_format();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_opaque_0_ffffff<'a>(v: <Opaque0FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_ec_point_format<'a>(v: <EcPointFormatCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_opaque_0_ffffff().wf(v@),
+        spec_ec_point_format().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_opaque_0_ffffff().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_0_ffffff().spec_serialize(v@))
+            &&& n == spec_ec_point_format().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_ec_point_format().spec_serialize(v@))
         },
 {
-    let combinator = opaque_0_ffffff();
+    let combinator = ec_point_format();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn opaque_0_ffffff_len<'a>(v: <Opaque0FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn ec_point_format_len<'a>(v: <EcPointFormatCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_opaque_0_ffffff().wf(v@),
-        spec_opaque_0_ffffff().spec_serialize(v@).len() <= usize::MAX,
+        spec_ec_point_format().wf(v@),
+        spec_ec_point_format().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_opaque_0_ffffff().spec_serialize(v@).len(),
+        serialize_len == spec_ec_point_format().spec_serialize(v@).len(),
 {
-    let combinator = opaque_0_ffffff();
+    let combinator = ec_point_format();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct Opaque0FfffffCont0;
-type Opaque0FfffffCont0Type<'a, 'b> = &'b u24;
-type Opaque0FfffffCont0SType<'a, 'x> = &'x u24;
-type Opaque0FfffffCont0Input<'a, 'b, 'x> = POrSType<Opaque0FfffffCont0Type<'a, 'b>, Opaque0FfffffCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<Opaque0FfffffCont0Input<'a, 'b, 'x>> for Opaque0FfffffCont0 {
-    type Output = bytes::Variable;
-
-    open spec fn requires(&self, deps: Opaque0FfffffCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: Opaque0FfffffCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_opaque0_ffffff_cont0(deps@)
-    }
-
-    fn apply(&self, deps: Opaque0FfffffCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                bytes::Variable(l.ex_into())
-            }
-        }
-    }
-}
                 
 
-pub struct SpecSrtpProtectionProfiles {
-    pub l: u16,
-    pub list: Seq<SpecSrtpProtectionProfile>,
+pub struct SpecEcPointFormatList {
+    pub l: u8,
+    pub list: Seq<u8>,
 }
 
-pub type SpecSrtpProtectionProfilesInner = (u16, Seq<SpecSrtpProtectionProfile>);
+pub type SpecEcPointFormatListInner = (u8, Seq<u8>);
 
 
-impl SpecFrom<SpecSrtpProtectionProfiles> for SpecSrtpProtectionProfilesInner {
-    open spec fn spec_from(m: SpecSrtpProtectionProfiles) -> SpecSrtpProtectionProfilesInner {
+impl SpecFrom<SpecEcPointFormatList> for SpecEcPointFormatListInner {
+    open spec fn spec_from(m: SpecEcPointFormatList) -> SpecEcPointFormatListInner {
         (m.l, m.list)
     }
 }
 
-impl SpecFrom<SpecSrtpProtectionProfilesInner> for SpecSrtpProtectionProfiles {
-    open spec fn spec_from(m: SpecSrtpProtectionProfilesInner) -> SpecSrtpProtectionProfiles {
+impl SpecFrom<SpecEcPointFormatListInner> for SpecEcPointFormatList {
+    open spec fn spec_from(m: SpecEcPointFormatListInner) -> SpecEcPointFormatList {
         let (l, list) = m;
-        SpecSrtpProtectionProfiles { l, list }
+        SpecEcPointFormatList { l, list }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct SrtpProtectionProfiles<'a> {
-    pub l: u16,
-    pub list: RepeatResult<SrtpProtectionProfile<'a>>,
+pub struct EcPointFormatList {
+    pub l: u8,
+    pub list: RepeatResult<u8>,
 }
 
-impl View for SrtpProtectionProfiles<'_> {
-    type V = SpecSrtpProtectionProfiles;
+impl View for EcPointFormatList {
+    type V = SpecEcPointFormatList;
 
     open spec fn view(&self) -> Self::V {
-        SpecSrtpProtectionProfiles {
+        SpecEcPointFormatList {
             l: self.l@,
             list: self.list@,
         }
     }
 }
-pub type SrtpProtectionProfilesInner<'a> = (u16, RepeatResult<SrtpProtectionProfile<'a>>);
+pub type EcPointFormatListInner = (u8, RepeatResult<u8>);
 
-pub type SrtpProtectionProfilesInnerRef<'a> = (&'a u16, &'a RepeatResult<SrtpProtectionProfile<'a>>);
-impl<'a> From<&'a SrtpProtectionProfiles<'a>> for SrtpProtectionProfilesInnerRef<'a> {
-    fn ex_from(m: &'a SrtpProtectionProfiles) -> SrtpProtectionProfilesInnerRef<'a> {
+pub type EcPointFormatListInnerRef<'a> = (&'a u8, &'a RepeatResult<u8>);
+impl<'a> From<&'a EcPointFormatList> for EcPointFormatListInnerRef<'a> {
+    fn ex_from(m: &'a EcPointFormatList) -> EcPointFormatListInnerRef<'a> {
         (&m.l, &m.list)
     }
 }
 
-impl<'a> From<SrtpProtectionProfilesInner<'a>> for SrtpProtectionProfiles<'a> {
-    fn ex_from(m: SrtpProtectionProfilesInner) -> SrtpProtectionProfiles {
+impl From<EcPointFormatListInner> for EcPointFormatList {
+    fn ex_from(m: EcPointFormatListInner) -> EcPointFormatList {
         let (l, list) = m;
-        SrtpProtectionProfiles { l, list }
+        EcPointFormatList { l, list }
     }
 }
 
-pub struct SrtpProtectionProfilesMapper;
-impl View for SrtpProtectionProfilesMapper {
+pub struct EcPointFormatListMapper;
+impl View for EcPointFormatListMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for SrtpProtectionProfilesMapper {
-    type Src = SpecSrtpProtectionProfilesInner;
-    type Dst = SpecSrtpProtectionProfiles;
+impl SpecIso for EcPointFormatListMapper {
+    type Src = SpecEcPointFormatListInner;
+    type Dst = SpecEcPointFormatList;
 }
-impl SpecIsoProof for SrtpProtectionProfilesMapper {
+impl SpecIsoProof for EcPointFormatListMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -25299,241 +25547,265 @@ impl SpecIsoProof for SrtpProtectionProfilesMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for SrtpProtectionProfilesMapper {
-    type Src = SrtpProtectionProfilesInner<'a>;
-    type Dst = SrtpProtectionProfiles<'a>;
-    type RefSrc = SrtpProtectionProfilesInnerRef<'a>;
+impl<'a> Iso<'a> for EcPointFormatListMapper {
+    type Src = EcPointFormatListInner;
+    type Dst = EcPointFormatList;
+    type RefSrc = EcPointFormatListInnerRef<'a>;
 }
 
-pub struct SpecSrtpProtectionProfilesCombinator(pub SpecSrtpProtectionProfilesCombinatorAlias);
+pub struct SpecEcPointFormatListCombinator(pub SpecEcPointFormatListCombinatorAlias);
 
-impl SpecCombinator for SpecSrtpProtectionProfilesCombinator {
-    type Type = SpecSrtpProtectionProfiles;
+impl SpecCombinator for SpecEcPointFormatListCombinator {
+    type Type = SpecEcPointFormatList;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecSrtpProtectionProfilesCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSrtpProtectionProfilesCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecEcPointFormatListCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEcPointFormatListCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecSrtpProtectionProfilesCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<SpecSrtpProtectionProfileCombinator>>>, SrtpProtectionProfilesMapper>;
+pub type SpecEcPointFormatListCombinatorAlias = Mapped<SpecPair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<SpecEcPointFormatCombinator>>>, EcPointFormatListMapper>;
 
-pub struct SrtpProtectionProfilesCombinator(pub SrtpProtectionProfilesCombinatorAlias);
+pub struct EcPointFormatListCombinator(pub EcPointFormatListCombinatorAlias);
 
-impl View for SrtpProtectionProfilesCombinator {
-    type V = SpecSrtpProtectionProfilesCombinator;
-    open spec fn view(&self) -> Self::V { SpecSrtpProtectionProfilesCombinator(self.0@) }
+impl View for EcPointFormatListCombinator {
+    type V = SpecEcPointFormatListCombinator;
+    open spec fn view(&self) -> Self::V { SpecEcPointFormatListCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SrtpProtectionProfilesCombinator {
-    type Type = SrtpProtectionProfiles<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EcPointFormatListCombinator {
+    type Type = EcPointFormatList;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SrtpProtectionProfilesCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate8195707947578446211>, AndThen<bytes::Variable, Repeat<SrtpProtectionProfileCombinator>>, SrtpProtectionProfilesCont0>, SrtpProtectionProfilesMapper>;
+}
+pub type EcPointFormatListCombinatorAlias = Mapped<Pair<Refined<U8, Predicate13984338198318635021>, AndThen<bytes::Variable, Repeat<EcPointFormatCombinator>>, EcPointFormatListCont0>, EcPointFormatListMapper>;
 
 
-pub open spec fn spec_srtp_protection_profiles() -> SpecSrtpProtectionProfilesCombinator {
-    SpecSrtpProtectionProfilesCombinator(
+pub open spec fn spec_ec_point_format_list() -> SpecEcPointFormatListCombinator {
+    SpecEcPointFormatListCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, |deps| spec_srtp_protection_profiles_cont0(deps)),
-        mapper: SrtpProtectionProfilesMapper,
+        inner: Pair::spec_new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, |deps| spec_ec_point_format_list_cont0(deps)),
+        mapper: EcPointFormatListMapper,
     })
 }
 
-pub open spec fn spec_srtp_protection_profiles_cont0(deps: u16) -> AndThen<bytes::Variable, Repeat<SpecSrtpProtectionProfileCombinator>> {
+pub open spec fn spec_ec_point_format_list_cont0(deps: u8) -> AndThen<bytes::Variable, Repeat<SpecEcPointFormatCombinator>> {
     let l = deps;
-    AndThen(bytes::Variable(l.spec_into()), Repeat(spec_srtp_protection_profile()))
+    AndThen(bytes::Variable((usize::spec_from(l)) as usize), Repeat(spec_ec_point_format()))
 }
 
-impl View for SrtpProtectionProfilesCont0 {
-    type V = spec_fn(u16) -> AndThen<bytes::Variable, Repeat<SpecSrtpProtectionProfileCombinator>>;
+impl View for EcPointFormatListCont0 {
+    type V = spec_fn(u8) -> AndThen<bytes::Variable, Repeat<SpecEcPointFormatCombinator>>;
 
     open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_srtp_protection_profiles_cont0(deps)
+        |deps: u8| {
+            spec_ec_point_format_list_cont0(deps)
         }
     }
 }
 
                 
-pub fn srtp_protection_profiles<'a>() -> (o: SrtpProtectionProfilesCombinator)
-    ensures o@ == spec_srtp_protection_profiles(),
+pub fn ec_point_format_list<'a>() -> (o: EcPointFormatListCombinator)
+    ensures o@ == spec_ec_point_format_list(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = SrtpProtectionProfilesCombinator(
+    let combinator = EcPointFormatListCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate8195707947578446211 }, SrtpProtectionProfilesCont0),
-        mapper: SrtpProtectionProfilesMapper,
-    });
-    assert({
-        &&& combinator@ == spec_srtp_protection_profiles()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(Refined { inner: U8, predicate: Predicate13984338198318635021 }, EcPointFormatListCont0),
+        mapper: EcPointFormatListMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_ec_point_format_list()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_srtp_protection_profiles<'a>(input: &'a [u8]) -> (res: PResult<<SrtpProtectionProfilesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_ec_point_format_list<'a>(input: &'a [u8]) -> (res: PResult<<EcPointFormatListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_srtp_protection_profiles().spec_parse(input@) == Some((n as int, v@)),
-        spec_srtp_protection_profiles().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_ec_point_format_list().spec_parse(input@) == Some((n as int, v@)),
+        spec_ec_point_format_list().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_srtp_protection_profiles().spec_parse(input@) is None,
-        spec_srtp_protection_profiles().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_ec_point_format_list().spec_parse(input@) is None,
+        spec_ec_point_format_list().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = srtp_protection_profiles();
+    let combinator = ec_point_format_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_srtp_protection_profiles<'a>(v: <SrtpProtectionProfilesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_ec_point_format_list<'a>(v: <EcPointFormatListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_srtp_protection_profiles().wf(v@),
+        spec_ec_point_format_list().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_srtp_protection_profiles().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_srtp_protection_profiles().spec_serialize(v@))
+            &&& n == spec_ec_point_format_list().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_ec_point_format_list().spec_serialize(v@))
         },
 {
-    let combinator = srtp_protection_profiles();
+    let combinator = ec_point_format_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn srtp_protection_profiles_len<'a>(v: <SrtpProtectionProfilesCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn ec_point_format_list_len<'a>(v: <EcPointFormatListCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_srtp_protection_profiles().wf(v@),
-        spec_srtp_protection_profiles().spec_serialize(v@).len() <= usize::MAX,
+        spec_ec_point_format_list().wf(v@),
+        spec_ec_point_format_list().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_srtp_protection_profiles().spec_serialize(v@).len(),
+        serialize_len == spec_ec_point_format_list().spec_serialize(v@).len(),
 {
-    let combinator = srtp_protection_profiles();
+    let combinator = ec_point_format_list();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct SrtpProtectionProfilesCont0;
-type SrtpProtectionProfilesCont0Type<'a, 'b> = &'b u16;
-type SrtpProtectionProfilesCont0SType<'a, 'x> = &'x u16;
-type SrtpProtectionProfilesCont0Input<'a, 'b, 'x> = POrSType<SrtpProtectionProfilesCont0Type<'a, 'b>, SrtpProtectionProfilesCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<SrtpProtectionProfilesCont0Input<'a, 'b, 'x>> for SrtpProtectionProfilesCont0 {
-    type Output = AndThen<bytes::Variable, Repeat<SrtpProtectionProfileCombinator>>;
+pub struct EcPointFormatListCont0;
+type EcPointFormatListCont0Type<'a, 'b> = &'b u8;
+type EcPointFormatListCont0SType<'a, 'x> = &'x u8;
+type EcPointFormatListCont0Input<'a, 'b, 'x> = POrSType<EcPointFormatListCont0Type<'a, 'b>, EcPointFormatListCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<EcPointFormatListCont0Input<'a, 'b, 'x>> for EcPointFormatListCont0 {
+    type Output = AndThen<bytes::Variable, Repeat<EcPointFormatCombinator>>;
 
-    open spec fn requires(&self, deps: SrtpProtectionProfilesCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: EcPointFormatListCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (Refined { inner: U8, predicate: Predicate13984338198318635021 }).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: SrtpProtectionProfilesCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_srtp_protection_profiles_cont0(deps@)
+    open spec fn ensures(&self, deps: EcPointFormatListCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_ec_point_format_list_cont0(deps@)
     }
 
-    fn apply(&self, deps: SrtpProtectionProfilesCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: EcPointFormatListCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(srtp_protection_profile()))
+                let l = deps;
+                let l = *l;
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(ec_point_format()))
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                AndThen(bytes::Variable(l.ex_into()), Repeat::new(srtp_protection_profile()))
+                AndThen(bytes::Variable((usize::ex_from(l)) as usize), Repeat::new(ec_point_format()))
             }
         }
     }
 }
                 
 
-pub struct SpecUseSrtpData {
-    pub profiles: SpecSrtpProtectionProfiles,
-    pub srtp_mki: SpecOpaque0Ff,
+pub enum SpecCertificateEntryData {
+    X509(SpecOpaque1Ffffff),
+    RawPublicKey(SpecOpaque1Ffffff),
 }
 
-pub type SpecUseSrtpDataInner = (SpecSrtpProtectionProfiles, SpecOpaque0Ff);
-
+pub type SpecCertificateEntryDataInner = Either<SpecOpaque1Ffffff, SpecOpaque1Ffffff>;
 
-impl SpecFrom<SpecUseSrtpData> for SpecUseSrtpDataInner {
-    open spec fn spec_from(m: SpecUseSrtpData) -> SpecUseSrtpDataInner {
-        (m.profiles, m.srtp_mki)
+impl SpecFrom<SpecCertificateEntryData> for SpecCertificateEntryDataInner {
+    open spec fn spec_from(m: SpecCertificateEntryData) -> SpecCertificateEntryDataInner {
+        match m {
+            SpecCertificateEntryData::X509(m) => Either::Left(m),
+            SpecCertificateEntryData::RawPublicKey(m) => Either::Right(m),
+        }
     }
+
 }
 
-impl SpecFrom<SpecUseSrtpDataInner> for SpecUseSrtpData {
-    open spec fn spec_from(m: SpecUseSrtpDataInner) -> SpecUseSrtpData {
-        let (profiles, srtp_mki) = m;
-        SpecUseSrtpData { profiles, srtp_mki }
+                
+impl SpecFrom<SpecCertificateEntryDataInner> for SpecCertificateEntryData {
+    open spec fn spec_from(m: SpecCertificateEntryDataInner) -> SpecCertificateEntryData {
+        match m {
+            Either::Left(m) => SpecCertificateEntryData::X509(m),
+            Either::Right(m) => SpecCertificateEntryData::RawPublicKey(m),
+        }
     }
+
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct UseSrtpData<'a> {
-    pub profiles: SrtpProtectionProfiles<'a>,
-    pub srtp_mki: Opaque0Ff<'a>,
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CertificateEntryData<'a> {
+    X509(Opaque1Ffffff<'a>),
+    RawPublicKey(Opaque1Ffffff<'a>),
 }
 
-impl View for UseSrtpData<'_> {
-    type V = SpecUseSrtpData;
+pub type CertificateEntryDataInner<'a> = Either<Opaque1Ffffff<'a>, Opaque1Ffffff<'a>>;
+
+pub type CertificateEntryDataInnerRef<'a> = Either<&'a Opaque1Ffffff<'a>, &'a Opaque1Ffffff<'a>>;
+
 
+impl<'a> View for CertificateEntryData<'a> {
+    type V = SpecCertificateEntryData;
     open spec fn view(&self) -> Self::V {
-        SpecUseSrtpData {
-            profiles: self.profiles@,
-            srtp_mki: self.srtp_mki@,
+        match self {
+            CertificateEntryData::X509(m) => SpecCertificateEntryData::X509(m@),
+            CertificateEntryData::RawPublicKey(m) => SpecCertificateEntryData::RawPublicKey(m@),
         }
     }
 }
-pub type UseSrtpDataInner<'a> = (SrtpProtectionProfiles<'a>, Opaque0Ff<'a>);
 
-pub type UseSrtpDataInnerRef<'a> = (&'a SrtpProtectionProfiles<'a>, &'a Opaque0Ff<'a>);
-impl<'a> From<&'a UseSrtpData<'a>> for UseSrtpDataInnerRef<'a> {
-    fn ex_from(m: &'a UseSrtpData) -> UseSrtpDataInnerRef<'a> {
-        (&m.profiles, &m.srtp_mki)
+
+impl<'a> From<&'a CertificateEntryData<'a>> for CertificateEntryDataInnerRef<'a> {
+    fn ex_from(m: &'a CertificateEntryData<'a>) -> CertificateEntryDataInnerRef<'a> {
+        match m {
+            CertificateEntryData::X509(m) => Either::Left(m),
+            CertificateEntryData::RawPublicKey(m) => Either::Right(m),
+        }
     }
+
 }
 
-impl<'a> From<UseSrtpDataInner<'a>> for UseSrtpData<'a> {
-    fn ex_from(m: UseSrtpDataInner) -> UseSrtpData {
-        let (profiles, srtp_mki) = m;
-        UseSrtpData { profiles, srtp_mki }
+impl<'a> From<CertificateEntryDataInner<'a>> for CertificateEntryData<'a> {
+    fn ex_from(m: CertificateEntryDataInner<'a>) -> CertificateEntryData<'a> {
+        match m {
+            Either::Left(m) => CertificateEntryData::X509(m),
+            Either::Right(m) => CertificateEntryData::RawPublicKey(m),
+        }
     }
+    
 }
 
-pub struct UseSrtpDataMapper;
-impl View for UseSrtpDataMapper {
+
+pub struct CertificateEntryDataMapper;
+impl View for CertificateEntryDataMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for UseSrtpDataMapper {
-    type Src = SpecUseSrtpDataInner;
-    type Dst = SpecUseSrtpData;
+impl SpecIso for CertificateEntryDataMapper {
+    type Src = SpecCertificateEntryDataInner;
+    type Dst = SpecCertificateEntryData;
 }
-impl SpecIsoProof for UseSrtpDataMapper {
+impl SpecIsoProof for CertificateEntryDataMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -25541,203 +25813,206 @@ impl SpecIsoProof for UseSrtpDataMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for UseSrtpDataMapper {
-    type Src = UseSrtpDataInner<'a>;
-    type Dst = UseSrtpData<'a>;
-    type RefSrc = UseSrtpDataInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateEntryDataMapper {
+    type Src = CertificateEntryDataInner<'a>;
+    type Dst = CertificateEntryData<'a>;
+    type RefSrc = CertificateEntryDataInnerRef<'a>;
 }
-type SpecUseSrtpDataCombinatorAlias1 = (SpecSrtpProtectionProfilesCombinator, SpecOpaque0FfCombinator);
-pub struct SpecUseSrtpDataCombinator(pub SpecUseSrtpDataCombinatorAlias);
 
-impl SpecCombinator for SpecUseSrtpDataCombinator {
-    type Type = SpecUseSrtpData;
+type SpecCertificateEntryDataCombinatorAlias1 = Choice<Cond<SpecOpaque1FfffffCombinator>, Cond<SpecOpaque1FfffffCombinator>>;
+pub struct SpecCertificateEntryDataCombinator(pub SpecCertificateEntryDataCombinatorAlias);
+
+impl SpecCombinator for SpecCertificateEntryDataCombinator {
+    type Type = SpecCertificateEntryData;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecUseSrtpDataCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecUseSrtpDataCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateEntryDataCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateEntryDataCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecUseSrtpDataCombinatorAlias = Mapped<SpecUseSrtpDataCombinatorAlias1, UseSrtpDataMapper>;
-type UseSrtpDataCombinatorAlias1 = (SrtpProtectionProfilesCombinator, Opaque0FfCombinator);
-pub struct UseSrtpDataCombinator1(pub UseSrtpDataCombinatorAlias1);
-impl View for UseSrtpDataCombinator1 {
-    type V = SpecUseSrtpDataCombinatorAlias1;
+pub type SpecCertificateEntryDataCombinatorAlias = Mapped<SpecCertificateEntryDataCombinatorAlias1, CertificateEntryDataMapper>;
+type CertificateEntryDataCombinatorAlias1 = Choice<Cond<Opaque1FfffffCombinator>, Cond<Opaque1FfffffCombinator>>;
+pub struct CertificateEntryDataCombinator1(pub CertificateEntryDataCombinatorAlias1);
+impl View for CertificateEntryDataCombinator1 {
+    type V = SpecCertificateEntryDataCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(UseSrtpDataCombinator1, UseSrtpDataCombinatorAlias1);
+impl_wrapper_combinator!(CertificateEntryDataCombinator1, CertificateEntryDataCombinatorAlias1);
 
-pub struct UseSrtpDataCombinator(pub UseSrtpDataCombinatorAlias);
+pub struct CertificateEntryDataCombinator(pub CertificateEntryDataCombinatorAlias);
 
-impl View for UseSrtpDataCombinator {
-    type V = SpecUseSrtpDataCombinator;
-    open spec fn view(&self) -> Self::V { SpecUseSrtpDataCombinator(self.0@) }
+impl View for CertificateEntryDataCombinator {
+    type V = SpecCertificateEntryDataCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateEntryDataCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for UseSrtpDataCombinator {
-    type Type = UseSrtpData<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateEntryDataCombinator {
+    type Type = CertificateEntryData<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type UseSrtpDataCombinatorAlias = Mapped<UseSrtpDataCombinator1, UseSrtpDataMapper>;
+}
+pub type CertificateEntryDataCombinatorAlias = Mapped<CertificateEntryDataCombinator1, CertificateEntryDataMapper>;
 
 
-pub open spec fn spec_use_srtp_data() -> SpecUseSrtpDataCombinator {
-    SpecUseSrtpDataCombinator(
-    Mapped {
-        inner: (spec_srtp_protection_profiles(), spec_opaque_0_ff()),
-        mapper: UseSrtpDataMapper,
-    })
+pub open spec fn spec_certificate_entry_data(cert_type: u8) -> SpecCertificateEntryDataCombinator {
+    SpecCertificateEntryDataCombinator(Mapped { inner: Choice(Cond { cond: cert_type == CertificateType::SPEC_X509, inner: spec_opaque_1_ffffff() }, Cond { cond: cert_type == CertificateType::SPEC_RawPublicKey, inner: spec_opaque_1_ffffff() }), mapper: CertificateEntryDataMapper })
 }
 
-                
-pub fn use_srtp_data<'a>() -> (o: UseSrtpDataCombinator)
-    ensures o@ == spec_use_srtp_data(),
+pub fn certificate_entry_data<'a>(cert_type: u8) -> (o: CertificateEntryDataCombinator)
+    requires
+        spec_certificate_type().wf(cert_type@),
+
+    ensures o@ == spec_certificate_entry_data(cert_type@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = UseSrtpDataCombinator(
-    Mapped {
-        inner: UseSrtpDataCombinator1((srtp_protection_profiles(), opaque_0_ff())),
-        mapper: UseSrtpDataMapper,
-    });
-    assert({
-        &&& combinator@ == spec_use_srtp_data()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = CertificateEntryDataCombinator(Mapped { inner: CertificateEntryDataCombinator1(Choice::new(Cond { cond: cert_type == CertificateType::X509, inner: opaque_1_ffffff() }, Cond { cond: cert_type == CertificateType::RawPublicKey, inner: opaque_1_ffffff() })), mapper: CertificateEntryDataMapper });
+    // assert({
+    //     &&& combinator@ == spec_certificate_entry_data(cert_type@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_use_srtp_data<'a>(input: &'a [u8]) -> (res: PResult<<UseSrtpDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_entry_data<'a>(input: &'a [u8], cert_type: u8) -> (res: PResult<<CertificateEntryDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_certificate_type().wf(cert_type@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_use_srtp_data().spec_parse(input@) == Some((n as int, v@)),
-        spec_use_srtp_data().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_entry_data(cert_type@).spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_entry_data(cert_type@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_use_srtp_data().spec_parse(input@) is None,
-        spec_use_srtp_data().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_entry_data(cert_type@).spec_parse(input@) is None,
+        spec_certificate_entry_data(cert_type@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = use_srtp_data();
+    let combinator = certificate_entry_data( cert_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_use_srtp_data<'a>(v: <UseSrtpDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_entry_data<'a>(v: <CertificateEntryDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, cert_type: u8) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_use_srtp_data().wf(v@),
+        spec_certificate_entry_data(cert_type@).wf(v@),
+        spec_certificate_type().wf(cert_type@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_use_srtp_data().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_use_srtp_data().spec_serialize(v@))
+            &&& n == spec_certificate_entry_data(cert_type@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_entry_data(cert_type@).spec_serialize(v@))
         },
 {
-    let combinator = use_srtp_data();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = certificate_entry_data( cert_type );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn use_srtp_data_len<'a>(v: <UseSrtpDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_entry_data_len<'a>(v: <CertificateEntryDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, cert_type: u8) -> (serialize_len: usize)
     requires
-        spec_use_srtp_data().wf(v@),
-        spec_use_srtp_data().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_entry_data(cert_type@).wf(v@),
+        spec_certificate_entry_data(cert_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_type().wf(cert_type@),
+
     ensures
-        serialize_len == spec_use_srtp_data().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_entry_data(cert_type@).spec_serialize(v@).len(),
 {
-    let combinator = use_srtp_data();
+    let combinator = certificate_entry_data( cert_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
 
-pub struct SpecServerCertTypeServerExtension {
-    pub server_certificate_type: u8,
+pub struct SpecCertificateEntry {
+    pub data: SpecCertificateEntryData,
+    pub extensions: SpecCertificateExtensions,
 }
 
-pub type SpecServerCertTypeServerExtensionInner = u8;
+pub type SpecCertificateEntryInner = (SpecCertificateEntryData, SpecCertificateExtensions);
 
 
-impl SpecFrom<SpecServerCertTypeServerExtension> for SpecServerCertTypeServerExtensionInner {
-    open spec fn spec_from(m: SpecServerCertTypeServerExtension) -> SpecServerCertTypeServerExtensionInner {
-        m.server_certificate_type
+impl SpecFrom<SpecCertificateEntry> for SpecCertificateEntryInner {
+    open spec fn spec_from(m: SpecCertificateEntry) -> SpecCertificateEntryInner {
+        (m.data, m.extensions)
     }
 }
 
-impl SpecFrom<SpecServerCertTypeServerExtensionInner> for SpecServerCertTypeServerExtension {
-    open spec fn spec_from(m: SpecServerCertTypeServerExtensionInner) -> SpecServerCertTypeServerExtension {
-        let server_certificate_type = m;
-        SpecServerCertTypeServerExtension { server_certificate_type }
+impl SpecFrom<SpecCertificateEntryInner> for SpecCertificateEntry {
+    open spec fn spec_from(m: SpecCertificateEntryInner) -> SpecCertificateEntry {
+        let (data, extensions) = m;
+        SpecCertificateEntry { data, extensions }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ServerCertTypeServerExtension {
-    pub server_certificate_type: u8,
+pub struct CertificateEntry<'a> {
+    pub data: CertificateEntryData<'a>,
+    pub extensions: CertificateExtensions<'a>,
 }
 
-impl View for ServerCertTypeServerExtension {
-    type V = SpecServerCertTypeServerExtension;
+impl View for CertificateEntry<'_> {
+    type V = SpecCertificateEntry;
 
     open spec fn view(&self) -> Self::V {
-        SpecServerCertTypeServerExtension {
-            server_certificate_type: self.server_certificate_type@,
+        SpecCertificateEntry {
+            data: self.data@,
+            extensions: self.extensions@,
         }
     }
 }
-pub type ServerCertTypeServerExtensionInner = u8;
+pub type CertificateEntryInner<'a> = (CertificateEntryData<'a>, CertificateExtensions<'a>);
 
-pub type ServerCertTypeServerExtensionInnerRef<'a> = &'a u8;
-impl<'a> From<&'a ServerCertTypeServerExtension> for ServerCertTypeServerExtensionInnerRef<'a> {
-    fn ex_from(m: &'a ServerCertTypeServerExtension) -> ServerCertTypeServerExtensionInnerRef<'a> {
-        &m.server_certificate_type
+pub type CertificateEntryInnerRef<'a> = (&'a CertificateEntryData<'a>, &'a CertificateExtensions<'a>);
+impl<'a> From<&'a CertificateEntry<'a>> for CertificateEntryInnerRef<'a> {
+    fn ex_from(m: &'a CertificateEntry) -> CertificateEntryInnerRef<'a> {
+        (&m.data, &m.extensions)
     }
 }
 
-impl From<ServerCertTypeServerExtensionInner> for ServerCertTypeServerExtension {
-    fn ex_from(m: ServerCertTypeServerExtensionInner) -> ServerCertTypeServerExtension {
-        let server_certificate_type = m;
-        ServerCertTypeServerExtension { server_certificate_type }
+impl<'a> From<CertificateEntryInner<'a>> for CertificateEntry<'a> {
+    fn ex_from(m: CertificateEntryInner) -> CertificateEntry {
+        let (data, extensions) = m;
+        CertificateEntry { data, extensions }
     }
 }
 
-pub struct ServerCertTypeServerExtensionMapper;
-impl View for ServerCertTypeServerExtensionMapper {
+pub struct CertificateEntryMapper;
+impl View for CertificateEntryMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ServerCertTypeServerExtensionMapper {
-    type Src = SpecServerCertTypeServerExtensionInner;
-    type Dst = SpecServerCertTypeServerExtension;
+impl SpecIso for CertificateEntryMapper {
+    type Src = SpecCertificateEntryInner;
+    type Dst = SpecCertificateEntry;
 }
-impl SpecIsoProof for ServerCertTypeServerExtensionMapper {
+impl SpecIsoProof for CertificateEntryMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -25745,315 +26020,432 @@ impl SpecIsoProof for ServerCertTypeServerExtensionMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ServerCertTypeServerExtensionMapper {
-    type Src = ServerCertTypeServerExtensionInner;
-    type Dst = ServerCertTypeServerExtension;
-    type RefSrc = ServerCertTypeServerExtensionInnerRef<'a>;
+impl<'a> Iso<'a> for CertificateEntryMapper {
+    type Src = CertificateEntryInner<'a>;
+    type Dst = CertificateEntry<'a>;
+    type RefSrc = CertificateEntryInnerRef<'a>;
 }
+type SpecCertificateEntryCombinatorAlias1 = (SpecCertificateEntryDataCombinator, SpecCertificateExtensionsCombinator);
+pub struct SpecCertificateEntryCombinator(pub SpecCertificateEntryCombinatorAlias);
 
-pub struct SpecServerCertTypeServerExtensionCombinator(pub SpecServerCertTypeServerExtensionCombinatorAlias);
-
-impl SpecCombinator for SpecServerCertTypeServerExtensionCombinator {
-    type Type = SpecServerCertTypeServerExtension;
+impl SpecCombinator for SpecCertificateEntryCombinator {
+    type Type = SpecCertificateEntry;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecServerCertTypeServerExtensionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecServerCertTypeServerExtensionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCertificateEntryCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCertificateEntryCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecServerCertTypeServerExtensionCombinatorAlias = Mapped<SpecCertificateTypeCombinator, ServerCertTypeServerExtensionMapper>;
+pub type SpecCertificateEntryCombinatorAlias = Mapped<SpecCertificateEntryCombinatorAlias1, CertificateEntryMapper>;
+type CertificateEntryCombinatorAlias1 = (CertificateEntryDataCombinator, CertificateExtensionsCombinator);
+pub struct CertificateEntryCombinator1(pub CertificateEntryCombinatorAlias1);
+impl View for CertificateEntryCombinator1 {
+    type V = SpecCertificateEntryCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(CertificateEntryCombinator1, CertificateEntryCombinatorAlias1);
 
-pub struct ServerCertTypeServerExtensionCombinator(pub ServerCertTypeServerExtensionCombinatorAlias);
+pub struct CertificateEntryCombinator(pub CertificateEntryCombinatorAlias);
 
-impl View for ServerCertTypeServerExtensionCombinator {
-    type V = SpecServerCertTypeServerExtensionCombinator;
-    open spec fn view(&self) -> Self::V { SpecServerCertTypeServerExtensionCombinator(self.0@) }
+impl View for CertificateEntryCombinator {
+    type V = SpecCertificateEntryCombinator;
+    open spec fn view(&self) -> Self::V { SpecCertificateEntryCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ServerCertTypeServerExtensionCombinator {
-    type Type = ServerCertTypeServerExtension;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CertificateEntryCombinator {
+    type Type = CertificateEntry<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ServerCertTypeServerExtensionCombinatorAlias = Mapped<CertificateTypeCombinator, ServerCertTypeServerExtensionMapper>;
+}
+pub type CertificateEntryCombinatorAlias = Mapped<CertificateEntryCombinator1, CertificateEntryMapper>;
 
 
-pub open spec fn spec_server_cert_type_server_extension() -> SpecServerCertTypeServerExtensionCombinator {
-    SpecServerCertTypeServerExtensionCombinator(
+pub open spec fn spec_certificate_entry(cert_type: u8) -> SpecCertificateEntryCombinator {
+    SpecCertificateEntryCombinator(
     Mapped {
-        inner: spec_certificate_type(),
-        mapper: ServerCertTypeServerExtensionMapper,
+        inner: (spec_certificate_entry_data(cert_type), spec_certificate_extensions()),
+        mapper: CertificateEntryMapper,
     })
 }
 
-                
-pub fn server_cert_type_server_extension<'a>() -> (o: ServerCertTypeServerExtensionCombinator)
-    ensures o@ == spec_server_cert_type_server_extension(),
+pub fn certificate_entry<'a>(cert_type: u8) -> (o: CertificateEntryCombinator)
+    requires
+        spec_certificate_type().wf(cert_type@),
+
+    ensures o@ == spec_certificate_entry(cert_type@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ServerCertTypeServerExtensionCombinator(
+    let combinator = CertificateEntryCombinator(
     Mapped {
-        inner: certificate_type(),
-        mapper: ServerCertTypeServerExtensionMapper,
-    });
-    assert({
-        &&& combinator@ == spec_server_cert_type_server_extension()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: CertificateEntryCombinator1((certificate_entry_data(cert_type), certificate_extensions())),
+        mapper: CertificateEntryMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_certificate_entry(cert_type@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_server_cert_type_server_extension<'a>(input: &'a [u8]) -> (res: PResult<<ServerCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_certificate_entry<'a>(input: &'a [u8], cert_type: u8) -> (res: PResult<<CertificateEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_certificate_type().wf(cert_type@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_server_cert_type_server_extension().spec_parse(input@) == Some((n as int, v@)),
-        spec_server_cert_type_server_extension().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_certificate_entry(cert_type@).spec_parse(input@) == Some((n as int, v@)),
+        spec_certificate_entry(cert_type@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_server_cert_type_server_extension().spec_parse(input@) is None,
-        spec_server_cert_type_server_extension().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_certificate_entry(cert_type@).spec_parse(input@) is None,
+        spec_certificate_entry(cert_type@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = server_cert_type_server_extension();
+    let combinator = certificate_entry( cert_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_server_cert_type_server_extension<'a>(v: <ServerCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_certificate_entry<'a>(v: <CertificateEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, cert_type: u8) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_server_cert_type_server_extension().wf(v@),
+        spec_certificate_entry(cert_type@).wf(v@),
+        spec_certificate_type().wf(cert_type@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_server_cert_type_server_extension().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_server_cert_type_server_extension().spec_serialize(v@))
+            &&& n == spec_certificate_entry(cert_type@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_certificate_entry(cert_type@).spec_serialize(v@))
         },
 {
-    let combinator = server_cert_type_server_extension();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = certificate_entry( cert_type );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn server_cert_type_server_extension_len<'a>(v: <ServerCertTypeServerExtensionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn certificate_entry_len<'a>(v: <CertificateEntryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, cert_type: u8) -> (serialize_len: usize)
     requires
-        spec_server_cert_type_server_extension().wf(v@),
-        spec_server_cert_type_server_extension().spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_entry(cert_type@).wf(v@),
+        spec_certificate_entry(cert_type@).spec_serialize(v@).len() <= usize::MAX,
+        spec_certificate_type().wf(cert_type@),
+
     ensures
-        serialize_len == spec_server_cert_type_server_extension().spec_serialize(v@).len(),
+        serialize_len == spec_certificate_entry(cert_type@).spec_serialize(v@).len(),
 {
-    let combinator = server_cert_type_server_extension();
+    let combinator = certificate_entry( cert_type );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
-pub type SpecFinishedOpaque = Seq<u8>;
-pub type FinishedOpaque<'a> = &'a [u8];
-pub type FinishedOpaqueRef<'a> = &'a &'a [u8];
 
+pub struct SpecTlsCiphertext {
+    pub opaque_type: SpecContentType,
+    pub version: u16,
+    pub encrypted_record: SpecOpaque0Ffff,
+}
 
-pub struct SpecFinishedOpaqueCombinator(pub SpecFinishedOpaqueCombinatorAlias);
+pub type SpecTlsCiphertextInner = (SpecContentType, (u16, SpecOpaque0Ffff));
 
-impl SpecCombinator for SpecFinishedOpaqueCombinator {
-    type Type = SpecFinishedOpaque;
+
+impl SpecFrom<SpecTlsCiphertext> for SpecTlsCiphertextInner {
+    open spec fn spec_from(m: SpecTlsCiphertext) -> SpecTlsCiphertextInner {
+        (m.opaque_type, (m.version, m.encrypted_record))
+    }
+}
+
+impl SpecFrom<SpecTlsCiphertextInner> for SpecTlsCiphertext {
+    open spec fn spec_from(m: SpecTlsCiphertextInner) -> SpecTlsCiphertext {
+        let (opaque_type, (version, encrypted_record)) = m;
+        SpecTlsCiphertext { opaque_type, version, encrypted_record }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct TlsCiphertext<'a> {
+    pub opaque_type: ContentType,
+    pub version: u16,
+    pub encrypted_record: Opaque0Ffff<'a>,
+}
+
+impl View for TlsCiphertext<'_> {
+    type V = SpecTlsCiphertext;
+
+    open spec fn view(&self) -> Self::V {
+        SpecTlsCiphertext {
+            opaque_type: self.opaque_type@,
+            version: self.version@,
+            encrypted_record: self.encrypted_record@,
+        }
+    }
+}
+pub type TlsCiphertextInner<'a> = (ContentType, (u16, Opaque0Ffff<'a>));
+
+pub type TlsCiphertextInnerRef<'a> = (&'a ContentType, (&'a u16, &'a Opaque0Ffff<'a>));
+impl<'a> From<&'a TlsCiphertext<'a>> for TlsCiphertextInnerRef<'a> {
+    fn ex_from(m: &'a TlsCiphertext) -> TlsCiphertextInnerRef<'a> {
+        (&m.opaque_type, (&m.version, &m.encrypted_record))
+    }
+}
+
+impl<'a> From<TlsCiphertextInner<'a>> for TlsCiphertext<'a> {
+    fn ex_from(m: TlsCiphertextInner) -> TlsCiphertext {
+        let (opaque_type, (version, encrypted_record)) = m;
+        TlsCiphertext { opaque_type, version, encrypted_record }
+    }
+}
+
+pub struct TlsCiphertextMapper;
+impl View for TlsCiphertextMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for TlsCiphertextMapper {
+    type Src = SpecTlsCiphertextInner;
+    type Dst = SpecTlsCiphertext;
+}
+impl SpecIsoProof for TlsCiphertextMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for TlsCiphertextMapper {
+    type Src = TlsCiphertextInner<'a>;
+    type Dst = TlsCiphertext<'a>;
+    type RefSrc = TlsCiphertextInnerRef<'a>;
+}
+type SpecTlsCiphertextCombinatorAlias1 = (SpecProtocolVersionCombinator, SpecOpaque0FfffCombinator);
+type SpecTlsCiphertextCombinatorAlias2 = (SpecContentTypeCombinator, SpecTlsCiphertextCombinatorAlias1);
+pub struct SpecTlsCiphertextCombinator(pub SpecTlsCiphertextCombinatorAlias);
+
+impl SpecCombinator for SpecTlsCiphertextCombinator {
+    type Type = SpecTlsCiphertext;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecFinishedOpaqueCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecFinishedOpaqueCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTlsCiphertextCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTlsCiphertextCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecFinishedOpaqueCombinatorAlias = bytes::Variable;
+pub type SpecTlsCiphertextCombinatorAlias = Mapped<SpecTlsCiphertextCombinatorAlias2, TlsCiphertextMapper>;
+type TlsCiphertextCombinatorAlias1 = (ProtocolVersionCombinator, Opaque0FfffCombinator);
+type TlsCiphertextCombinatorAlias2 = (ContentTypeCombinator, TlsCiphertextCombinator1);
+pub struct TlsCiphertextCombinator1(pub TlsCiphertextCombinatorAlias1);
+impl View for TlsCiphertextCombinator1 {
+    type V = SpecTlsCiphertextCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TlsCiphertextCombinator1, TlsCiphertextCombinatorAlias1);
+
+pub struct TlsCiphertextCombinator2(pub TlsCiphertextCombinatorAlias2);
+impl View for TlsCiphertextCombinator2 {
+    type V = SpecTlsCiphertextCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TlsCiphertextCombinator2, TlsCiphertextCombinatorAlias2);
 
-pub struct FinishedOpaqueCombinator(pub FinishedOpaqueCombinatorAlias);
+pub struct TlsCiphertextCombinator(pub TlsCiphertextCombinatorAlias);
 
-impl View for FinishedOpaqueCombinator {
-    type V = SpecFinishedOpaqueCombinator;
-    open spec fn view(&self) -> Self::V { SpecFinishedOpaqueCombinator(self.0@) }
+impl View for TlsCiphertextCombinator {
+    type V = SpecTlsCiphertextCombinator;
+    open spec fn view(&self) -> Self::V { SpecTlsCiphertextCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FinishedOpaqueCombinator {
-    type Type = FinishedOpaque<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TlsCiphertextCombinator {
+    type Type = TlsCiphertext<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type FinishedOpaqueCombinatorAlias = bytes::Variable;
+}
+pub type TlsCiphertextCombinatorAlias = Mapped<TlsCiphertextCombinator2, TlsCiphertextMapper>;
 
 
-pub open spec fn spec_finished_opaque(digest_size: u24) -> SpecFinishedOpaqueCombinator {
-    SpecFinishedOpaqueCombinator(bytes::Variable(digest_size.spec_into()))
+pub open spec fn spec_tls_ciphertext() -> SpecTlsCiphertextCombinator {
+    SpecTlsCiphertextCombinator(
+    Mapped {
+        inner: (spec_content_type(), (spec_protocol_version(), spec_opaque_0_ffff())),
+        mapper: TlsCiphertextMapper,
+    })
 }
 
-pub fn finished_opaque<'a>(digest_size: u24) -> (o: FinishedOpaqueCombinator)
-    ensures o@ == spec_finished_opaque(digest_size@),
+                
+pub fn tls_ciphertext<'a>() -> (o: TlsCiphertextCombinator)
+    ensures o@ == spec_tls_ciphertext(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = FinishedOpaqueCombinator(bytes::Variable(digest_size.ex_into()));
-    assert({
-        &&& combinator@ == spec_finished_opaque(digest_size@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = TlsCiphertextCombinator(
+    Mapped {
+        inner: TlsCiphertextCombinator2((content_type(), TlsCiphertextCombinator1((protocol_version(), opaque_0_ffff())))),
+        mapper: TlsCiphertextMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_tls_ciphertext()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_finished_opaque<'a>(input: &'a [u8], digest_size: u24) -> (res: PResult<<FinishedOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_tls_ciphertext<'a>(input: &'a [u8]) -> (res: PResult<<TlsCiphertextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_finished_opaque(digest_size@).spec_parse(input@) == Some((n as int, v@)),
-        spec_finished_opaque(digest_size@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_tls_ciphertext().spec_parse(input@) == Some((n as int, v@)),
+        spec_tls_ciphertext().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_finished_opaque(digest_size@).spec_parse(input@) is None,
-        spec_finished_opaque(digest_size@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_tls_ciphertext().spec_parse(input@) is None,
+        spec_tls_ciphertext().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = finished_opaque( digest_size );
+    let combinator = tls_ciphertext();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_finished_opaque<'a>(v: <FinishedOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, digest_size: u24) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_tls_ciphertext<'a>(v: <TlsCiphertextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_finished_opaque(digest_size@).wf(v@),
+        spec_tls_ciphertext().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_finished_opaque(digest_size@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_finished_opaque(digest_size@).spec_serialize(v@))
+            &&& n == spec_tls_ciphertext().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_tls_ciphertext().spec_serialize(v@))
         },
 {
-    let combinator = finished_opaque( digest_size );
-    combinator.serialize(v, data, pos)
+    let combinator = tls_ciphertext();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn finished_opaque_len<'a>(v: <FinishedOpaqueCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, digest_size: u24) -> (serialize_len: usize)
+pub fn tls_ciphertext_len<'a>(v: <TlsCiphertextCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_finished_opaque(digest_size@).wf(v@),
-        spec_finished_opaque(digest_size@).spec_serialize(v@).len() <= usize::MAX,
+        spec_tls_ciphertext().wf(v@),
+        spec_tls_ciphertext().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_finished_opaque(digest_size@).spec_serialize(v@).len(),
+        serialize_len == spec_tls_ciphertext().spec_serialize(v@).len(),
 {
-    let combinator = finished_opaque( digest_size );
+    let combinator = tls_ciphertext();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+                
 
-pub struct SpecOpaque2Ffff {
-    pub l: u16,
+pub struct SpecOpaque0Ffffff {
+    pub l: u24,
     pub data: Seq<u8>,
 }
 
-pub type SpecOpaque2FfffInner = (u16, Seq<u8>);
+pub type SpecOpaque0FfffffInner = (u24, Seq<u8>);
 
 
-impl SpecFrom<SpecOpaque2Ffff> for SpecOpaque2FfffInner {
-    open spec fn spec_from(m: SpecOpaque2Ffff) -> SpecOpaque2FfffInner {
+impl SpecFrom<SpecOpaque0Ffffff> for SpecOpaque0FfffffInner {
+    open spec fn spec_from(m: SpecOpaque0Ffffff) -> SpecOpaque0FfffffInner {
         (m.l, m.data)
     }
 }
 
-impl SpecFrom<SpecOpaque2FfffInner> for SpecOpaque2Ffff {
-    open spec fn spec_from(m: SpecOpaque2FfffInner) -> SpecOpaque2Ffff {
+impl SpecFrom<SpecOpaque0FfffffInner> for SpecOpaque0Ffffff {
+    open spec fn spec_from(m: SpecOpaque0FfffffInner) -> SpecOpaque0Ffffff {
         let (l, data) = m;
-        SpecOpaque2Ffff { l, data }
+        SpecOpaque0Ffffff { l, data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Opaque2Ffff<'a> {
-    pub l: u16,
+pub struct Opaque0Ffffff<'a> {
+    pub l: u24,
     pub data: &'a [u8],
 }
 
-impl View for Opaque2Ffff<'_> {
-    type V = SpecOpaque2Ffff;
+impl View for Opaque0Ffffff<'_> {
+    type V = SpecOpaque0Ffffff;
 
     open spec fn view(&self) -> Self::V {
-        SpecOpaque2Ffff {
+        SpecOpaque0Ffffff {
             l: self.l@,
             data: self.data@,
         }
     }
 }
-pub type Opaque2FfffInner<'a> = (u16, &'a [u8]);
+pub type Opaque0FfffffInner<'a> = (u24, &'a [u8]);
 
-pub type Opaque2FfffInnerRef<'a> = (&'a u16, &'a &'a [u8]);
-impl<'a> From<&'a Opaque2Ffff<'a>> for Opaque2FfffInnerRef<'a> {
-    fn ex_from(m: &'a Opaque2Ffff) -> Opaque2FfffInnerRef<'a> {
+pub type Opaque0FfffffInnerRef<'a> = (&'a u24, &'a &'a [u8]);
+impl<'a> From<&'a Opaque0Ffffff<'a>> for Opaque0FfffffInnerRef<'a> {
+    fn ex_from(m: &'a Opaque0Ffffff) -> Opaque0FfffffInnerRef<'a> {
         (&m.l, &m.data)
     }
 }
 
-impl<'a> From<Opaque2FfffInner<'a>> for Opaque2Ffff<'a> {
-    fn ex_from(m: Opaque2FfffInner) -> Opaque2Ffff {
+impl<'a> From<Opaque0FfffffInner<'a>> for Opaque0Ffffff<'a> {
+    fn ex_from(m: Opaque0FfffffInner) -> Opaque0Ffffff {
         let (l, data) = m;
-        Opaque2Ffff { l, data }
+        Opaque0Ffffff { l, data }
     }
 }
 
-pub struct Opaque2FfffMapper;
-impl View for Opaque2FfffMapper {
+pub struct Opaque0FfffffMapper;
+impl View for Opaque0FfffffMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for Opaque2FfffMapper {
-    type Src = SpecOpaque2FfffInner;
-    type Dst = SpecOpaque2Ffff;
+impl SpecIso for Opaque0FfffffMapper {
+    type Src = SpecOpaque0FfffffInner;
+    type Dst = SpecOpaque0Ffffff;
 }
-impl SpecIsoProof for Opaque2FfffMapper {
+impl SpecIsoProof for Opaque0FfffffMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -26061,190 +26453,174 @@ impl SpecIsoProof for Opaque2FfffMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for Opaque2FfffMapper {
-    type Src = Opaque2FfffInner<'a>;
-    type Dst = Opaque2Ffff<'a>;
-    type RefSrc = Opaque2FfffInnerRef<'a>;
+impl<'a> Iso<'a> for Opaque0FfffffMapper {
+    type Src = Opaque0FfffffInner<'a>;
+    type Dst = Opaque0Ffffff<'a>;
+    type RefSrc = Opaque0FfffffInnerRef<'a>;
 }
 
-pub struct SpecOpaque2FfffCombinator(pub SpecOpaque2FfffCombinatorAlias);
+pub struct SpecOpaque0FfffffCombinator(pub SpecOpaque0FfffffCombinatorAlias);
 
-impl SpecCombinator for SpecOpaque2FfffCombinator {
-    type Type = SpecOpaque2Ffff;
+impl SpecCombinator for SpecOpaque0FfffffCombinator {
+    type Type = SpecOpaque0Ffffff;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecOpaque2FfffCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecOpaque2FfffCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecOpaque0FfffffCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecOpaque0FfffffCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecOpaque2FfffCombinatorAlias = Mapped<SpecPair<Refined<U16Be, Predicate3016150102856496288>, bytes::Variable>, Opaque2FfffMapper>;
-pub struct Predicate3016150102856496288;
-impl View for Predicate3016150102856496288 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u16> for Predicate3016150102856496288 {
-    fn apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 2 && i <= 65535)
-    }
-}
-impl SpecPred<u16> for Predicate3016150102856496288 {
-    open spec fn spec_apply(&self, i: &u16) -> bool {
-        let i = (*i);
-        (i >= 2 && i <= 65535)
-    }
-}
+pub type SpecOpaque0FfffffCombinatorAlias = Mapped<SpecPair<U24Be, bytes::Variable>, Opaque0FfffffMapper>;
 
-pub struct Opaque2FfffCombinator(pub Opaque2FfffCombinatorAlias);
+pub struct Opaque0FfffffCombinator(pub Opaque0FfffffCombinatorAlias);
 
-impl View for Opaque2FfffCombinator {
-    type V = SpecOpaque2FfffCombinator;
-    open spec fn view(&self) -> Self::V { SpecOpaque2FfffCombinator(self.0@) }
+impl View for Opaque0FfffffCombinator {
+    type V = SpecOpaque0FfffffCombinator;
+    open spec fn view(&self) -> Self::V { SpecOpaque0FfffffCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque2FfffCombinator {
-    type Type = Opaque2Ffff<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Opaque0FfffffCombinator {
+    type Type = Opaque0Ffffff<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type Opaque2FfffCombinatorAlias = Mapped<Pair<Refined<U16Be, Predicate3016150102856496288>, bytes::Variable, Opaque2FfffCont0>, Opaque2FfffMapper>;
+}
+pub type Opaque0FfffffCombinatorAlias = Mapped<Pair<U24Be, bytes::Variable, Opaque0FfffffCont0>, Opaque0FfffffMapper>;
 
 
-pub open spec fn spec_opaque_2_ffff() -> SpecOpaque2FfffCombinator {
-    SpecOpaque2FfffCombinator(
+pub open spec fn spec_opaque_0_ffffff() -> SpecOpaque0FfffffCombinator {
+    SpecOpaque0FfffffCombinator(
     Mapped {
-        inner: Pair::spec_new(Refined { inner: U16Be, predicate: Predicate3016150102856496288 }, |deps| spec_opaque2_ffff_cont0(deps)),
-        mapper: Opaque2FfffMapper,
+        inner: Pair::spec_new(U24Be, |deps| spec_opaque0_ffffff_cont0(deps)),
+        mapper: Opaque0FfffffMapper,
     })
 }
 
-pub open spec fn spec_opaque2_ffff_cont0(deps: u16) -> bytes::Variable {
+pub open spec fn spec_opaque0_ffffff_cont0(deps: u24) -> bytes::Variable {
     let l = deps;
-    bytes::Variable(l.spec_into())
+    bytes::Variable((usize::spec_from(l)) as usize)
 }
 
-impl View for Opaque2FfffCont0 {
-    type V = spec_fn(u16) -> bytes::Variable;
+impl View for Opaque0FfffffCont0 {
+    type V = spec_fn(u24) -> bytes::Variable;
 
     open spec fn view(&self) -> Self::V {
-        |deps: u16| {
-            spec_opaque2_ffff_cont0(deps)
+        |deps: u24| {
+            spec_opaque0_ffffff_cont0(deps)
         }
     }
 }
 
                 
-pub fn opaque_2_ffff<'a>() -> (o: Opaque2FfffCombinator)
-    ensures o@ == spec_opaque_2_ffff(),
+pub fn opaque_0_ffffff<'a>() -> (o: Opaque0FfffffCombinator)
+    ensures o@ == spec_opaque_0_ffffff(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = Opaque2FfffCombinator(
+    let combinator = Opaque0FfffffCombinator(
     Mapped {
-        inner: Pair::new(Refined { inner: U16Be, predicate: Predicate3016150102856496288 }, Opaque2FfffCont0),
-        mapper: Opaque2FfffMapper,
-    });
-    assert({
-        &&& combinator@ == spec_opaque_2_ffff()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(U24Be, Opaque0FfffffCont0),
+        mapper: Opaque0FfffffMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_opaque_0_ffffff()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_opaque_2_ffff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque2FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_opaque_0_ffffff<'a>(input: &'a [u8]) -> (res: PResult<<Opaque0FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_opaque_2_ffff().spec_parse(input@) == Some((n as int, v@)),
-        spec_opaque_2_ffff().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_opaque_0_ffffff().spec_parse(input@) == Some((n as int, v@)),
+        spec_opaque_0_ffffff().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_opaque_2_ffff().spec_parse(input@) is None,
-        spec_opaque_2_ffff().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_opaque_0_ffffff().spec_parse(input@) is None,
+        spec_opaque_0_ffffff().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = opaque_2_ffff();
+    let combinator = opaque_0_ffffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_opaque_2_ffff<'a>(v: <Opaque2FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_opaque_0_ffffff<'a>(v: <Opaque0FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_opaque_2_ffff().wf(v@),
+        spec_opaque_0_ffffff().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_opaque_2_ffff().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_2_ffff().spec_serialize(v@))
+            &&& n == spec_opaque_0_ffffff().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_opaque_0_ffffff().spec_serialize(v@))
         },
 {
-    let combinator = opaque_2_ffff();
+    let combinator = opaque_0_ffffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn opaque_2_ffff_len<'a>(v: <Opaque2FfffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn opaque_0_ffffff_len<'a>(v: <Opaque0FfffffCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_opaque_2_ffff().wf(v@),
-        spec_opaque_2_ffff().spec_serialize(v@).len() <= usize::MAX,
+        spec_opaque_0_ffffff().wf(v@),
+        spec_opaque_0_ffffff().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_opaque_2_ffff().spec_serialize(v@).len(),
+        serialize_len == spec_opaque_0_ffffff().spec_serialize(v@).len(),
 {
-    let combinator = opaque_2_ffff();
+    let combinator = opaque_0_ffffff();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct Opaque2FfffCont0;
-type Opaque2FfffCont0Type<'a, 'b> = &'b u16;
-type Opaque2FfffCont0SType<'a, 'x> = &'x u16;
-type Opaque2FfffCont0Input<'a, 'b, 'x> = POrSType<Opaque2FfffCont0Type<'a, 'b>, Opaque2FfffCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<Opaque2FfffCont0Input<'a, 'b, 'x>> for Opaque2FfffCont0 {
+pub struct Opaque0FfffffCont0;
+type Opaque0FfffffCont0Type<'a, 'b> = &'b u24;
+type Opaque0FfffffCont0SType<'a, 'x> = &'x u24;
+type Opaque0FfffffCont0Input<'a, 'b, 'x> = POrSType<Opaque0FfffffCont0Type<'a, 'b>, Opaque0FfffffCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<Opaque0FfffffCont0Input<'a, 'b, 'x>> for Opaque0FfffffCont0 {
     type Output = bytes::Variable;
 
-    open spec fn requires(&self, deps: Opaque2FfffCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: Opaque0FfffffCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (U24Be).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: Opaque2FfffCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_opaque2_ffff_cont0(deps@)
+    open spec fn ensures(&self, deps: Opaque0FfffffCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_opaque0_ffffff_cont0(deps@)
     }
 
-    fn apply(&self, deps: Opaque2FfffCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: Opaque0FfffffCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                bytes::Variable(l.ex_into())
+                let l = deps;
+                let l = *l;
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                bytes::Variable(l.ex_into())
+                bytes::Variable((usize::ex_from(l)) as usize)
             }
         }
     }
diff --git a/vest-dsl/wasm/src/vest_wasm.rs b/vest-dsl/wasm/src/vest_wasm.rs
index c67cf0d7..67f9ee9a 100644
--- a/vest-dsl/wasm/src/vest_wasm.rs
+++ b/vest-dsl/wasm/src/vest_wasm.rs
@@ -34,1416 +34,896 @@ macro_rules! impl_wrapper_combinator {
     };
 }
 verus!{
-pub type SpecLocalidx = u64;
-pub type Localidx = u64;
-pub type LocalidxRef<'a> = &'a u64;
+pub type SpecEmpty = Seq<u8>;
+pub type Empty<'a> = &'a [u8];
+pub type EmptyRef<'a> = &'a &'a [u8];
 
 
-pub struct SpecLocalidxCombinator(pub SpecLocalidxCombinatorAlias);
+pub struct SpecEmptyCombinator(pub SpecEmptyCombinatorAlias);
 
-impl SpecCombinator for SpecLocalidxCombinator {
-    type Type = SpecLocalidx;
+impl SpecCombinator for SpecEmptyCombinator {
+    type Type = SpecEmpty;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecLocalidxCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecLocalidxCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecEmptyCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEmptyCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecLocalidxCombinatorAlias = UnsignedLEB128;
+pub type SpecEmptyCombinatorAlias = bytes::Fixed<0>;
 
-pub struct LocalidxCombinator(pub LocalidxCombinatorAlias);
+pub struct EmptyCombinator(pub EmptyCombinatorAlias);
 
-impl View for LocalidxCombinator {
-    type V = SpecLocalidxCombinator;
-    open spec fn view(&self) -> Self::V { SpecLocalidxCombinator(self.0@) }
+impl View for EmptyCombinator {
+    type V = SpecEmptyCombinator;
+    open spec fn view(&self) -> Self::V { SpecEmptyCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LocalidxCombinator {
-    type Type = Localidx;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EmptyCombinator {
+    type Type = Empty<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type LocalidxCombinatorAlias = UnsignedLEB128;
+}
+pub type EmptyCombinatorAlias = bytes::Fixed<0>;
 
 
-pub open spec fn spec_localidx() -> SpecLocalidxCombinator {
-    SpecLocalidxCombinator(UnsignedLEB128)
+pub open spec fn spec_empty() -> SpecEmptyCombinator {
+    SpecEmptyCombinator(bytes::Fixed::<0>)
 }
 
                 
-pub fn localidx<'a>() -> (o: LocalidxCombinator)
-    ensures o@ == spec_localidx(),
+pub fn empty<'a>() -> (o: EmptyCombinator)
+    ensures o@ == spec_empty(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = LocalidxCombinator(UnsignedLEB128);
-    assert({
-        &&& combinator@ == spec_localidx()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = EmptyCombinator(bytes::Fixed::<0>);
+    // assert({
+    //     &&& combinator@ == spec_empty()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_localidx<'a>(input: &'a [u8]) -> (res: PResult<<LocalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_empty<'a>(input: &'a [u8]) -> (res: PResult<<EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_localidx().spec_parse(input@) == Some((n as int, v@)),
-        spec_localidx().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_empty().spec_parse(input@) == Some((n as int, v@)),
+        spec_empty().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_localidx().spec_parse(input@) is None,
-        spec_localidx().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_empty().spec_parse(input@) is None,
+        spec_empty().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = localidx();
+    let combinator = empty();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_localidx<'a>(v: <LocalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_empty<'a>(v: <EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_localidx().wf(v@),
+        spec_empty().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_localidx().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_localidx().spec_serialize(v@))
+            &&& n == spec_empty().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_empty().spec_serialize(v@))
         },
 {
-    let combinator = localidx();
+    let combinator = empty();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn localidx_len<'a>(v: <LocalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn empty_len<'a>(v: <EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_localidx().wf(v@),
-        spec_localidx().spec_serialize(v@).len() <= usize::MAX,
+        spec_empty().wf(v@),
+        spec_empty().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_localidx().spec_serialize(v@).len(),
+        serialize_len == spec_empty().spec_serialize(v@).len(),
 {
-    let combinator = localidx();
+    let combinator = empty();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub mod InstrBytecode {
-    use super::*;
-    pub spec const SPEC_Unreachable: u8 = 0;
-    pub spec const SPEC_Nop: u8 = 1;
-    pub spec const SPEC_Block: u8 = 2;
-    pub spec const SPEC_Loop: u8 = 3;
-    pub spec const SPEC_If: u8 = 4;
-    pub spec const SPEC_Else: u8 = 5;
-    pub spec const SPEC_End: u8 = 11;
-    pub spec const SPEC_Br: u8 = 12;
-    pub spec const SPEC_BrIf: u8 = 13;
-    pub spec const SPEC_BrTable: u8 = 14;
-    pub spec const SPEC_Ret: u8 = 15;
-    pub spec const SPEC_Call: u8 = 16;
-    pub spec const SPEC_CallIndirect: u8 = 17;
-    pub spec const SPEC_RefNull: u8 = 208;
-    pub spec const SPEC_RefIsNull: u8 = 209;
-    pub spec const SPEC_RefFunc: u8 = 210;
-    pub spec const SPEC_Drop: u8 = 26;
-    pub spec const SPEC_Select: u8 = 27;
-    pub spec const SPEC_SelectT: u8 = 28;
-    pub spec const SPEC_LocalGet: u8 = 32;
-    pub spec const SPEC_LocalSet: u8 = 33;
-    pub spec const SPEC_LocalTee: u8 = 34;
-    pub spec const SPEC_GlobalGet: u8 = 35;
-    pub spec const SPEC_GlobalSet: u8 = 36;
-    pub spec const SPEC_TableGet: u8 = 37;
-    pub spec const SPEC_TableSet: u8 = 38;
-    pub spec const SPEC_OpcodeFC: u8 = 252;
-    pub spec const SPEC_I32Load: u8 = 40;
-    pub spec const SPEC_I64Load: u8 = 41;
-    pub spec const SPEC_F32Load: u8 = 42;
-    pub spec const SPEC_F64Load: u8 = 43;
-    pub spec const SPEC_I32Load8S: u8 = 44;
-    pub spec const SPEC_I32Load8U: u8 = 45;
-    pub spec const SPEC_I32Load16S: u8 = 46;
-    pub spec const SPEC_I32Load16U: u8 = 47;
-    pub spec const SPEC_I64Load8S: u8 = 48;
-    pub spec const SPEC_I64Load8U: u8 = 49;
-    pub spec const SPEC_I64Load16S: u8 = 50;
-    pub spec const SPEC_I64Load16U: u8 = 51;
-    pub spec const SPEC_I64Load32S: u8 = 52;
-    pub spec const SPEC_I64Load32U: u8 = 53;
-    pub spec const SPEC_I32Store: u8 = 54;
-    pub spec const SPEC_I64Store: u8 = 55;
-    pub spec const SPEC_F32Store: u8 = 56;
-    pub spec const SPEC_F64Store: u8 = 57;
-    pub spec const SPEC_I32Store8: u8 = 58;
-    pub spec const SPEC_I32Store16: u8 = 59;
-    pub spec const SPEC_I64Store8: u8 = 60;
-    pub spec const SPEC_I64Store16: u8 = 61;
-    pub spec const SPEC_I64Store32: u8 = 62;
-    pub spec const SPEC_MemorySize: u8 = 63;
-    pub spec const SPEC_MemoryGrow: u8 = 64;
-    pub spec const SPEC_I32Const: u8 = 65;
-    pub spec const SPEC_I64Const: u8 = 66;
-    pub spec const SPEC_F32Const: u8 = 67;
-    pub spec const SPEC_F64Const: u8 = 68;
-    pub spec const SPEC_I32Eqz: u8 = 69;
-    pub spec const SPEC_I32Eq: u8 = 70;
-    pub spec const SPEC_I32Ne: u8 = 71;
-    pub spec const SPEC_I32LtS: u8 = 72;
-    pub spec const SPEC_I32LtU: u8 = 73;
-    pub spec const SPEC_I32GtS: u8 = 74;
-    pub spec const SPEC_I32GtU: u8 = 75;
-    pub spec const SPEC_I32LeS: u8 = 76;
-    pub spec const SPEC_I32LeU: u8 = 77;
-    pub spec const SPEC_I32GeS: u8 = 78;
-    pub spec const SPEC_I32GeU: u8 = 79;
-    pub spec const SPEC_I64Eqz: u8 = 80;
-    pub spec const SPEC_I64Eq: u8 = 81;
-    pub spec const SPEC_I64Ne: u8 = 82;
-    pub spec const SPEC_I64LtS: u8 = 83;
-    pub spec const SPEC_I64LtU: u8 = 84;
-    pub spec const SPEC_I64GtS: u8 = 85;
-    pub spec const SPEC_I64GtU: u8 = 86;
-    pub spec const SPEC_I64LeS: u8 = 87;
-    pub spec const SPEC_I64LeU: u8 = 88;
-    pub spec const SPEC_I64GeS: u8 = 89;
-    pub spec const SPEC_I64GeU: u8 = 90;
-    pub spec const SPEC_F32Eq: u8 = 91;
-    pub spec const SPEC_F32Ne: u8 = 92;
-    pub spec const SPEC_F32Lt: u8 = 93;
-    pub spec const SPEC_F32Gt: u8 = 94;
-    pub spec const SPEC_F32Le: u8 = 95;
-    pub spec const SPEC_F32Ge: u8 = 96;
-    pub spec const SPEC_F64Eq: u8 = 97;
-    pub spec const SPEC_F64Ne: u8 = 98;
-    pub spec const SPEC_F64Lt: u8 = 99;
-    pub spec const SPEC_F64Gt: u8 = 100;
-    pub spec const SPEC_F64Le: u8 = 101;
-    pub spec const SPEC_F64Ge: u8 = 102;
-    pub spec const SPEC_I32Clz: u8 = 103;
-    pub spec const SPEC_I32Ctz: u8 = 104;
-    pub spec const SPEC_I32Popcnt: u8 = 105;
-    pub spec const SPEC_I32Add: u8 = 106;
-    pub spec const SPEC_I32Sub: u8 = 107;
-    pub spec const SPEC_I32Mul: u8 = 108;
-    pub spec const SPEC_I32DivS: u8 = 109;
-    pub spec const SPEC_I32DivU: u8 = 110;
-    pub spec const SPEC_I32RemS: u8 = 111;
-    pub spec const SPEC_I32RemU: u8 = 112;
-    pub spec const SPEC_I32And: u8 = 113;
-    pub spec const SPEC_I32Or: u8 = 114;
-    pub spec const SPEC_I32Xor: u8 = 115;
-    pub spec const SPEC_I32Shl: u8 = 116;
-    pub spec const SPEC_I32ShrS: u8 = 117;
-    pub spec const SPEC_I32ShrU: u8 = 118;
-    pub spec const SPEC_I32Rotl: u8 = 119;
-    pub spec const SPEC_I32Rotr: u8 = 120;
-    pub spec const SPEC_I64Clz: u8 = 121;
-    pub spec const SPEC_I64Ctz: u8 = 122;
-    pub spec const SPEC_I64Popcnt: u8 = 123;
-    pub spec const SPEC_I64Add: u8 = 124;
-    pub spec const SPEC_I64Sub: u8 = 125;
-    pub spec const SPEC_I64Mul: u8 = 126;
-    pub spec const SPEC_I64DivS: u8 = 127;
-    pub spec const SPEC_I64DivU: u8 = 128;
-    pub spec const SPEC_I64RemS: u8 = 129;
-    pub spec const SPEC_I64RemU: u8 = 130;
-    pub spec const SPEC_I64And: u8 = 131;
-    pub spec const SPEC_I64Or: u8 = 132;
-    pub spec const SPEC_I64Xor: u8 = 133;
-    pub spec const SPEC_I64Shl: u8 = 134;
-    pub spec const SPEC_I64ShrS: u8 = 135;
-    pub spec const SPEC_I64ShrU: u8 = 136;
-    pub spec const SPEC_I64Rotl: u8 = 137;
-    pub spec const SPEC_I64Rotr: u8 = 138;
-    pub spec const SPEC_F32Abs: u8 = 139;
-    pub spec const SPEC_F32Neg: u8 = 140;
-    pub spec const SPEC_F32Ceil: u8 = 141;
-    pub spec const SPEC_F32Floor: u8 = 142;
-    pub spec const SPEC_F32Trunc: u8 = 143;
-    pub spec const SPEC_F32Nearest: u8 = 144;
-    pub spec const SPEC_F32Sqrt: u8 = 145;
-    pub spec const SPEC_F32Add: u8 = 146;
-    pub spec const SPEC_F32Sub: u8 = 147;
-    pub spec const SPEC_F32Mul: u8 = 148;
-    pub spec const SPEC_F32Div: u8 = 149;
-    pub spec const SPEC_F32Min: u8 = 150;
-    pub spec const SPEC_F32Max: u8 = 151;
-    pub spec const SPEC_F32Copysign: u8 = 152;
-    pub spec const SPEC_F64Abs: u8 = 153;
-    pub spec const SPEC_F64Neg: u8 = 154;
-    pub spec const SPEC_F64Ceil: u8 = 155;
-    pub spec const SPEC_F64Floor: u8 = 156;
-    pub spec const SPEC_F64Trunc: u8 = 157;
-    pub spec const SPEC_F64Nearest: u8 = 158;
-    pub spec const SPEC_F64Sqrt: u8 = 159;
-    pub spec const SPEC_F64Add: u8 = 160;
-    pub spec const SPEC_F64Sub: u8 = 161;
-    pub spec const SPEC_F64Mul: u8 = 162;
-    pub spec const SPEC_F64Div: u8 = 163;
-    pub spec const SPEC_F64Min: u8 = 164;
-    pub spec const SPEC_F64Max: u8 = 165;
-    pub spec const SPEC_F64Copysign: u8 = 166;
-    pub spec const SPEC_I32WrapI64: u8 = 167;
-    pub spec const SPEC_I32TruncF32S: u8 = 168;
-    pub spec const SPEC_I32TruncF32U: u8 = 169;
-    pub spec const SPEC_I32TruncF64S: u8 = 170;
-    pub spec const SPEC_I32TruncF64U: u8 = 171;
-    pub spec const SPEC_I64ExtendI32S: u8 = 172;
-    pub spec const SPEC_I64ExtendI32U: u8 = 173;
-    pub spec const SPEC_I64TruncF32S: u8 = 174;
-    pub spec const SPEC_I64TruncF32U: u8 = 175;
-    pub spec const SPEC_I64TruncF64S: u8 = 176;
-    pub spec const SPEC_I64TruncF64U: u8 = 177;
-    pub spec const SPEC_F32ConvertI32S: u8 = 178;
-    pub spec const SPEC_F32ConvertI32U: u8 = 179;
-    pub spec const SPEC_F32ConvertI64S: u8 = 180;
-    pub spec const SPEC_F32ConvertI64U: u8 = 181;
-    pub spec const SPEC_F32DemoteF64: u8 = 182;
-    pub spec const SPEC_F64ConvertI32S: u8 = 183;
-    pub spec const SPEC_F64ConvertI32U: u8 = 184;
-    pub spec const SPEC_F64ConvertI64S: u8 = 185;
-    pub spec const SPEC_F64ConvertI64U: u8 = 186;
-    pub spec const SPEC_F64PromoteF32: u8 = 187;
-    pub spec const SPEC_I32ReinterpretF32: u8 = 188;
-    pub spec const SPEC_I64ReinterpretF64: u8 = 189;
-    pub spec const SPEC_F32ReinterpretI32: u8 = 190;
-    pub spec const SPEC_F64ReinterpretI64: u8 = 191;
-    pub spec const SPEC_I32Extend8S: u8 = 192;
-    pub spec const SPEC_I32Extend16S: u8 = 193;
-    pub spec const SPEC_I64Extend8S: u8 = 194;
-    pub spec const SPEC_I64Extend16S: u8 = 195;
-    pub spec const SPEC_I64Extend32S: u8 = 196;
-    pub spec const SPEC_OpcodeFD: u8 = 253;
-    pub exec const Unreachable: u8 ensures Unreachable == SPEC_Unreachable { 0 }
-    pub exec const Nop: u8 ensures Nop == SPEC_Nop { 1 }
-    pub exec const Block: u8 ensures Block == SPEC_Block { 2 }
-    pub exec const Loop: u8 ensures Loop == SPEC_Loop { 3 }
-    pub exec const If: u8 ensures If == SPEC_If { 4 }
-    pub exec const Else: u8 ensures Else == SPEC_Else { 5 }
-    pub exec const End: u8 ensures End == SPEC_End { 11 }
-    pub exec const Br: u8 ensures Br == SPEC_Br { 12 }
-    pub exec const BrIf: u8 ensures BrIf == SPEC_BrIf { 13 }
-    pub exec const BrTable: u8 ensures BrTable == SPEC_BrTable { 14 }
-    pub exec const Ret: u8 ensures Ret == SPEC_Ret { 15 }
-    pub exec const Call: u8 ensures Call == SPEC_Call { 16 }
-    pub exec const CallIndirect: u8 ensures CallIndirect == SPEC_CallIndirect { 17 }
-    pub exec const RefNull: u8 ensures RefNull == SPEC_RefNull { 208 }
-    pub exec const RefIsNull: u8 ensures RefIsNull == SPEC_RefIsNull { 209 }
-    pub exec const RefFunc: u8 ensures RefFunc == SPEC_RefFunc { 210 }
-    pub exec const Drop: u8 ensures Drop == SPEC_Drop { 26 }
-    pub exec const Select: u8 ensures Select == SPEC_Select { 27 }
-    pub exec const SelectT: u8 ensures SelectT == SPEC_SelectT { 28 }
-    pub exec const LocalGet: u8 ensures LocalGet == SPEC_LocalGet { 32 }
-    pub exec const LocalSet: u8 ensures LocalSet == SPEC_LocalSet { 33 }
-    pub exec const LocalTee: u8 ensures LocalTee == SPEC_LocalTee { 34 }
-    pub exec const GlobalGet: u8 ensures GlobalGet == SPEC_GlobalGet { 35 }
-    pub exec const GlobalSet: u8 ensures GlobalSet == SPEC_GlobalSet { 36 }
-    pub exec const TableGet: u8 ensures TableGet == SPEC_TableGet { 37 }
-    pub exec const TableSet: u8 ensures TableSet == SPEC_TableSet { 38 }
-    pub exec const OpcodeFC: u8 ensures OpcodeFC == SPEC_OpcodeFC { 252 }
-    pub exec const I32Load: u8 ensures I32Load == SPEC_I32Load { 40 }
-    pub exec const I64Load: u8 ensures I64Load == SPEC_I64Load { 41 }
-    pub exec const F32Load: u8 ensures F32Load == SPEC_F32Load { 42 }
-    pub exec const F64Load: u8 ensures F64Load == SPEC_F64Load { 43 }
-    pub exec const I32Load8S: u8 ensures I32Load8S == SPEC_I32Load8S { 44 }
-    pub exec const I32Load8U: u8 ensures I32Load8U == SPEC_I32Load8U { 45 }
-    pub exec const I32Load16S: u8 ensures I32Load16S == SPEC_I32Load16S { 46 }
-    pub exec const I32Load16U: u8 ensures I32Load16U == SPEC_I32Load16U { 47 }
-    pub exec const I64Load8S: u8 ensures I64Load8S == SPEC_I64Load8S { 48 }
-    pub exec const I64Load8U: u8 ensures I64Load8U == SPEC_I64Load8U { 49 }
-    pub exec const I64Load16S: u8 ensures I64Load16S == SPEC_I64Load16S { 50 }
-    pub exec const I64Load16U: u8 ensures I64Load16U == SPEC_I64Load16U { 51 }
-    pub exec const I64Load32S: u8 ensures I64Load32S == SPEC_I64Load32S { 52 }
-    pub exec const I64Load32U: u8 ensures I64Load32U == SPEC_I64Load32U { 53 }
-    pub exec const I32Store: u8 ensures I32Store == SPEC_I32Store { 54 }
-    pub exec const I64Store: u8 ensures I64Store == SPEC_I64Store { 55 }
-    pub exec const F32Store: u8 ensures F32Store == SPEC_F32Store { 56 }
-    pub exec const F64Store: u8 ensures F64Store == SPEC_F64Store { 57 }
-    pub exec const I32Store8: u8 ensures I32Store8 == SPEC_I32Store8 { 58 }
-    pub exec const I32Store16: u8 ensures I32Store16 == SPEC_I32Store16 { 59 }
-    pub exec const I64Store8: u8 ensures I64Store8 == SPEC_I64Store8 { 60 }
-    pub exec const I64Store16: u8 ensures I64Store16 == SPEC_I64Store16 { 61 }
-    pub exec const I64Store32: u8 ensures I64Store32 == SPEC_I64Store32 { 62 }
-    pub exec const MemorySize: u8 ensures MemorySize == SPEC_MemorySize { 63 }
-    pub exec const MemoryGrow: u8 ensures MemoryGrow == SPEC_MemoryGrow { 64 }
-    pub exec const I32Const: u8 ensures I32Const == SPEC_I32Const { 65 }
-    pub exec const I64Const: u8 ensures I64Const == SPEC_I64Const { 66 }
-    pub exec const F32Const: u8 ensures F32Const == SPEC_F32Const { 67 }
-    pub exec const F64Const: u8 ensures F64Const == SPEC_F64Const { 68 }
-    pub exec const I32Eqz: u8 ensures I32Eqz == SPEC_I32Eqz { 69 }
-    pub exec const I32Eq: u8 ensures I32Eq == SPEC_I32Eq { 70 }
-    pub exec const I32Ne: u8 ensures I32Ne == SPEC_I32Ne { 71 }
-    pub exec const I32LtS: u8 ensures I32LtS == SPEC_I32LtS { 72 }
-    pub exec const I32LtU: u8 ensures I32LtU == SPEC_I32LtU { 73 }
-    pub exec const I32GtS: u8 ensures I32GtS == SPEC_I32GtS { 74 }
-    pub exec const I32GtU: u8 ensures I32GtU == SPEC_I32GtU { 75 }
-    pub exec const I32LeS: u8 ensures I32LeS == SPEC_I32LeS { 76 }
-    pub exec const I32LeU: u8 ensures I32LeU == SPEC_I32LeU { 77 }
-    pub exec const I32GeS: u8 ensures I32GeS == SPEC_I32GeS { 78 }
-    pub exec const I32GeU: u8 ensures I32GeU == SPEC_I32GeU { 79 }
-    pub exec const I64Eqz: u8 ensures I64Eqz == SPEC_I64Eqz { 80 }
-    pub exec const I64Eq: u8 ensures I64Eq == SPEC_I64Eq { 81 }
-    pub exec const I64Ne: u8 ensures I64Ne == SPEC_I64Ne { 82 }
-    pub exec const I64LtS: u8 ensures I64LtS == SPEC_I64LtS { 83 }
-    pub exec const I64LtU: u8 ensures I64LtU == SPEC_I64LtU { 84 }
-    pub exec const I64GtS: u8 ensures I64GtS == SPEC_I64GtS { 85 }
-    pub exec const I64GtU: u8 ensures I64GtU == SPEC_I64GtU { 86 }
-    pub exec const I64LeS: u8 ensures I64LeS == SPEC_I64LeS { 87 }
-    pub exec const I64LeU: u8 ensures I64LeU == SPEC_I64LeU { 88 }
-    pub exec const I64GeS: u8 ensures I64GeS == SPEC_I64GeS { 89 }
-    pub exec const I64GeU: u8 ensures I64GeU == SPEC_I64GeU { 90 }
-    pub exec const F32Eq: u8 ensures F32Eq == SPEC_F32Eq { 91 }
-    pub exec const F32Ne: u8 ensures F32Ne == SPEC_F32Ne { 92 }
-    pub exec const F32Lt: u8 ensures F32Lt == SPEC_F32Lt { 93 }
-    pub exec const F32Gt: u8 ensures F32Gt == SPEC_F32Gt { 94 }
-    pub exec const F32Le: u8 ensures F32Le == SPEC_F32Le { 95 }
-    pub exec const F32Ge: u8 ensures F32Ge == SPEC_F32Ge { 96 }
-    pub exec const F64Eq: u8 ensures F64Eq == SPEC_F64Eq { 97 }
-    pub exec const F64Ne: u8 ensures F64Ne == SPEC_F64Ne { 98 }
-    pub exec const F64Lt: u8 ensures F64Lt == SPEC_F64Lt { 99 }
-    pub exec const F64Gt: u8 ensures F64Gt == SPEC_F64Gt { 100 }
-    pub exec const F64Le: u8 ensures F64Le == SPEC_F64Le { 101 }
-    pub exec const F64Ge: u8 ensures F64Ge == SPEC_F64Ge { 102 }
-    pub exec const I32Clz: u8 ensures I32Clz == SPEC_I32Clz { 103 }
-    pub exec const I32Ctz: u8 ensures I32Ctz == SPEC_I32Ctz { 104 }
-    pub exec const I32Popcnt: u8 ensures I32Popcnt == SPEC_I32Popcnt { 105 }
-    pub exec const I32Add: u8 ensures I32Add == SPEC_I32Add { 106 }
-    pub exec const I32Sub: u8 ensures I32Sub == SPEC_I32Sub { 107 }
-    pub exec const I32Mul: u8 ensures I32Mul == SPEC_I32Mul { 108 }
-    pub exec const I32DivS: u8 ensures I32DivS == SPEC_I32DivS { 109 }
-    pub exec const I32DivU: u8 ensures I32DivU == SPEC_I32DivU { 110 }
-    pub exec const I32RemS: u8 ensures I32RemS == SPEC_I32RemS { 111 }
-    pub exec const I32RemU: u8 ensures I32RemU == SPEC_I32RemU { 112 }
-    pub exec const I32And: u8 ensures I32And == SPEC_I32And { 113 }
-    pub exec const I32Or: u8 ensures I32Or == SPEC_I32Or { 114 }
-    pub exec const I32Xor: u8 ensures I32Xor == SPEC_I32Xor { 115 }
-    pub exec const I32Shl: u8 ensures I32Shl == SPEC_I32Shl { 116 }
-    pub exec const I32ShrS: u8 ensures I32ShrS == SPEC_I32ShrS { 117 }
-    pub exec const I32ShrU: u8 ensures I32ShrU == SPEC_I32ShrU { 118 }
-    pub exec const I32Rotl: u8 ensures I32Rotl == SPEC_I32Rotl { 119 }
-    pub exec const I32Rotr: u8 ensures I32Rotr == SPEC_I32Rotr { 120 }
-    pub exec const I64Clz: u8 ensures I64Clz == SPEC_I64Clz { 121 }
-    pub exec const I64Ctz: u8 ensures I64Ctz == SPEC_I64Ctz { 122 }
-    pub exec const I64Popcnt: u8 ensures I64Popcnt == SPEC_I64Popcnt { 123 }
-    pub exec const I64Add: u8 ensures I64Add == SPEC_I64Add { 124 }
-    pub exec const I64Sub: u8 ensures I64Sub == SPEC_I64Sub { 125 }
-    pub exec const I64Mul: u8 ensures I64Mul == SPEC_I64Mul { 126 }
-    pub exec const I64DivS: u8 ensures I64DivS == SPEC_I64DivS { 127 }
-    pub exec const I64DivU: u8 ensures I64DivU == SPEC_I64DivU { 128 }
-    pub exec const I64RemS: u8 ensures I64RemS == SPEC_I64RemS { 129 }
-    pub exec const I64RemU: u8 ensures I64RemU == SPEC_I64RemU { 130 }
-    pub exec const I64And: u8 ensures I64And == SPEC_I64And { 131 }
-    pub exec const I64Or: u8 ensures I64Or == SPEC_I64Or { 132 }
-    pub exec const I64Xor: u8 ensures I64Xor == SPEC_I64Xor { 133 }
-    pub exec const I64Shl: u8 ensures I64Shl == SPEC_I64Shl { 134 }
-    pub exec const I64ShrS: u8 ensures I64ShrS == SPEC_I64ShrS { 135 }
-    pub exec const I64ShrU: u8 ensures I64ShrU == SPEC_I64ShrU { 136 }
-    pub exec const I64Rotl: u8 ensures I64Rotl == SPEC_I64Rotl { 137 }
-    pub exec const I64Rotr: u8 ensures I64Rotr == SPEC_I64Rotr { 138 }
-    pub exec const F32Abs: u8 ensures F32Abs == SPEC_F32Abs { 139 }
-    pub exec const F32Neg: u8 ensures F32Neg == SPEC_F32Neg { 140 }
-    pub exec const F32Ceil: u8 ensures F32Ceil == SPEC_F32Ceil { 141 }
-    pub exec const F32Floor: u8 ensures F32Floor == SPEC_F32Floor { 142 }
-    pub exec const F32Trunc: u8 ensures F32Trunc == SPEC_F32Trunc { 143 }
-    pub exec const F32Nearest: u8 ensures F32Nearest == SPEC_F32Nearest { 144 }
-    pub exec const F32Sqrt: u8 ensures F32Sqrt == SPEC_F32Sqrt { 145 }
-    pub exec const F32Add: u8 ensures F32Add == SPEC_F32Add { 146 }
-    pub exec const F32Sub: u8 ensures F32Sub == SPEC_F32Sub { 147 }
-    pub exec const F32Mul: u8 ensures F32Mul == SPEC_F32Mul { 148 }
-    pub exec const F32Div: u8 ensures F32Div == SPEC_F32Div { 149 }
-    pub exec const F32Min: u8 ensures F32Min == SPEC_F32Min { 150 }
-    pub exec const F32Max: u8 ensures F32Max == SPEC_F32Max { 151 }
-    pub exec const F32Copysign: u8 ensures F32Copysign == SPEC_F32Copysign { 152 }
-    pub exec const F64Abs: u8 ensures F64Abs == SPEC_F64Abs { 153 }
-    pub exec const F64Neg: u8 ensures F64Neg == SPEC_F64Neg { 154 }
-    pub exec const F64Ceil: u8 ensures F64Ceil == SPEC_F64Ceil { 155 }
-    pub exec const F64Floor: u8 ensures F64Floor == SPEC_F64Floor { 156 }
-    pub exec const F64Trunc: u8 ensures F64Trunc == SPEC_F64Trunc { 157 }
-    pub exec const F64Nearest: u8 ensures F64Nearest == SPEC_F64Nearest { 158 }
-    pub exec const F64Sqrt: u8 ensures F64Sqrt == SPEC_F64Sqrt { 159 }
-    pub exec const F64Add: u8 ensures F64Add == SPEC_F64Add { 160 }
-    pub exec const F64Sub: u8 ensures F64Sub == SPEC_F64Sub { 161 }
-    pub exec const F64Mul: u8 ensures F64Mul == SPEC_F64Mul { 162 }
-    pub exec const F64Div: u8 ensures F64Div == SPEC_F64Div { 163 }
-    pub exec const F64Min: u8 ensures F64Min == SPEC_F64Min { 164 }
-    pub exec const F64Max: u8 ensures F64Max == SPEC_F64Max { 165 }
-    pub exec const F64Copysign: u8 ensures F64Copysign == SPEC_F64Copysign { 166 }
-    pub exec const I32WrapI64: u8 ensures I32WrapI64 == SPEC_I32WrapI64 { 167 }
-    pub exec const I32TruncF32S: u8 ensures I32TruncF32S == SPEC_I32TruncF32S { 168 }
-    pub exec const I32TruncF32U: u8 ensures I32TruncF32U == SPEC_I32TruncF32U { 169 }
-    pub exec const I32TruncF64S: u8 ensures I32TruncF64S == SPEC_I32TruncF64S { 170 }
-    pub exec const I32TruncF64U: u8 ensures I32TruncF64U == SPEC_I32TruncF64U { 171 }
-    pub exec const I64ExtendI32S: u8 ensures I64ExtendI32S == SPEC_I64ExtendI32S { 172 }
-    pub exec const I64ExtendI32U: u8 ensures I64ExtendI32U == SPEC_I64ExtendI32U { 173 }
-    pub exec const I64TruncF32S: u8 ensures I64TruncF32S == SPEC_I64TruncF32S { 174 }
-    pub exec const I64TruncF32U: u8 ensures I64TruncF32U == SPEC_I64TruncF32U { 175 }
-    pub exec const I64TruncF64S: u8 ensures I64TruncF64S == SPEC_I64TruncF64S { 176 }
-    pub exec const I64TruncF64U: u8 ensures I64TruncF64U == SPEC_I64TruncF64U { 177 }
-    pub exec const F32ConvertI32S: u8 ensures F32ConvertI32S == SPEC_F32ConvertI32S { 178 }
-    pub exec const F32ConvertI32U: u8 ensures F32ConvertI32U == SPEC_F32ConvertI32U { 179 }
-    pub exec const F32ConvertI64S: u8 ensures F32ConvertI64S == SPEC_F32ConvertI64S { 180 }
-    pub exec const F32ConvertI64U: u8 ensures F32ConvertI64U == SPEC_F32ConvertI64U { 181 }
-    pub exec const F32DemoteF64: u8 ensures F32DemoteF64 == SPEC_F32DemoteF64 { 182 }
-    pub exec const F64ConvertI32S: u8 ensures F64ConvertI32S == SPEC_F64ConvertI32S { 183 }
-    pub exec const F64ConvertI32U: u8 ensures F64ConvertI32U == SPEC_F64ConvertI32U { 184 }
-    pub exec const F64ConvertI64S: u8 ensures F64ConvertI64S == SPEC_F64ConvertI64S { 185 }
-    pub exec const F64ConvertI64U: u8 ensures F64ConvertI64U == SPEC_F64ConvertI64U { 186 }
-    pub exec const F64PromoteF32: u8 ensures F64PromoteF32 == SPEC_F64PromoteF32 { 187 }
-    pub exec const I32ReinterpretF32: u8 ensures I32ReinterpretF32 == SPEC_I32ReinterpretF32 { 188 }
-    pub exec const I64ReinterpretF64: u8 ensures I64ReinterpretF64 == SPEC_I64ReinterpretF64 { 189 }
-    pub exec const F32ReinterpretI32: u8 ensures F32ReinterpretI32 == SPEC_F32ReinterpretI32 { 190 }
-    pub exec const F64ReinterpretI64: u8 ensures F64ReinterpretI64 == SPEC_F64ReinterpretI64 { 191 }
-    pub exec const I32Extend8S: u8 ensures I32Extend8S == SPEC_I32Extend8S { 192 }
-    pub exec const I32Extend16S: u8 ensures I32Extend16S == SPEC_I32Extend16S { 193 }
-    pub exec const I64Extend8S: u8 ensures I64Extend8S == SPEC_I64Extend8S { 194 }
-    pub exec const I64Extend16S: u8 ensures I64Extend16S == SPEC_I64Extend16S { 195 }
-    pub exec const I64Extend32S: u8 ensures I64Extend32S == SPEC_I64Extend32S { 196 }
-    pub exec const OpcodeFD: u8 ensures OpcodeFD == SPEC_OpcodeFD { 253 }
-}
-
 
-pub struct SpecInstrBytecodeCombinator(pub SpecInstrBytecodeCombinatorAlias);
+pub spec const SPEC_Numtype_I32: u8 = 127;
+pub spec const SPEC_Numtype_I64: u8 = 126;
+pub spec const SPEC_Numtype_F32: u8 = 125;
+pub spec const SPEC_Numtype_F64: u8 = 124;
+pub exec static EXEC_Numtype_I32: u8 ensures EXEC_Numtype_I32 == SPEC_Numtype_I32 { 127 }
+pub exec static EXEC_Numtype_I64: u8 ensures EXEC_Numtype_I64 == SPEC_Numtype_I64 { 126 }
+pub exec static EXEC_Numtype_F32: u8 ensures EXEC_Numtype_F32 == SPEC_Numtype_F32 { 125 }
+pub exec static EXEC_Numtype_F64: u8 ensures EXEC_Numtype_F64 == SPEC_Numtype_F64 { 124 }
 
-impl SpecCombinator for SpecInstrBytecodeCombinator {
-    type Type = u8;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecInstrBytecodeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecInstrBytecodeCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Numtype {
+    I32 = 127,
+I64 = 126,
+F32 = 125,
+F64 = 124
 }
-pub type SpecInstrBytecodeCombinatorAlias = U8;
+pub type SpecNumtype = Numtype;
 
-pub struct InstrBytecodeCombinator(pub InstrBytecodeCombinatorAlias);
+pub type NumtypeInner = u8;
 
-impl View for InstrBytecodeCombinator {
-    type V = SpecInstrBytecodeCombinator;
-    open spec fn view(&self) -> Self::V { SpecInstrBytecodeCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrBytecodeCombinator {
-    type Type = u8;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type InstrBytecodeCombinatorAlias = U8;
+pub type NumtypeInnerRef<'a> = &'a u8;
 
+impl View for Numtype {
+    type V = Self;
 
-pub open spec fn spec_instr_bytecode() -> SpecInstrBytecodeCombinator {
-    SpecInstrBytecodeCombinator(U8)
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
 }
 
-                
-pub fn instr_bytecode<'a>() -> (o: InstrBytecodeCombinator)
-    ensures o@ == spec_instr_bytecode(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = InstrBytecodeCombinator(U8);
-    assert({
-        &&& combinator@ == spec_instr_bytecode()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
+impl SpecTryFrom<NumtypeInner> for Numtype {
+    type Error = ();
+
+    open spec fn spec_try_from(v: NumtypeInner) -> Result<Numtype, ()> {
+        match v {
+            127u8 => Ok(Numtype::I32),
+            126u8 => Ok(Numtype::I64),
+            125u8 => Ok(Numtype::F32),
+            124u8 => Ok(Numtype::F64),
+            _ => Err(()),
+        }
+    }
 }
 
-pub fn parse_instr_bytecode<'a>(input: &'a [u8]) -> (res: PResult<<InstrBytecodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_instr_bytecode().spec_parse(input@) == Some((n as int, v@)),
-        spec_instr_bytecode().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_instr_bytecode().spec_parse(input@) is None,
-        spec_instr_bytecode().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = instr_bytecode();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+impl SpecTryFrom<Numtype> for NumtypeInner {
+    type Error = ();
+
+    open spec fn spec_try_from(v: Numtype) -> Result<NumtypeInner, ()> {
+        match v {
+            Numtype::I32 => Ok(SPEC_Numtype_I32),
+            Numtype::I64 => Ok(SPEC_Numtype_I64),
+            Numtype::F32 => Ok(SPEC_Numtype_F32),
+            Numtype::F64 => Ok(SPEC_Numtype_F64),
+        }
+    }
 }
 
-pub fn serialize_instr_bytecode<'a>(v: <InstrBytecodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_instr_bytecode().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_instr_bytecode().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_instr_bytecode().spec_serialize(v@))
-        },
-{
-    let combinator = instr_bytecode();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+impl TryFrom<NumtypeInner> for Numtype {
+    type Error = ();
+
+    fn ex_try_from(v: NumtypeInner) -> Result<Numtype, ()> {
+        match v {
+            127u8 => Ok(Numtype::I32),
+            126u8 => Ok(Numtype::I64),
+            125u8 => Ok(Numtype::F32),
+            124u8 => Ok(Numtype::F64),
+            _ => Err(()),
+        }
+    }
 }
 
-pub fn instr_bytecode_len<'a>(v: <InstrBytecodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_instr_bytecode().wf(v@),
-        spec_instr_bytecode().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_instr_bytecode().spec_serialize(v@).len(),
-{
-    let combinator = instr_bytecode();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+impl<'a> TryFrom<&'a Numtype> for NumtypeInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a Numtype) -> Result<NumtypeInnerRef<'a>, ()> {
+        match v {
+            Numtype::I32 => Ok(&EXEC_Numtype_I32),
+            Numtype::I64 => Ok(&EXEC_Numtype_I64),
+            Numtype::F32 => Ok(&EXEC_Numtype_F32),
+            Numtype::F64 => Ok(&EXEC_Numtype_F64),
+        }
+    }
 }
 
-                
-pub type SpecGlobalidx = u64;
-pub type Globalidx = u64;
-pub type GlobalidxRef<'a> = &'a u64;
+pub struct NumtypeMapper;
+
+impl View for NumtypeMapper {
+    type V = Self;
 
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
 
-pub struct SpecGlobalidxCombinator(pub SpecGlobalidxCombinatorAlias);
+impl SpecPartialIso for NumtypeMapper {
+    type Src = NumtypeInner;
+    type Dst = Numtype;
+}
 
-impl SpecCombinator for SpecGlobalidxCombinator {
-    type Type = SpecGlobalidx;
+impl SpecPartialIsoProof for NumtypeMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+}
+
+impl<'a> PartialIso<'a> for NumtypeMapper {
+    type Src = NumtypeInner;
+    type Dst = Numtype;
+    type RefSrc = NumtypeInnerRef<'a>;
+}
+
+
+pub struct SpecNumtypeCombinator(pub SpecNumtypeCombinatorAlias);
+
+impl SpecCombinator for SpecNumtypeCombinator {
+    type Type = SpecNumtype;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecGlobalidxCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecGlobalidxCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecNumtypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNumtypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecGlobalidxCombinatorAlias = UnsignedLEB128;
+pub type SpecNumtypeCombinatorAlias = TryMap<U8, NumtypeMapper>;
 
-pub struct GlobalidxCombinator(pub GlobalidxCombinatorAlias);
+pub struct NumtypeCombinator(pub NumtypeCombinatorAlias);
 
-impl View for GlobalidxCombinator {
-    type V = SpecGlobalidxCombinator;
-    open spec fn view(&self) -> Self::V { SpecGlobalidxCombinator(self.0@) }
+impl View for NumtypeCombinator {
+    type V = SpecNumtypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecNumtypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GlobalidxCombinator {
-    type Type = Globalidx;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NumtypeCombinator {
+    type Type = Numtype;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type GlobalidxCombinatorAlias = UnsignedLEB128;
+}
+pub type NumtypeCombinatorAlias = TryMap<U8, NumtypeMapper>;
 
 
-pub open spec fn spec_globalidx() -> SpecGlobalidxCombinator {
-    SpecGlobalidxCombinator(UnsignedLEB128)
+pub open spec fn spec_numtype() -> SpecNumtypeCombinator {
+    SpecNumtypeCombinator(TryMap { inner: U8, mapper: NumtypeMapper })
 }
 
                 
-pub fn globalidx<'a>() -> (o: GlobalidxCombinator)
-    ensures o@ == spec_globalidx(),
+pub fn numtype<'a>() -> (o: NumtypeCombinator)
+    ensures o@ == spec_numtype(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = GlobalidxCombinator(UnsignedLEB128);
-    assert({
-        &&& combinator@ == spec_globalidx()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = NumtypeCombinator(TryMap { inner: U8, mapper: NumtypeMapper });
+    // assert({
+    //     &&& combinator@ == spec_numtype()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_globalidx<'a>(input: &'a [u8]) -> (res: PResult<<GlobalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_numtype<'a>(input: &'a [u8]) -> (res: PResult<<NumtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_globalidx().spec_parse(input@) == Some((n as int, v@)),
-        spec_globalidx().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_numtype().spec_parse(input@) == Some((n as int, v@)),
+        spec_numtype().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_globalidx().spec_parse(input@) is None,
-        spec_globalidx().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_numtype().spec_parse(input@) is None,
+        spec_numtype().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = globalidx();
+    let combinator = numtype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_globalidx<'a>(v: <GlobalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_numtype<'a>(v: <NumtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_globalidx().wf(v@),
+        spec_numtype().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_globalidx().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_globalidx().spec_serialize(v@))
+            &&& n == spec_numtype().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_numtype().spec_serialize(v@))
         },
 {
-    let combinator = globalidx();
+    let combinator = numtype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn globalidx_len<'a>(v: <GlobalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn numtype_len<'a>(v: <NumtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_globalidx().wf(v@),
-        spec_globalidx().spec_serialize(v@).len() <= usize::MAX,
+        spec_numtype().wf(v@),
+        spec_numtype().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_globalidx().spec_serialize(v@).len(),
+        serialize_len == spec_numtype().spec_serialize(v@).len(),
 {
-    let combinator = globalidx();
+    let combinator = numtype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub enum SpecInstrVariable {
-    LocalGet(SpecLocalidx),
-    LocalSet(SpecLocalidx),
-    LocalTee(SpecLocalidx),
-    GlobalGet(SpecGlobalidx),
-    GlobalSet(SpecGlobalidx),
+pub spec const SPEC_Vectype_V128: u8 = 123;
+pub exec static EXEC_Vectype_V128: u8 ensures EXEC_Vectype_V128 == SPEC_Vectype_V128 { 123 }
+
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Vectype {
+    V128 = 123
 }
+pub type SpecVectype = Vectype;
 
-pub type SpecInstrVariableInner = Either<SpecLocalidx, Either<SpecLocalidx, Either<SpecLocalidx, Either<SpecGlobalidx, SpecGlobalidx>>>>;
+pub type VectypeInner = u8;
 
-impl SpecFrom<SpecInstrVariable> for SpecInstrVariableInner {
-    open spec fn spec_from(m: SpecInstrVariable) -> SpecInstrVariableInner {
-        match m {
-            SpecInstrVariable::LocalGet(m) => Either::Left(m),
-            SpecInstrVariable::LocalSet(m) => Either::Right(Either::Left(m)),
-            SpecInstrVariable::LocalTee(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecInstrVariable::GlobalGet(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            SpecInstrVariable::GlobalSet(m) => Either::Right(Either::Right(Either::Right(Either::Right(m)))),
-        }
-    }
+pub type VectypeInnerRef<'a> = &'a u8;
+
+impl View for Vectype {
+    type V = Self;
 
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
 }
 
-                
-impl SpecFrom<SpecInstrVariableInner> for SpecInstrVariable {
-    open spec fn spec_from(m: SpecInstrVariableInner) -> SpecInstrVariable {
-        match m {
-            Either::Left(m) => SpecInstrVariable::LocalGet(m),
-            Either::Right(Either::Left(m)) => SpecInstrVariable::LocalSet(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecInstrVariable::LocalTee(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecInstrVariable::GlobalGet(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(m)))) => SpecInstrVariable::GlobalSet(m),
+impl SpecTryFrom<VectypeInner> for Vectype {
+    type Error = ();
+
+    open spec fn spec_try_from(v: VectypeInner) -> Result<Vectype, ()> {
+        match v {
+            123u8 => Ok(Vectype::V128),
+            _ => Err(()),
         }
     }
-
 }
 
+impl SpecTryFrom<Vectype> for VectypeInner {
+    type Error = ();
 
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum InstrVariable {
-    LocalGet(Localidx),
-    LocalSet(Localidx),
-    LocalTee(Localidx),
-    GlobalGet(Globalidx),
-    GlobalSet(Globalidx),
-}
-
-pub type InstrVariableInner = Either<Localidx, Either<Localidx, Either<Localidx, Either<Globalidx, Globalidx>>>>;
-
-pub type InstrVariableInnerRef<'a> = Either<&'a Localidx, Either<&'a Localidx, Either<&'a Localidx, Either<&'a Globalidx, &'a Globalidx>>>>;
-
-
-impl View for InstrVariable {
-    type V = SpecInstrVariable;
-    open spec fn view(&self) -> Self::V {
-        match self {
-            InstrVariable::LocalGet(m) => SpecInstrVariable::LocalGet(m@),
-            InstrVariable::LocalSet(m) => SpecInstrVariable::LocalSet(m@),
-            InstrVariable::LocalTee(m) => SpecInstrVariable::LocalTee(m@),
-            InstrVariable::GlobalGet(m) => SpecInstrVariable::GlobalGet(m@),
-            InstrVariable::GlobalSet(m) => SpecInstrVariable::GlobalSet(m@),
+    open spec fn spec_try_from(v: Vectype) -> Result<VectypeInner, ()> {
+        match v {
+            Vectype::V128 => Ok(SPEC_Vectype_V128),
         }
     }
 }
 
+impl TryFrom<VectypeInner> for Vectype {
+    type Error = ();
 
-impl<'a> From<&'a InstrVariable> for InstrVariableInnerRef<'a> {
-    fn ex_from(m: &'a InstrVariable) -> InstrVariableInnerRef<'a> {
-        match m {
-            InstrVariable::LocalGet(m) => Either::Left(m),
-            InstrVariable::LocalSet(m) => Either::Right(Either::Left(m)),
-            InstrVariable::LocalTee(m) => Either::Right(Either::Right(Either::Left(m))),
-            InstrVariable::GlobalGet(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            InstrVariable::GlobalSet(m) => Either::Right(Either::Right(Either::Right(Either::Right(m)))),
+    fn ex_try_from(v: VectypeInner) -> Result<Vectype, ()> {
+        match v {
+            123u8 => Ok(Vectype::V128),
+            _ => Err(()),
         }
     }
-
 }
 
-impl From<InstrVariableInner> for InstrVariable {
-    fn ex_from(m: InstrVariableInner) -> InstrVariable {
-        match m {
-            Either::Left(m) => InstrVariable::LocalGet(m),
-            Either::Right(Either::Left(m)) => InstrVariable::LocalSet(m),
-            Either::Right(Either::Right(Either::Left(m))) => InstrVariable::LocalTee(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => InstrVariable::GlobalGet(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(m)))) => InstrVariable::GlobalSet(m),
+impl<'a> TryFrom<&'a Vectype> for VectypeInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a Vectype) -> Result<VectypeInnerRef<'a>, ()> {
+        match v {
+            Vectype::V128 => Ok(&EXEC_Vectype_V128),
         }
     }
-    
 }
 
+pub struct VectypeMapper;
 
-pub struct InstrVariableMapper;
-impl View for InstrVariableMapper {
+impl View for VectypeMapper {
     type V = Self;
+
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for InstrVariableMapper {
-    type Src = SpecInstrVariableInner;
-    type Dst = SpecInstrVariable;
+
+impl SpecPartialIso for VectypeMapper {
+    type Src = VectypeInner;
+    type Dst = Vectype;
 }
-impl SpecIsoProof for InstrVariableMapper {
+
+impl SpecPartialIsoProof for VectypeMapper {
     proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
     }
+
     proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
     }
 }
-impl<'a> Iso<'a> for InstrVariableMapper {
-    type Src = InstrVariableInner;
-    type Dst = InstrVariable;
-    type RefSrc = InstrVariableInnerRef<'a>;
+
+impl<'a> PartialIso<'a> for VectypeMapper {
+    type Src = VectypeInner;
+    type Dst = Vectype;
+    type RefSrc = VectypeInnerRef<'a>;
 }
 
-type SpecInstrVariableCombinatorAlias1 = Choice<Cond<SpecGlobalidxCombinator>, Cond<SpecGlobalidxCombinator>>;
-type SpecInstrVariableCombinatorAlias2 = Choice<Cond<SpecLocalidxCombinator>, SpecInstrVariableCombinatorAlias1>;
-type SpecInstrVariableCombinatorAlias3 = Choice<Cond<SpecLocalidxCombinator>, SpecInstrVariableCombinatorAlias2>;
-type SpecInstrVariableCombinatorAlias4 = Choice<Cond<SpecLocalidxCombinator>, SpecInstrVariableCombinatorAlias3>;
-pub struct SpecInstrVariableCombinator(pub SpecInstrVariableCombinatorAlias);
 
-impl SpecCombinator for SpecInstrVariableCombinator {
-    type Type = SpecInstrVariable;
+pub struct SpecVectypeCombinator(pub SpecVectypeCombinatorAlias);
+
+impl SpecCombinator for SpecVectypeCombinator {
+    type Type = SpecVectype;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecInstrVariableCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecInstrVariableCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecVectypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecVectypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecInstrVariableCombinatorAlias = Mapped<SpecInstrVariableCombinatorAlias4, InstrVariableMapper>;
-type InstrVariableCombinatorAlias1 = Choice<Cond<GlobalidxCombinator>, Cond<GlobalidxCombinator>>;
-type InstrVariableCombinatorAlias2 = Choice<Cond<LocalidxCombinator>, InstrVariableCombinator1>;
-type InstrVariableCombinatorAlias3 = Choice<Cond<LocalidxCombinator>, InstrVariableCombinator2>;
-type InstrVariableCombinatorAlias4 = Choice<Cond<LocalidxCombinator>, InstrVariableCombinator3>;
-pub struct InstrVariableCombinator1(pub InstrVariableCombinatorAlias1);
-impl View for InstrVariableCombinator1 {
-    type V = SpecInstrVariableCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(InstrVariableCombinator1, InstrVariableCombinatorAlias1);
-
-pub struct InstrVariableCombinator2(pub InstrVariableCombinatorAlias2);
-impl View for InstrVariableCombinator2 {
-    type V = SpecInstrVariableCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(InstrVariableCombinator2, InstrVariableCombinatorAlias2);
-
-pub struct InstrVariableCombinator3(pub InstrVariableCombinatorAlias3);
-impl View for InstrVariableCombinator3 {
-    type V = SpecInstrVariableCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(InstrVariableCombinator3, InstrVariableCombinatorAlias3);
-
-pub struct InstrVariableCombinator4(pub InstrVariableCombinatorAlias4);
-impl View for InstrVariableCombinator4 {
-    type V = SpecInstrVariableCombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(InstrVariableCombinator4, InstrVariableCombinatorAlias4);
+pub type SpecVectypeCombinatorAlias = TryMap<U8, VectypeMapper>;
 
-pub struct InstrVariableCombinator(pub InstrVariableCombinatorAlias);
+pub struct VectypeCombinator(pub VectypeCombinatorAlias);
 
-impl View for InstrVariableCombinator {
-    type V = SpecInstrVariableCombinator;
-    open spec fn view(&self) -> Self::V { SpecInstrVariableCombinator(self.0@) }
+impl View for VectypeCombinator {
+    type V = SpecVectypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecVectypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrVariableCombinator {
-    type Type = InstrVariable;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for VectypeCombinator {
+    type Type = Vectype;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type InstrVariableCombinatorAlias = Mapped<InstrVariableCombinator4, InstrVariableMapper>;
+}
+pub type VectypeCombinatorAlias = TryMap<U8, VectypeMapper>;
 
 
-pub open spec fn spec_instr_variable(opcode: u8) -> SpecInstrVariableCombinator {
-    SpecInstrVariableCombinator(Mapped { inner: Choice(Cond { cond: opcode == InstrBytecode::SPEC_LocalGet, inner: spec_localidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_LocalSet, inner: spec_localidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_LocalTee, inner: spec_localidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_GlobalGet, inner: spec_globalidx() }, Cond { cond: opcode == InstrBytecode::SPEC_GlobalSet, inner: spec_globalidx() })))), mapper: InstrVariableMapper })
+pub open spec fn spec_vectype() -> SpecVectypeCombinator {
+    SpecVectypeCombinator(TryMap { inner: U8, mapper: VectypeMapper })
 }
 
-pub fn instr_variable<'a>(opcode: u8) -> (o: InstrVariableCombinator)
-    ensures o@ == spec_instr_variable(opcode@),
+                
+pub fn vectype<'a>() -> (o: VectypeCombinator)
+    ensures o@ == spec_vectype(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = InstrVariableCombinator(Mapped { inner: InstrVariableCombinator4(Choice::new(Cond { cond: opcode == InstrBytecode::LocalGet, inner: localidx() }, InstrVariableCombinator3(Choice::new(Cond { cond: opcode == InstrBytecode::LocalSet, inner: localidx() }, InstrVariableCombinator2(Choice::new(Cond { cond: opcode == InstrBytecode::LocalTee, inner: localidx() }, InstrVariableCombinator1(Choice::new(Cond { cond: opcode == InstrBytecode::GlobalGet, inner: globalidx() }, Cond { cond: opcode == InstrBytecode::GlobalSet, inner: globalidx() })))))))), mapper: InstrVariableMapper });
-    assert({
-        &&& combinator@ == spec_instr_variable(opcode@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = VectypeCombinator(TryMap { inner: U8, mapper: VectypeMapper });
+    // assert({
+    //     &&& combinator@ == spec_vectype()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_instr_variable<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrVariableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_vectype<'a>(input: &'a [u8]) -> (res: PResult<<VectypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_instr_variable(opcode@).spec_parse(input@) == Some((n as int, v@)),
-        spec_instr_variable(opcode@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_vectype().spec_parse(input@) == Some((n as int, v@)),
+        spec_vectype().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_instr_variable(opcode@).spec_parse(input@) is None,
-        spec_instr_variable(opcode@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_vectype().spec_parse(input@) is None,
+        spec_vectype().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = instr_variable( opcode );
+    let combinator = vectype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_instr_variable<'a>(v: <InstrVariableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, opcode: u8) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_vectype<'a>(v: <VectypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_instr_variable(opcode@).wf(v@),
+        spec_vectype().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_instr_variable(opcode@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_instr_variable(opcode@).spec_serialize(v@))
+            &&& n == spec_vectype().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_vectype().spec_serialize(v@))
         },
 {
-    let combinator = instr_variable( opcode );
-    combinator.serialize(v, data, pos)
+    let combinator = vectype();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn instr_variable_len<'a>(v: <InstrVariableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, opcode: u8) -> (serialize_len: usize)
+pub fn vectype_len<'a>(v: <VectypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_instr_variable(opcode@).wf(v@),
-        spec_instr_variable(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_vectype().wf(v@),
+        spec_vectype().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_instr_variable(opcode@).spec_serialize(v@).len(),
+        serialize_len == spec_vectype().spec_serialize(v@).len(),
 {
-    let combinator = instr_variable( opcode );
+    let combinator = vectype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub type SpecEmpty = Seq<u8>;
-pub type Empty<'a> = &'a [u8];
-pub type EmptyRef<'a> = &'a &'a [u8];
-
+                
 
-pub struct SpecEmptyCombinator(pub SpecEmptyCombinatorAlias);
+pub spec const SPEC_Reftype_FuncRef: u8 = 112;
+pub spec const SPEC_Reftype_ExternRef: u8 = 111;
+pub exec static EXEC_Reftype_FuncRef: u8 ensures EXEC_Reftype_FuncRef == SPEC_Reftype_FuncRef { 112 }
+pub exec static EXEC_Reftype_ExternRef: u8 ensures EXEC_Reftype_ExternRef == SPEC_Reftype_ExternRef { 111 }
 
-impl SpecCombinator for SpecEmptyCombinator {
-    type Type = SpecEmpty;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecEmptyCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecEmptyCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Reftype {
+    FuncRef = 112,
+ExternRef = 111
 }
-pub type SpecEmptyCombinatorAlias = bytes::Fixed<0>;
+pub type SpecReftype = Reftype;
 
-pub struct EmptyCombinator(pub EmptyCombinatorAlias);
+pub type ReftypeInner = u8;
 
-impl View for EmptyCombinator {
-    type V = SpecEmptyCombinator;
-    open spec fn view(&self) -> Self::V { SpecEmptyCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EmptyCombinator {
-    type Type = Empty<'a>;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type EmptyCombinatorAlias = bytes::Fixed<0>;
+pub type ReftypeInnerRef<'a> = &'a u8;
 
+impl View for Reftype {
+    type V = Self;
 
-pub open spec fn spec_empty() -> SpecEmptyCombinator {
-    SpecEmptyCombinator(bytes::Fixed::<0>)
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
 }
 
-                
-pub fn empty<'a>() -> (o: EmptyCombinator)
-    ensures o@ == spec_empty(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = EmptyCombinator(bytes::Fixed::<0>);
-    assert({
-        &&& combinator@ == spec_empty()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
+impl SpecTryFrom<ReftypeInner> for Reftype {
+    type Error = ();
+
+    open spec fn spec_try_from(v: ReftypeInner) -> Result<Reftype, ()> {
+        match v {
+            112u8 => Ok(Reftype::FuncRef),
+            111u8 => Ok(Reftype::ExternRef),
+            _ => Err(()),
+        }
+    }
 }
 
-pub fn parse_empty<'a>(input: &'a [u8]) -> (res: PResult<<EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_empty().spec_parse(input@) == Some((n as int, v@)),
-        spec_empty().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_empty().spec_parse(input@) is None,
-        spec_empty().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = empty();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+impl SpecTryFrom<Reftype> for ReftypeInner {
+    type Error = ();
+
+    open spec fn spec_try_from(v: Reftype) -> Result<ReftypeInner, ()> {
+        match v {
+            Reftype::FuncRef => Ok(SPEC_Reftype_FuncRef),
+            Reftype::ExternRef => Ok(SPEC_Reftype_ExternRef),
+        }
+    }
 }
 
-pub fn serialize_empty<'a>(v: <EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_empty().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_empty().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_empty().spec_serialize(v@))
-        },
-{
-    let combinator = empty();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+impl TryFrom<ReftypeInner> for Reftype {
+    type Error = ();
+
+    fn ex_try_from(v: ReftypeInner) -> Result<Reftype, ()> {
+        match v {
+            112u8 => Ok(Reftype::FuncRef),
+            111u8 => Ok(Reftype::ExternRef),
+            _ => Err(()),
+        }
+    }
 }
 
-pub fn empty_len<'a>(v: <EmptyCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_empty().wf(v@),
-        spec_empty().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_empty().spec_serialize(v@).len(),
-{
-    let combinator = empty();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+impl<'a> TryFrom<&'a Reftype> for ReftypeInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a Reftype) -> Result<ReftypeInnerRef<'a>, ()> {
+        match v {
+            Reftype::FuncRef => Ok(&EXEC_Reftype_FuncRef),
+            Reftype::ExternRef => Ok(&EXEC_Reftype_ExternRef),
+        }
+    }
 }
 
-                
-pub type SpecLabelidx = u64;
-pub type Labelidx = u64;
-pub type LabelidxRef<'a> = &'a u64;
+pub struct ReftypeMapper;
 
+impl View for ReftypeMapper {
+    type V = Self;
 
-pub struct SpecLabelidxCombinator(pub SpecLabelidxCombinatorAlias);
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
 
-impl SpecCombinator for SpecLabelidxCombinator {
-    type Type = SpecLabelidx;
+impl SpecPartialIso for ReftypeMapper {
+    type Src = ReftypeInner;
+    type Dst = Reftype;
+}
+
+impl SpecPartialIsoProof for ReftypeMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+}
+
+impl<'a> PartialIso<'a> for ReftypeMapper {
+    type Src = ReftypeInner;
+    type Dst = Reftype;
+    type RefSrc = ReftypeInnerRef<'a>;
+}
+
+
+pub struct SpecReftypeCombinator(pub SpecReftypeCombinatorAlias);
+
+impl SpecCombinator for SpecReftypeCombinator {
+    type Type = SpecReftype;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecLabelidxCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecLabelidxCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecReftypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecReftypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecLabelidxCombinatorAlias = UnsignedLEB128;
+pub type SpecReftypeCombinatorAlias = TryMap<U8, ReftypeMapper>;
 
-pub struct LabelidxCombinator(pub LabelidxCombinatorAlias);
+pub struct ReftypeCombinator(pub ReftypeCombinatorAlias);
 
-impl View for LabelidxCombinator {
-    type V = SpecLabelidxCombinator;
-    open spec fn view(&self) -> Self::V { SpecLabelidxCombinator(self.0@) }
+impl View for ReftypeCombinator {
+    type V = SpecReftypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecReftypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LabelidxCombinator {
-    type Type = Labelidx;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ReftypeCombinator {
+    type Type = Reftype;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type LabelidxCombinatorAlias = UnsignedLEB128;
+}
+pub type ReftypeCombinatorAlias = TryMap<U8, ReftypeMapper>;
 
 
-pub open spec fn spec_labelidx() -> SpecLabelidxCombinator {
-    SpecLabelidxCombinator(UnsignedLEB128)
+pub open spec fn spec_reftype() -> SpecReftypeCombinator {
+    SpecReftypeCombinator(TryMap { inner: U8, mapper: ReftypeMapper })
 }
 
                 
-pub fn labelidx<'a>() -> (o: LabelidxCombinator)
-    ensures o@ == spec_labelidx(),
+pub fn reftype<'a>() -> (o: ReftypeCombinator)
+    ensures o@ == spec_reftype(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = LabelidxCombinator(UnsignedLEB128);
-    assert({
-        &&& combinator@ == spec_labelidx()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ReftypeCombinator(TryMap { inner: U8, mapper: ReftypeMapper });
+    // assert({
+    //     &&& combinator@ == spec_reftype()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_labelidx<'a>(input: &'a [u8]) -> (res: PResult<<LabelidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_reftype<'a>(input: &'a [u8]) -> (res: PResult<<ReftypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_labelidx().spec_parse(input@) == Some((n as int, v@)),
-        spec_labelidx().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_reftype().spec_parse(input@) == Some((n as int, v@)),
+        spec_reftype().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_labelidx().spec_parse(input@) is None,
-        spec_labelidx().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_reftype().spec_parse(input@) is None,
+        spec_reftype().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = labelidx();
+    let combinator = reftype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_labelidx<'a>(v: <LabelidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_reftype<'a>(v: <ReftypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_labelidx().wf(v@),
+        spec_reftype().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_labelidx().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_labelidx().spec_serialize(v@))
+            &&& n == spec_reftype().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_reftype().spec_serialize(v@))
         },
 {
-    let combinator = labelidx();
+    let combinator = reftype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn labelidx_len<'a>(v: <LabelidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn reftype_len<'a>(v: <ReftypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_labelidx().wf(v@),
-        spec_labelidx().spec_serialize(v@).len() <= usize::MAX,
+        spec_reftype().wf(v@),
+        spec_reftype().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_labelidx().spec_serialize(v@).len(),
+        serialize_len == spec_reftype().spec_serialize(v@).len(),
 {
-    let combinator = labelidx();
+    let combinator = reftype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub type SpecFuncidx = u64;
-pub type Funcidx = u64;
-pub type FuncidxRef<'a> = &'a u64;
 
-
-pub struct SpecFuncidxCombinator(pub SpecFuncidxCombinatorAlias);
-
-impl SpecCombinator for SpecFuncidxCombinator {
-    type Type = SpecFuncidx;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecFuncidxCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecFuncidxCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
+pub enum SpecValtype {
+    NumTy(SpecNumtype),
+    VecTy(SpecVectype),
+    RefTy(SpecReftype),
 }
-pub type SpecFuncidxCombinatorAlias = UnsignedLEB128;
 
-pub struct FuncidxCombinator(pub FuncidxCombinatorAlias);
-
-impl View for FuncidxCombinator {
-    type V = SpecFuncidxCombinator;
-    open spec fn view(&self) -> Self::V { SpecFuncidxCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FuncidxCombinator {
-    type Type = Funcidx;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type FuncidxCombinatorAlias = UnsignedLEB128;
+pub type SpecValtypeInner = Either<SpecNumtype, Either<SpecVectype, SpecReftype>>;
 
+impl SpecFrom<SpecValtype> for SpecValtypeInner {
+    open spec fn spec_from(m: SpecValtype) -> SpecValtypeInner {
+        match m {
+            SpecValtype::NumTy(m) => Either::Left(m),
+            SpecValtype::VecTy(m) => Either::Right(Either::Left(m)),
+            SpecValtype::RefTy(m) => Either::Right(Either::Right(m)),
+        }
+    }
 
-pub open spec fn spec_funcidx() -> SpecFuncidxCombinator {
-    SpecFuncidxCombinator(UnsignedLEB128)
 }
 
                 
-pub fn funcidx<'a>() -> (o: FuncidxCombinator)
-    ensures o@ == spec_funcidx(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = FuncidxCombinator(UnsignedLEB128);
-    assert({
-        &&& combinator@ == spec_funcidx()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
-
-pub fn parse_funcidx<'a>(input: &'a [u8]) -> (res: PResult<<FuncidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_funcidx().spec_parse(input@) == Some((n as int, v@)),
-        spec_funcidx().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_funcidx().spec_parse(input@) is None,
-        spec_funcidx().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = funcidx();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
-}
+impl SpecFrom<SpecValtypeInner> for SpecValtype {
+    open spec fn spec_from(m: SpecValtypeInner) -> SpecValtype {
+        match m {
+            Either::Left(m) => SpecValtype::NumTy(m),
+            Either::Right(Either::Left(m)) => SpecValtype::VecTy(m),
+            Either::Right(Either::Right(m)) => SpecValtype::RefTy(m),
+        }
+    }
 
-pub fn serialize_funcidx<'a>(v: <FuncidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_funcidx().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_funcidx().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_funcidx().spec_serialize(v@))
-        },
-{
-    let combinator = funcidx();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn funcidx_len<'a>(v: <FuncidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_funcidx().wf(v@),
-        spec_funcidx().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_funcidx().spec_serialize(v@).len(),
-{
-    let combinator = funcidx();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
-}
 
-                
 
-pub struct SpecLabelidxVec {
-    pub l: u64,
-    pub v: Seq<SpecLabelidx>,
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Valtype {
+    NumTy(Numtype),
+    VecTy(Vectype),
+    RefTy(Reftype),
 }
 
-pub type SpecLabelidxVecInner = (u64, Seq<SpecLabelidx>);
+pub type ValtypeInner = Either<Numtype, Either<Vectype, Reftype>>;
 
+pub type ValtypeInnerRef<'a> = Either<&'a Numtype, Either<&'a Vectype, &'a Reftype>>;
 
-impl SpecFrom<SpecLabelidxVec> for SpecLabelidxVecInner {
-    open spec fn spec_from(m: SpecLabelidxVec) -> SpecLabelidxVecInner {
-        (m.l, m.v)
-    }
-}
 
-impl SpecFrom<SpecLabelidxVecInner> for SpecLabelidxVec {
-    open spec fn spec_from(m: SpecLabelidxVecInner) -> SpecLabelidxVec {
-        let (l, v) = m;
-        SpecLabelidxVec { l, v }
+impl View for Valtype {
+    type V = SpecValtype;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            Valtype::NumTy(m) => SpecValtype::NumTy(m@),
+            Valtype::VecTy(m) => SpecValtype::VecTy(m@),
+            Valtype::RefTy(m) => SpecValtype::RefTy(m@),
+        }
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct LabelidxVec {
-    pub l: u64,
-    pub v: RepeatResult<Labelidx>,
-}
 
-impl View for LabelidxVec {
-    type V = SpecLabelidxVec;
 
-    open spec fn view(&self) -> Self::V {
-        SpecLabelidxVec {
-            l: self.l@,
-            v: self.v@,
+impl<'a> From<&'a Valtype> for ValtypeInnerRef<'a> {
+    fn ex_from(m: &'a Valtype) -> ValtypeInnerRef<'a> {
+        match m {
+            Valtype::NumTy(m) => Either::Left(m),
+            Valtype::VecTy(m) => Either::Right(Either::Left(m)),
+            Valtype::RefTy(m) => Either::Right(Either::Right(m)),
         }
     }
-}
-pub type LabelidxVecInner = (u64, RepeatResult<Labelidx>);
 
-pub type LabelidxVecInnerRef<'a> = (&'a u64, &'a RepeatResult<Labelidx>);
-impl<'a> From<&'a LabelidxVec> for LabelidxVecInnerRef<'a> {
-    fn ex_from(m: &'a LabelidxVec) -> LabelidxVecInnerRef<'a> {
-        (&m.l, &m.v)
-    }
 }
 
-impl From<LabelidxVecInner> for LabelidxVec {
-    fn ex_from(m: LabelidxVecInner) -> LabelidxVec {
-        let (l, v) = m;
-        LabelidxVec { l, v }
+impl From<ValtypeInner> for Valtype {
+    fn ex_from(m: ValtypeInner) -> Valtype {
+        match m {
+            Either::Left(m) => Valtype::NumTy(m),
+            Either::Right(Either::Left(m)) => Valtype::VecTy(m),
+            Either::Right(Either::Right(m)) => Valtype::RefTy(m),
+        }
     }
+    
 }
 
-pub struct LabelidxVecMapper;
-impl View for LabelidxVecMapper {
+
+pub struct ValtypeMapper;
+impl View for ValtypeMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for LabelidxVecMapper {
-    type Src = SpecLabelidxVecInner;
-    type Dst = SpecLabelidxVec;
+impl SpecIso for ValtypeMapper {
+    type Src = SpecValtypeInner;
+    type Dst = SpecValtype;
 }
-impl SpecIsoProof for LabelidxVecMapper {
+impl SpecIsoProof for ValtypeMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -1451,684 +931,1699 @@ impl SpecIsoProof for LabelidxVecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for LabelidxVecMapper {
-    type Src = LabelidxVecInner;
-    type Dst = LabelidxVec;
-    type RefSrc = LabelidxVecInnerRef<'a>;
+impl<'a> Iso<'a> for ValtypeMapper {
+    type Src = ValtypeInner;
+    type Dst = Valtype;
+    type RefSrc = ValtypeInnerRef<'a>;
 }
 
-pub struct SpecLabelidxVecCombinator(pub SpecLabelidxVecCombinatorAlias);
+type SpecValtypeCombinatorAlias1 = Choice<SpecVectypeCombinator, SpecReftypeCombinator>;
+type SpecValtypeCombinatorAlias2 = Choice<SpecNumtypeCombinator, SpecValtypeCombinatorAlias1>;
+impl DisjointFrom<SpecNumtypeCombinator> for SpecVectypeCombinator {
+    open spec fn disjoint_from(&self, other: &SpecNumtypeCombinator) -> bool
+    { self.0.disjoint_from(&other.0) }
+    proof fn parse_disjoint_on(&self, other: &SpecNumtypeCombinator, buf: Seq<u8>)
+    { self.0.parse_disjoint_on(&other.0, buf); }
+}
 
-impl SpecCombinator for SpecLabelidxVecCombinator {
-    type Type = SpecLabelidxVec;
+impl DisjointFrom<SpecNumtypeCombinator> for SpecReftypeCombinator {
+    open spec fn disjoint_from(&self, other: &SpecNumtypeCombinator) -> bool
+    { self.0.disjoint_from(&other.0) }
+    proof fn parse_disjoint_on(&self, other: &SpecNumtypeCombinator, buf: Seq<u8>)
+    { self.0.parse_disjoint_on(&other.0, buf); }
+}
+
+impl DisjointFrom<SpecVectypeCombinator> for SpecReftypeCombinator {
+    open spec fn disjoint_from(&self, other: &SpecVectypeCombinator) -> bool
+    { self.0.disjoint_from(&other.0) }
+    proof fn parse_disjoint_on(&self, other: &SpecVectypeCombinator, buf: Seq<u8>)
+    { self.0.parse_disjoint_on(&other.0, buf); }
+}
+pub struct SpecValtypeCombinator(pub SpecValtypeCombinatorAlias);
+
+impl SpecCombinator for SpecValtypeCombinator {
+    type Type = SpecValtype;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecLabelidxVecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecLabelidxVecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecValtypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecValtypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecLabelidxVecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecLabelidxCombinator>>, LabelidxVecMapper>;
+pub type SpecValtypeCombinatorAlias = Mapped<SpecValtypeCombinatorAlias2, ValtypeMapper>;
+type ValtypeCombinatorAlias1 = Choice<VectypeCombinator, ReftypeCombinator>;
+type ValtypeCombinatorAlias2 = Choice<NumtypeCombinator, ValtypeCombinator1>;
+pub struct ValtypeCombinator1(pub ValtypeCombinatorAlias1);
+impl View for ValtypeCombinator1 {
+    type V = SpecValtypeCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ValtypeCombinator1, ValtypeCombinatorAlias1);
 
-pub struct LabelidxVecCombinator(pub LabelidxVecCombinatorAlias);
+pub struct ValtypeCombinator2(pub ValtypeCombinatorAlias2);
+impl View for ValtypeCombinator2 {
+    type V = SpecValtypeCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ValtypeCombinator2, ValtypeCombinatorAlias2);
 
-impl View for LabelidxVecCombinator {
-    type V = SpecLabelidxVecCombinator;
-    open spec fn view(&self) -> Self::V { SpecLabelidxVecCombinator(self.0@) }
+pub struct ValtypeCombinator(pub ValtypeCombinatorAlias);
+
+impl View for ValtypeCombinator {
+    type V = SpecValtypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecValtypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LabelidxVecCombinator {
-    type Type = LabelidxVec;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ValtypeCombinator {
+    type Type = Valtype;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type LabelidxVecCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<LabelidxCombinator>, LabelidxVecCont0>, LabelidxVecMapper>;
-
-
-pub open spec fn spec_labelidx_vec() -> SpecLabelidxVecCombinator {
-    SpecLabelidxVecCombinator(
-    Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_labelidx_vec_cont0(deps)),
-        mapper: LabelidxVecMapper,
-    })
-}
-
-pub open spec fn spec_labelidx_vec_cont0(deps: u64) -> RepeatN<SpecLabelidxCombinator> {
-    let l = deps;
-    RepeatN(spec_labelidx(), l.spec_into())
 }
+pub type ValtypeCombinatorAlias = Mapped<ValtypeCombinator2, ValtypeMapper>;
 
-impl View for LabelidxVecCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecLabelidxCombinator>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_labelidx_vec_cont0(deps)
-        }
-    }
+pub open spec fn spec_valtype() -> SpecValtypeCombinator {
+    SpecValtypeCombinator(Mapped { inner: Choice(spec_numtype(), Choice(spec_vectype(), spec_reftype())), mapper: ValtypeMapper })
 }
 
                 
-pub fn labelidx_vec<'a>() -> (o: LabelidxVecCombinator)
-    ensures o@ == spec_labelidx_vec(),
+pub fn valtype<'a>() -> (o: ValtypeCombinator)
+    ensures o@ == spec_valtype(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = LabelidxVecCombinator(
-    Mapped {
-        inner: Pair::new(UnsignedLEB128, LabelidxVecCont0),
-        mapper: LabelidxVecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_labelidx_vec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ValtypeCombinator(Mapped { inner: ValtypeCombinator2(Choice::new(numtype(), ValtypeCombinator1(Choice::new(vectype(), reftype())))), mapper: ValtypeMapper });
+    // assert({
+    //     &&& combinator@ == spec_valtype()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_labelidx_vec<'a>(input: &'a [u8]) -> (res: PResult<<LabelidxVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_valtype<'a>(input: &'a [u8]) -> (res: PResult<<ValtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_labelidx_vec().spec_parse(input@) == Some((n as int, v@)),
-        spec_labelidx_vec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_valtype().spec_parse(input@) == Some((n as int, v@)),
+        spec_valtype().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_labelidx_vec().spec_parse(input@) is None,
-        spec_labelidx_vec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_valtype().spec_parse(input@) is None,
+        spec_valtype().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = labelidx_vec();
+    let combinator = valtype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_labelidx_vec<'a>(v: <LabelidxVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_valtype<'a>(v: <ValtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_labelidx_vec().wf(v@),
+        spec_valtype().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_labelidx_vec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_labelidx_vec().spec_serialize(v@))
+            &&& n == spec_valtype().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_valtype().spec_serialize(v@))
         },
 {
-    let combinator = labelidx_vec();
+    let combinator = valtype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn labelidx_vec_len<'a>(v: <LabelidxVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn valtype_len<'a>(v: <ValtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_labelidx_vec().wf(v@),
-        spec_labelidx_vec().spec_serialize(v@).len() <= usize::MAX,
+        spec_valtype().wf(v@),
+        spec_valtype().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_labelidx_vec().spec_serialize(v@).len(),
+        serialize_len == spec_valtype().spec_serialize(v@).len(),
 {
-    let combinator = labelidx_vec();
+    let combinator = valtype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct LabelidxVecCont0;
-type LabelidxVecCont0Type<'a, 'b> = &'b u64;
-type LabelidxVecCont0SType<'a, 'x> = &'x u64;
-type LabelidxVecCont0Input<'a, 'b, 'x> = POrSType<LabelidxVecCont0Type<'a, 'b>, LabelidxVecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<LabelidxVecCont0Input<'a, 'b, 'x>> for LabelidxVecCont0 {
-    type Output = RepeatN<LabelidxCombinator>;
+                
 
-    open spec fn requires(&self, deps: LabelidxVecCont0Input<'a, 'b, 'x>) -> bool { true }
+pub struct SpecSelectT {
+    pub l: u64,
+    pub v: Seq<SpecValtype>,
+}
 
-    open spec fn ensures(&self, deps: LabelidxVecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_labelidx_vec_cont0(deps@)
+pub type SpecSelectTInner = (u64, Seq<SpecValtype>);
+
+
+impl SpecFrom<SpecSelectT> for SpecSelectTInner {
+    open spec fn spec_from(m: SpecSelectT) -> SpecSelectTInner {
+        (m.l, m.v)
     }
+}
 
-    fn apply(&self, deps: LabelidxVecCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(labelidx(), l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(labelidx(), l.ex_into())
-            }
-        }
+impl SpecFrom<SpecSelectTInner> for SpecSelectT {
+    open spec fn spec_from(m: SpecSelectTInner) -> SpecSelectT {
+        let (l, v) = m;
+        SpecSelectT { l, v }
     }
 }
-                
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct SpecBrTable {
-    pub l: SpecLabelidxVec,
-    pub l_n: SpecLabelidx,
+pub struct SelectT {
+    pub l: u64,
+    pub v: RepeatResult<Valtype>,
 }
 
-pub type SpecBrTableInner = (SpecLabelidxVec, SpecLabelidx);
+impl View for SelectT {
+    type V = SpecSelectT;
 
+    open spec fn view(&self) -> Self::V {
+        SpecSelectT {
+            l: self.l@,
+            v: self.v@,
+        }
+    }
+}
+pub type SelectTInner = (u64, RepeatResult<Valtype>);
 
-impl SpecFrom<SpecBrTable> for SpecBrTableInner {
-    open spec fn spec_from(m: SpecBrTable) -> SpecBrTableInner {
-        (m.l, m.l_n)
+pub type SelectTInnerRef<'a> = (&'a u64, &'a RepeatResult<Valtype>);
+impl<'a> From<&'a SelectT> for SelectTInnerRef<'a> {
+    fn ex_from(m: &'a SelectT) -> SelectTInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-impl SpecFrom<SpecBrTableInner> for SpecBrTable {
-    open spec fn spec_from(m: SpecBrTableInner) -> SpecBrTable {
-        let (l, l_n) = m;
-        SpecBrTable { l, l_n }
+impl From<SelectTInner> for SelectT {
+    fn ex_from(m: SelectTInner) -> SelectT {
+        let (l, v) = m;
+        SelectT { l, v }
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct BrTable {
-    pub l: LabelidxVec,
-    pub l_n: Labelidx,
+pub struct SelectTMapper;
+impl View for SelectTMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for SelectTMapper {
+    type Src = SpecSelectTInner;
+    type Dst = SpecSelectT;
+}
+impl SpecIsoProof for SelectTMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for SelectTMapper {
+    type Src = SelectTInner;
+    type Dst = SelectT;
+    type RefSrc = SelectTInnerRef<'a>;
 }
 
-impl View for BrTable {
-    type V = SpecBrTable;
+pub struct SpecSelectTCombinator(pub SpecSelectTCombinatorAlias);
+
+impl SpecCombinator for SpecSelectTCombinator {
+    type Type = SpecSelectT;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecSelectTCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSelectTCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecSelectTCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecValtypeCombinator>>, SelectTMapper>;
+
+pub struct SelectTCombinator(pub SelectTCombinatorAlias);
+
+impl View for SelectTCombinator {
+    type V = SpecSelectTCombinator;
+    open spec fn view(&self) -> Self::V { SpecSelectTCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SelectTCombinator {
+    type Type = SelectT;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type SelectTCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ValtypeCombinator>, SelectTCont0>, SelectTMapper>;
+
+
+pub open spec fn spec_select_t() -> SpecSelectTCombinator {
+    SpecSelectTCombinator(
+    Mapped {
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_select_t_cont0(deps)),
+        mapper: SelectTMapper,
+    })
+}
+
+pub open spec fn spec_select_t_cont0(deps: u64) -> RepeatN<SpecValtypeCombinator> {
+    let l = deps;
+    RepeatN(spec_valtype(), (usize::spec_from(l)) as usize)
+}
+
+impl View for SelectTCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecValtypeCombinator>;
 
     open spec fn view(&self) -> Self::V {
-        SpecBrTable {
-            l: self.l@,
-            l_n: self.l_n@,
+        |deps: u64| {
+            spec_select_t_cont0(deps)
         }
     }
 }
-pub type BrTableInner = (LabelidxVec, Labelidx);
 
-pub type BrTableInnerRef<'a> = (&'a LabelidxVec, &'a Labelidx);
-impl<'a> From<&'a BrTable> for BrTableInnerRef<'a> {
-    fn ex_from(m: &'a BrTable) -> BrTableInnerRef<'a> {
-        (&m.l, &m.l_n)
+                
+pub fn select_t<'a>() -> (o: SelectTCombinator)
+    ensures o@ == spec_select_t(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = SelectTCombinator(
+    Mapped {
+        inner: Pair::new(UnsignedLEB128, SelectTCont0),
+        mapper: SelectTMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_select_t()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_select_t<'a>(input: &'a [u8]) -> (res: PResult<<SelectTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_select_t().spec_parse(input@) == Some((n as int, v@)),
+        spec_select_t().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_select_t().spec_parse(input@) is None,
+        spec_select_t().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = select_t();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_select_t<'a>(v: <SelectTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_select_t().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_select_t().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_select_t().spec_serialize(v@))
+        },
+{
+    let combinator = select_t();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn select_t_len<'a>(v: <SelectTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_select_t().wf(v@),
+        spec_select_t().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_select_t().spec_serialize(v@).len(),
+{
+    let combinator = select_t();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct SelectTCont0;
+type SelectTCont0Type<'a, 'b> = &'b u64;
+type SelectTCont0SType<'a, 'x> = &'x u64;
+type SelectTCont0Input<'a, 'b, 'x> = POrSType<SelectTCont0Type<'a, 'b>, SelectTCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<SelectTCont0Input<'a, 'b, 'x>> for SelectTCont0 {
+    type Output = RepeatN<ValtypeCombinator>;
+
+    open spec fn requires(&self, deps: SelectTCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: SelectTCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_select_t_cont0(deps@)
+    }
+
+    fn apply(&self, deps: SelectTCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(valtype(), (usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(valtype(), (usize::ex_from(l)) as usize)
+            }
+        }
     }
 }
+                
+
+pub spec const SPEC_MutT_Const: u8 = 0;
+pub spec const SPEC_MutT_Var: u8 = 1;
+pub exec static EXEC_MutT_Const: u8 ensures EXEC_MutT_Const == SPEC_MutT_Const { 0 }
+pub exec static EXEC_MutT_Var: u8 ensures EXEC_MutT_Var == SPEC_MutT_Var { 1 }
+
+#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
+pub enum MutT {
+    Const = 0,
+Var = 1
+}
+pub type SpecMutT = MutT;
+
+pub type MutTInner = u8;
+
+pub type MutTInnerRef<'a> = &'a u8;
+
+impl View for MutT {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecTryFrom<MutTInner> for MutT {
+    type Error = ();
+
+    open spec fn spec_try_from(v: MutTInner) -> Result<MutT, ()> {
+        match v {
+            0u8 => Ok(MutT::Const),
+            1u8 => Ok(MutT::Var),
+            _ => Err(()),
+        }
+    }
+}
+
+impl SpecTryFrom<MutT> for MutTInner {
+    type Error = ();
+
+    open spec fn spec_try_from(v: MutT) -> Result<MutTInner, ()> {
+        match v {
+            MutT::Const => Ok(SPEC_MutT_Const),
+            MutT::Var => Ok(SPEC_MutT_Var),
+        }
+    }
+}
+
+impl TryFrom<MutTInner> for MutT {
+    type Error = ();
+
+    fn ex_try_from(v: MutTInner) -> Result<MutT, ()> {
+        match v {
+            0u8 => Ok(MutT::Const),
+            1u8 => Ok(MutT::Var),
+            _ => Err(()),
+        }
+    }
+}
+
+impl<'a> TryFrom<&'a MutT> for MutTInnerRef<'a> {
+    type Error = ();
+
+    fn ex_try_from(v: &'a MutT) -> Result<MutTInnerRef<'a>, ()> {
+        match v {
+            MutT::Const => Ok(&EXEC_MutT_Const),
+            MutT::Var => Ok(&EXEC_MutT_Var),
+        }
+    }
+}
+
+pub struct MutTMapper;
+
+impl View for MutTMapper {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+
+impl SpecPartialIso for MutTMapper {
+    type Src = MutTInner;
+    type Dst = MutT;
+}
+
+impl SpecPartialIsoProof for MutTMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(
+            Self::spec_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_rev_apply(v) is Ok
+            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(
+            Self::spec_rev_apply(s) matches Ok(v) ==> {
+            &&& Self::spec_apply(v) is Ok
+            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
+        });
+    }
+}
+
+impl<'a> PartialIso<'a> for MutTMapper {
+    type Src = MutTInner;
+    type Dst = MutT;
+    type RefSrc = MutTInnerRef<'a>;
+}
+
+
+pub struct SpecMutTCombinator(pub SpecMutTCombinatorAlias);
+
+impl SpecCombinator for SpecMutTCombinator {
+    type Type = SpecMutT;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecMutTCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMutTCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecMutTCombinatorAlias = TryMap<U8, MutTMapper>;
+
+pub struct MutTCombinator(pub MutTCombinatorAlias);
+
+impl View for MutTCombinator {
+    type V = SpecMutTCombinator;
+    open spec fn view(&self) -> Self::V { SpecMutTCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MutTCombinator {
+    type Type = MutT;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type MutTCombinatorAlias = TryMap<U8, MutTMapper>;
+
+
+pub open spec fn spec_mut_t() -> SpecMutTCombinator {
+    SpecMutTCombinator(TryMap { inner: U8, mapper: MutTMapper })
+}
+
+                
+pub fn mut_t<'a>() -> (o: MutTCombinator)
+    ensures o@ == spec_mut_t(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = MutTCombinator(TryMap { inner: U8, mapper: MutTMapper });
+    // assert({
+    //     &&& combinator@ == spec_mut_t()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_mut_t<'a>(input: &'a [u8]) -> (res: PResult<<MutTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_mut_t().spec_parse(input@) == Some((n as int, v@)),
+        spec_mut_t().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_mut_t().spec_parse(input@) is None,
+        spec_mut_t().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = mut_t();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_mut_t<'a>(v: <MutTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_mut_t().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_mut_t().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_mut_t().spec_serialize(v@))
+        },
+{
+    let combinator = mut_t();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn mut_t_len<'a>(v: <MutTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_mut_t().wf(v@),
+        spec_mut_t().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_mut_t().spec_serialize(v@).len(),
+{
+    let combinator = mut_t();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub type SpecTableidx = u64;
+pub type Tableidx = u64;
+pub type TableidxRef<'a> = &'a u64;
+
+
+pub struct SpecTableidxCombinator(pub SpecTableidxCombinatorAlias);
+
+impl SpecCombinator for SpecTableidxCombinator {
+    type Type = SpecTableidx;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTableidxCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTableidxCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTableidxCombinatorAlias = UnsignedLEB128;
+
+pub struct TableidxCombinator(pub TableidxCombinatorAlias);
+
+impl View for TableidxCombinator {
+    type V = SpecTableidxCombinator;
+    open spec fn view(&self) -> Self::V { SpecTableidxCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TableidxCombinator {
+    type Type = Tableidx;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TableidxCombinatorAlias = UnsignedLEB128;
+
+
+pub open spec fn spec_tableidx() -> SpecTableidxCombinator {
+    SpecTableidxCombinator(UnsignedLEB128)
+}
+
+                
+pub fn tableidx<'a>() -> (o: TableidxCombinator)
+    ensures o@ == spec_tableidx(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TableidxCombinator(UnsignedLEB128);
+    // assert({
+    //     &&& combinator@ == spec_tableidx()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_tableidx<'a>(input: &'a [u8]) -> (res: PResult<<TableidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_tableidx().spec_parse(input@) == Some((n as int, v@)),
+        spec_tableidx().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_tableidx().spec_parse(input@) is None,
+        spec_tableidx().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = tableidx();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_tableidx<'a>(v: <TableidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_tableidx().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_tableidx().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_tableidx().spec_serialize(v@))
+        },
+{
+    let combinator = tableidx();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn tableidx_len<'a>(v: <TableidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_tableidx().wf(v@),
+        spec_tableidx().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_tableidx().spec_serialize(v@).len(),
+{
+    let combinator = tableidx();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub type SpecTableFill = SpecTableidx;
+pub type TableFill = Tableidx;
+pub type TableFillRef<'a> = &'a Tableidx;
+
+
+pub struct SpecTableFillCombinator(pub SpecTableFillCombinatorAlias);
+
+impl SpecCombinator for SpecTableFillCombinator {
+    type Type = SpecTableFill;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecTableFillCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTableFillCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecTableFillCombinatorAlias = SpecTableidxCombinator;
+
+pub struct TableFillCombinator(pub TableFillCombinatorAlias);
+
+impl View for TableFillCombinator {
+    type V = SpecTableFillCombinator;
+    open spec fn view(&self) -> Self::V { SpecTableFillCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TableFillCombinator {
+    type Type = TableFill;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type TableFillCombinatorAlias = TableidxCombinator;
+
+
+pub open spec fn spec_table_fill() -> SpecTableFillCombinator {
+    SpecTableFillCombinator(spec_tableidx())
+}
+
+                
+pub fn table_fill<'a>() -> (o: TableFillCombinator)
+    ensures o@ == spec_table_fill(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = TableFillCombinator(tableidx());
+    // assert({
+    //     &&& combinator@ == spec_table_fill()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_table_fill<'a>(input: &'a [u8]) -> (res: PResult<<TableFillCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_table_fill().spec_parse(input@) == Some((n as int, v@)),
+        spec_table_fill().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_table_fill().spec_parse(input@) is None,
+        spec_table_fill().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = table_fill();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_table_fill<'a>(v: <TableFillCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_table_fill().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_table_fill().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_table_fill().spec_serialize(v@))
+        },
+{
+    let combinator = table_fill();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn table_fill_len<'a>(v: <TableFillCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_table_fill().wf(v@),
+        spec_table_fill().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_table_fill().spec_serialize(v@).len(),
+{
+    let combinator = table_fill();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+pub mod InstrBytecode {
+    use super::*;
+    pub spec const SPEC_Unreachable: u8 = 0;
+    pub spec const SPEC_Nop: u8 = 1;
+    pub spec const SPEC_Block: u8 = 2;
+    pub spec const SPEC_Loop: u8 = 3;
+    pub spec const SPEC_If: u8 = 4;
+    pub spec const SPEC_Else: u8 = 5;
+    pub spec const SPEC_End: u8 = 11;
+    pub spec const SPEC_Br: u8 = 12;
+    pub spec const SPEC_BrIf: u8 = 13;
+    pub spec const SPEC_BrTable: u8 = 14;
+    pub spec const SPEC_Ret: u8 = 15;
+    pub spec const SPEC_Call: u8 = 16;
+    pub spec const SPEC_CallIndirect: u8 = 17;
+    pub spec const SPEC_RefNull: u8 = 208;
+    pub spec const SPEC_RefIsNull: u8 = 209;
+    pub spec const SPEC_RefFunc: u8 = 210;
+    pub spec const SPEC_Drop: u8 = 26;
+    pub spec const SPEC_Select: u8 = 27;
+    pub spec const SPEC_SelectT: u8 = 28;
+    pub spec const SPEC_LocalGet: u8 = 32;
+    pub spec const SPEC_LocalSet: u8 = 33;
+    pub spec const SPEC_LocalTee: u8 = 34;
+    pub spec const SPEC_GlobalGet: u8 = 35;
+    pub spec const SPEC_GlobalSet: u8 = 36;
+    pub spec const SPEC_TableGet: u8 = 37;
+    pub spec const SPEC_TableSet: u8 = 38;
+    pub spec const SPEC_OpcodeFC: u8 = 252;
+    pub spec const SPEC_I32Load: u8 = 40;
+    pub spec const SPEC_I64Load: u8 = 41;
+    pub spec const SPEC_F32Load: u8 = 42;
+    pub spec const SPEC_F64Load: u8 = 43;
+    pub spec const SPEC_I32Load8S: u8 = 44;
+    pub spec const SPEC_I32Load8U: u8 = 45;
+    pub spec const SPEC_I32Load16S: u8 = 46;
+    pub spec const SPEC_I32Load16U: u8 = 47;
+    pub spec const SPEC_I64Load8S: u8 = 48;
+    pub spec const SPEC_I64Load8U: u8 = 49;
+    pub spec const SPEC_I64Load16S: u8 = 50;
+    pub spec const SPEC_I64Load16U: u8 = 51;
+    pub spec const SPEC_I64Load32S: u8 = 52;
+    pub spec const SPEC_I64Load32U: u8 = 53;
+    pub spec const SPEC_I32Store: u8 = 54;
+    pub spec const SPEC_I64Store: u8 = 55;
+    pub spec const SPEC_F32Store: u8 = 56;
+    pub spec const SPEC_F64Store: u8 = 57;
+    pub spec const SPEC_I32Store8: u8 = 58;
+    pub spec const SPEC_I32Store16: u8 = 59;
+    pub spec const SPEC_I64Store8: u8 = 60;
+    pub spec const SPEC_I64Store16: u8 = 61;
+    pub spec const SPEC_I64Store32: u8 = 62;
+    pub spec const SPEC_MemorySize: u8 = 63;
+    pub spec const SPEC_MemoryGrow: u8 = 64;
+    pub spec const SPEC_I32Const: u8 = 65;
+    pub spec const SPEC_I64Const: u8 = 66;
+    pub spec const SPEC_F32Const: u8 = 67;
+    pub spec const SPEC_F64Const: u8 = 68;
+    pub spec const SPEC_I32Eqz: u8 = 69;
+    pub spec const SPEC_I32Eq: u8 = 70;
+    pub spec const SPEC_I32Ne: u8 = 71;
+    pub spec const SPEC_I32LtS: u8 = 72;
+    pub spec const SPEC_I32LtU: u8 = 73;
+    pub spec const SPEC_I32GtS: u8 = 74;
+    pub spec const SPEC_I32GtU: u8 = 75;
+    pub spec const SPEC_I32LeS: u8 = 76;
+    pub spec const SPEC_I32LeU: u8 = 77;
+    pub spec const SPEC_I32GeS: u8 = 78;
+    pub spec const SPEC_I32GeU: u8 = 79;
+    pub spec const SPEC_I64Eqz: u8 = 80;
+    pub spec const SPEC_I64Eq: u8 = 81;
+    pub spec const SPEC_I64Ne: u8 = 82;
+    pub spec const SPEC_I64LtS: u8 = 83;
+    pub spec const SPEC_I64LtU: u8 = 84;
+    pub spec const SPEC_I64GtS: u8 = 85;
+    pub spec const SPEC_I64GtU: u8 = 86;
+    pub spec const SPEC_I64LeS: u8 = 87;
+    pub spec const SPEC_I64LeU: u8 = 88;
+    pub spec const SPEC_I64GeS: u8 = 89;
+    pub spec const SPEC_I64GeU: u8 = 90;
+    pub spec const SPEC_F32Eq: u8 = 91;
+    pub spec const SPEC_F32Ne: u8 = 92;
+    pub spec const SPEC_F32Lt: u8 = 93;
+    pub spec const SPEC_F32Gt: u8 = 94;
+    pub spec const SPEC_F32Le: u8 = 95;
+    pub spec const SPEC_F32Ge: u8 = 96;
+    pub spec const SPEC_F64Eq: u8 = 97;
+    pub spec const SPEC_F64Ne: u8 = 98;
+    pub spec const SPEC_F64Lt: u8 = 99;
+    pub spec const SPEC_F64Gt: u8 = 100;
+    pub spec const SPEC_F64Le: u8 = 101;
+    pub spec const SPEC_F64Ge: u8 = 102;
+    pub spec const SPEC_I32Clz: u8 = 103;
+    pub spec const SPEC_I32Ctz: u8 = 104;
+    pub spec const SPEC_I32Popcnt: u8 = 105;
+    pub spec const SPEC_I32Add: u8 = 106;
+    pub spec const SPEC_I32Sub: u8 = 107;
+    pub spec const SPEC_I32Mul: u8 = 108;
+    pub spec const SPEC_I32DivS: u8 = 109;
+    pub spec const SPEC_I32DivU: u8 = 110;
+    pub spec const SPEC_I32RemS: u8 = 111;
+    pub spec const SPEC_I32RemU: u8 = 112;
+    pub spec const SPEC_I32And: u8 = 113;
+    pub spec const SPEC_I32Or: u8 = 114;
+    pub spec const SPEC_I32Xor: u8 = 115;
+    pub spec const SPEC_I32Shl: u8 = 116;
+    pub spec const SPEC_I32ShrS: u8 = 117;
+    pub spec const SPEC_I32ShrU: u8 = 118;
+    pub spec const SPEC_I32Rotl: u8 = 119;
+    pub spec const SPEC_I32Rotr: u8 = 120;
+    pub spec const SPEC_I64Clz: u8 = 121;
+    pub spec const SPEC_I64Ctz: u8 = 122;
+    pub spec const SPEC_I64Popcnt: u8 = 123;
+    pub spec const SPEC_I64Add: u8 = 124;
+    pub spec const SPEC_I64Sub: u8 = 125;
+    pub spec const SPEC_I64Mul: u8 = 126;
+    pub spec const SPEC_I64DivS: u8 = 127;
+    pub spec const SPEC_I64DivU: u8 = 128;
+    pub spec const SPEC_I64RemS: u8 = 129;
+    pub spec const SPEC_I64RemU: u8 = 130;
+    pub spec const SPEC_I64And: u8 = 131;
+    pub spec const SPEC_I64Or: u8 = 132;
+    pub spec const SPEC_I64Xor: u8 = 133;
+    pub spec const SPEC_I64Shl: u8 = 134;
+    pub spec const SPEC_I64ShrS: u8 = 135;
+    pub spec const SPEC_I64ShrU: u8 = 136;
+    pub spec const SPEC_I64Rotl: u8 = 137;
+    pub spec const SPEC_I64Rotr: u8 = 138;
+    pub spec const SPEC_F32Abs: u8 = 139;
+    pub spec const SPEC_F32Neg: u8 = 140;
+    pub spec const SPEC_F32Ceil: u8 = 141;
+    pub spec const SPEC_F32Floor: u8 = 142;
+    pub spec const SPEC_F32Trunc: u8 = 143;
+    pub spec const SPEC_F32Nearest: u8 = 144;
+    pub spec const SPEC_F32Sqrt: u8 = 145;
+    pub spec const SPEC_F32Add: u8 = 146;
+    pub spec const SPEC_F32Sub: u8 = 147;
+    pub spec const SPEC_F32Mul: u8 = 148;
+    pub spec const SPEC_F32Div: u8 = 149;
+    pub spec const SPEC_F32Min: u8 = 150;
+    pub spec const SPEC_F32Max: u8 = 151;
+    pub spec const SPEC_F32Copysign: u8 = 152;
+    pub spec const SPEC_F64Abs: u8 = 153;
+    pub spec const SPEC_F64Neg: u8 = 154;
+    pub spec const SPEC_F64Ceil: u8 = 155;
+    pub spec const SPEC_F64Floor: u8 = 156;
+    pub spec const SPEC_F64Trunc: u8 = 157;
+    pub spec const SPEC_F64Nearest: u8 = 158;
+    pub spec const SPEC_F64Sqrt: u8 = 159;
+    pub spec const SPEC_F64Add: u8 = 160;
+    pub spec const SPEC_F64Sub: u8 = 161;
+    pub spec const SPEC_F64Mul: u8 = 162;
+    pub spec const SPEC_F64Div: u8 = 163;
+    pub spec const SPEC_F64Min: u8 = 164;
+    pub spec const SPEC_F64Max: u8 = 165;
+    pub spec const SPEC_F64Copysign: u8 = 166;
+    pub spec const SPEC_I32WrapI64: u8 = 167;
+    pub spec const SPEC_I32TruncF32S: u8 = 168;
+    pub spec const SPEC_I32TruncF32U: u8 = 169;
+    pub spec const SPEC_I32TruncF64S: u8 = 170;
+    pub spec const SPEC_I32TruncF64U: u8 = 171;
+    pub spec const SPEC_I64ExtendI32S: u8 = 172;
+    pub spec const SPEC_I64ExtendI32U: u8 = 173;
+    pub spec const SPEC_I64TruncF32S: u8 = 174;
+    pub spec const SPEC_I64TruncF32U: u8 = 175;
+    pub spec const SPEC_I64TruncF64S: u8 = 176;
+    pub spec const SPEC_I64TruncF64U: u8 = 177;
+    pub spec const SPEC_F32ConvertI32S: u8 = 178;
+    pub spec const SPEC_F32ConvertI32U: u8 = 179;
+    pub spec const SPEC_F32ConvertI64S: u8 = 180;
+    pub spec const SPEC_F32ConvertI64U: u8 = 181;
+    pub spec const SPEC_F32DemoteF64: u8 = 182;
+    pub spec const SPEC_F64ConvertI32S: u8 = 183;
+    pub spec const SPEC_F64ConvertI32U: u8 = 184;
+    pub spec const SPEC_F64ConvertI64S: u8 = 185;
+    pub spec const SPEC_F64ConvertI64U: u8 = 186;
+    pub spec const SPEC_F64PromoteF32: u8 = 187;
+    pub spec const SPEC_I32ReinterpretF32: u8 = 188;
+    pub spec const SPEC_I64ReinterpretF64: u8 = 189;
+    pub spec const SPEC_F32ReinterpretI32: u8 = 190;
+    pub spec const SPEC_F64ReinterpretI64: u8 = 191;
+    pub spec const SPEC_I32Extend8S: u8 = 192;
+    pub spec const SPEC_I32Extend16S: u8 = 193;
+    pub spec const SPEC_I64Extend8S: u8 = 194;
+    pub spec const SPEC_I64Extend16S: u8 = 195;
+    pub spec const SPEC_I64Extend32S: u8 = 196;
+    pub spec const SPEC_OpcodeFD: u8 = 253;
+    pub exec const Unreachable: u8 ensures Unreachable == SPEC_Unreachable { 0 }
+    pub exec const Nop: u8 ensures Nop == SPEC_Nop { 1 }
+    pub exec const Block: u8 ensures Block == SPEC_Block { 2 }
+    pub exec const Loop: u8 ensures Loop == SPEC_Loop { 3 }
+    pub exec const If: u8 ensures If == SPEC_If { 4 }
+    pub exec const Else: u8 ensures Else == SPEC_Else { 5 }
+    pub exec const End: u8 ensures End == SPEC_End { 11 }
+    pub exec const Br: u8 ensures Br == SPEC_Br { 12 }
+    pub exec const BrIf: u8 ensures BrIf == SPEC_BrIf { 13 }
+    pub exec const BrTable: u8 ensures BrTable == SPEC_BrTable { 14 }
+    pub exec const Ret: u8 ensures Ret == SPEC_Ret { 15 }
+    pub exec const Call: u8 ensures Call == SPEC_Call { 16 }
+    pub exec const CallIndirect: u8 ensures CallIndirect == SPEC_CallIndirect { 17 }
+    pub exec const RefNull: u8 ensures RefNull == SPEC_RefNull { 208 }
+    pub exec const RefIsNull: u8 ensures RefIsNull == SPEC_RefIsNull { 209 }
+    pub exec const RefFunc: u8 ensures RefFunc == SPEC_RefFunc { 210 }
+    pub exec const Drop: u8 ensures Drop == SPEC_Drop { 26 }
+    pub exec const Select: u8 ensures Select == SPEC_Select { 27 }
+    pub exec const SelectT: u8 ensures SelectT == SPEC_SelectT { 28 }
+    pub exec const LocalGet: u8 ensures LocalGet == SPEC_LocalGet { 32 }
+    pub exec const LocalSet: u8 ensures LocalSet == SPEC_LocalSet { 33 }
+    pub exec const LocalTee: u8 ensures LocalTee == SPEC_LocalTee { 34 }
+    pub exec const GlobalGet: u8 ensures GlobalGet == SPEC_GlobalGet { 35 }
+    pub exec const GlobalSet: u8 ensures GlobalSet == SPEC_GlobalSet { 36 }
+    pub exec const TableGet: u8 ensures TableGet == SPEC_TableGet { 37 }
+    pub exec const TableSet: u8 ensures TableSet == SPEC_TableSet { 38 }
+    pub exec const OpcodeFC: u8 ensures OpcodeFC == SPEC_OpcodeFC { 252 }
+    pub exec const I32Load: u8 ensures I32Load == SPEC_I32Load { 40 }
+    pub exec const I64Load: u8 ensures I64Load == SPEC_I64Load { 41 }
+    pub exec const F32Load: u8 ensures F32Load == SPEC_F32Load { 42 }
+    pub exec const F64Load: u8 ensures F64Load == SPEC_F64Load { 43 }
+    pub exec const I32Load8S: u8 ensures I32Load8S == SPEC_I32Load8S { 44 }
+    pub exec const I32Load8U: u8 ensures I32Load8U == SPEC_I32Load8U { 45 }
+    pub exec const I32Load16S: u8 ensures I32Load16S == SPEC_I32Load16S { 46 }
+    pub exec const I32Load16U: u8 ensures I32Load16U == SPEC_I32Load16U { 47 }
+    pub exec const I64Load8S: u8 ensures I64Load8S == SPEC_I64Load8S { 48 }
+    pub exec const I64Load8U: u8 ensures I64Load8U == SPEC_I64Load8U { 49 }
+    pub exec const I64Load16S: u8 ensures I64Load16S == SPEC_I64Load16S { 50 }
+    pub exec const I64Load16U: u8 ensures I64Load16U == SPEC_I64Load16U { 51 }
+    pub exec const I64Load32S: u8 ensures I64Load32S == SPEC_I64Load32S { 52 }
+    pub exec const I64Load32U: u8 ensures I64Load32U == SPEC_I64Load32U { 53 }
+    pub exec const I32Store: u8 ensures I32Store == SPEC_I32Store { 54 }
+    pub exec const I64Store: u8 ensures I64Store == SPEC_I64Store { 55 }
+    pub exec const F32Store: u8 ensures F32Store == SPEC_F32Store { 56 }
+    pub exec const F64Store: u8 ensures F64Store == SPEC_F64Store { 57 }
+    pub exec const I32Store8: u8 ensures I32Store8 == SPEC_I32Store8 { 58 }
+    pub exec const I32Store16: u8 ensures I32Store16 == SPEC_I32Store16 { 59 }
+    pub exec const I64Store8: u8 ensures I64Store8 == SPEC_I64Store8 { 60 }
+    pub exec const I64Store16: u8 ensures I64Store16 == SPEC_I64Store16 { 61 }
+    pub exec const I64Store32: u8 ensures I64Store32 == SPEC_I64Store32 { 62 }
+    pub exec const MemorySize: u8 ensures MemorySize == SPEC_MemorySize { 63 }
+    pub exec const MemoryGrow: u8 ensures MemoryGrow == SPEC_MemoryGrow { 64 }
+    pub exec const I32Const: u8 ensures I32Const == SPEC_I32Const { 65 }
+    pub exec const I64Const: u8 ensures I64Const == SPEC_I64Const { 66 }
+    pub exec const F32Const: u8 ensures F32Const == SPEC_F32Const { 67 }
+    pub exec const F64Const: u8 ensures F64Const == SPEC_F64Const { 68 }
+    pub exec const I32Eqz: u8 ensures I32Eqz == SPEC_I32Eqz { 69 }
+    pub exec const I32Eq: u8 ensures I32Eq == SPEC_I32Eq { 70 }
+    pub exec const I32Ne: u8 ensures I32Ne == SPEC_I32Ne { 71 }
+    pub exec const I32LtS: u8 ensures I32LtS == SPEC_I32LtS { 72 }
+    pub exec const I32LtU: u8 ensures I32LtU == SPEC_I32LtU { 73 }
+    pub exec const I32GtS: u8 ensures I32GtS == SPEC_I32GtS { 74 }
+    pub exec const I32GtU: u8 ensures I32GtU == SPEC_I32GtU { 75 }
+    pub exec const I32LeS: u8 ensures I32LeS == SPEC_I32LeS { 76 }
+    pub exec const I32LeU: u8 ensures I32LeU == SPEC_I32LeU { 77 }
+    pub exec const I32GeS: u8 ensures I32GeS == SPEC_I32GeS { 78 }
+    pub exec const I32GeU: u8 ensures I32GeU == SPEC_I32GeU { 79 }
+    pub exec const I64Eqz: u8 ensures I64Eqz == SPEC_I64Eqz { 80 }
+    pub exec const I64Eq: u8 ensures I64Eq == SPEC_I64Eq { 81 }
+    pub exec const I64Ne: u8 ensures I64Ne == SPEC_I64Ne { 82 }
+    pub exec const I64LtS: u8 ensures I64LtS == SPEC_I64LtS { 83 }
+    pub exec const I64LtU: u8 ensures I64LtU == SPEC_I64LtU { 84 }
+    pub exec const I64GtS: u8 ensures I64GtS == SPEC_I64GtS { 85 }
+    pub exec const I64GtU: u8 ensures I64GtU == SPEC_I64GtU { 86 }
+    pub exec const I64LeS: u8 ensures I64LeS == SPEC_I64LeS { 87 }
+    pub exec const I64LeU: u8 ensures I64LeU == SPEC_I64LeU { 88 }
+    pub exec const I64GeS: u8 ensures I64GeS == SPEC_I64GeS { 89 }
+    pub exec const I64GeU: u8 ensures I64GeU == SPEC_I64GeU { 90 }
+    pub exec const F32Eq: u8 ensures F32Eq == SPEC_F32Eq { 91 }
+    pub exec const F32Ne: u8 ensures F32Ne == SPEC_F32Ne { 92 }
+    pub exec const F32Lt: u8 ensures F32Lt == SPEC_F32Lt { 93 }
+    pub exec const F32Gt: u8 ensures F32Gt == SPEC_F32Gt { 94 }
+    pub exec const F32Le: u8 ensures F32Le == SPEC_F32Le { 95 }
+    pub exec const F32Ge: u8 ensures F32Ge == SPEC_F32Ge { 96 }
+    pub exec const F64Eq: u8 ensures F64Eq == SPEC_F64Eq { 97 }
+    pub exec const F64Ne: u8 ensures F64Ne == SPEC_F64Ne { 98 }
+    pub exec const F64Lt: u8 ensures F64Lt == SPEC_F64Lt { 99 }
+    pub exec const F64Gt: u8 ensures F64Gt == SPEC_F64Gt { 100 }
+    pub exec const F64Le: u8 ensures F64Le == SPEC_F64Le { 101 }
+    pub exec const F64Ge: u8 ensures F64Ge == SPEC_F64Ge { 102 }
+    pub exec const I32Clz: u8 ensures I32Clz == SPEC_I32Clz { 103 }
+    pub exec const I32Ctz: u8 ensures I32Ctz == SPEC_I32Ctz { 104 }
+    pub exec const I32Popcnt: u8 ensures I32Popcnt == SPEC_I32Popcnt { 105 }
+    pub exec const I32Add: u8 ensures I32Add == SPEC_I32Add { 106 }
+    pub exec const I32Sub: u8 ensures I32Sub == SPEC_I32Sub { 107 }
+    pub exec const I32Mul: u8 ensures I32Mul == SPEC_I32Mul { 108 }
+    pub exec const I32DivS: u8 ensures I32DivS == SPEC_I32DivS { 109 }
+    pub exec const I32DivU: u8 ensures I32DivU == SPEC_I32DivU { 110 }
+    pub exec const I32RemS: u8 ensures I32RemS == SPEC_I32RemS { 111 }
+    pub exec const I32RemU: u8 ensures I32RemU == SPEC_I32RemU { 112 }
+    pub exec const I32And: u8 ensures I32And == SPEC_I32And { 113 }
+    pub exec const I32Or: u8 ensures I32Or == SPEC_I32Or { 114 }
+    pub exec const I32Xor: u8 ensures I32Xor == SPEC_I32Xor { 115 }
+    pub exec const I32Shl: u8 ensures I32Shl == SPEC_I32Shl { 116 }
+    pub exec const I32ShrS: u8 ensures I32ShrS == SPEC_I32ShrS { 117 }
+    pub exec const I32ShrU: u8 ensures I32ShrU == SPEC_I32ShrU { 118 }
+    pub exec const I32Rotl: u8 ensures I32Rotl == SPEC_I32Rotl { 119 }
+    pub exec const I32Rotr: u8 ensures I32Rotr == SPEC_I32Rotr { 120 }
+    pub exec const I64Clz: u8 ensures I64Clz == SPEC_I64Clz { 121 }
+    pub exec const I64Ctz: u8 ensures I64Ctz == SPEC_I64Ctz { 122 }
+    pub exec const I64Popcnt: u8 ensures I64Popcnt == SPEC_I64Popcnt { 123 }
+    pub exec const I64Add: u8 ensures I64Add == SPEC_I64Add { 124 }
+    pub exec const I64Sub: u8 ensures I64Sub == SPEC_I64Sub { 125 }
+    pub exec const I64Mul: u8 ensures I64Mul == SPEC_I64Mul { 126 }
+    pub exec const I64DivS: u8 ensures I64DivS == SPEC_I64DivS { 127 }
+    pub exec const I64DivU: u8 ensures I64DivU == SPEC_I64DivU { 128 }
+    pub exec const I64RemS: u8 ensures I64RemS == SPEC_I64RemS { 129 }
+    pub exec const I64RemU: u8 ensures I64RemU == SPEC_I64RemU { 130 }
+    pub exec const I64And: u8 ensures I64And == SPEC_I64And { 131 }
+    pub exec const I64Or: u8 ensures I64Or == SPEC_I64Or { 132 }
+    pub exec const I64Xor: u8 ensures I64Xor == SPEC_I64Xor { 133 }
+    pub exec const I64Shl: u8 ensures I64Shl == SPEC_I64Shl { 134 }
+    pub exec const I64ShrS: u8 ensures I64ShrS == SPEC_I64ShrS { 135 }
+    pub exec const I64ShrU: u8 ensures I64ShrU == SPEC_I64ShrU { 136 }
+    pub exec const I64Rotl: u8 ensures I64Rotl == SPEC_I64Rotl { 137 }
+    pub exec const I64Rotr: u8 ensures I64Rotr == SPEC_I64Rotr { 138 }
+    pub exec const F32Abs: u8 ensures F32Abs == SPEC_F32Abs { 139 }
+    pub exec const F32Neg: u8 ensures F32Neg == SPEC_F32Neg { 140 }
+    pub exec const F32Ceil: u8 ensures F32Ceil == SPEC_F32Ceil { 141 }
+    pub exec const F32Floor: u8 ensures F32Floor == SPEC_F32Floor { 142 }
+    pub exec const F32Trunc: u8 ensures F32Trunc == SPEC_F32Trunc { 143 }
+    pub exec const F32Nearest: u8 ensures F32Nearest == SPEC_F32Nearest { 144 }
+    pub exec const F32Sqrt: u8 ensures F32Sqrt == SPEC_F32Sqrt { 145 }
+    pub exec const F32Add: u8 ensures F32Add == SPEC_F32Add { 146 }
+    pub exec const F32Sub: u8 ensures F32Sub == SPEC_F32Sub { 147 }
+    pub exec const F32Mul: u8 ensures F32Mul == SPEC_F32Mul { 148 }
+    pub exec const F32Div: u8 ensures F32Div == SPEC_F32Div { 149 }
+    pub exec const F32Min: u8 ensures F32Min == SPEC_F32Min { 150 }
+    pub exec const F32Max: u8 ensures F32Max == SPEC_F32Max { 151 }
+    pub exec const F32Copysign: u8 ensures F32Copysign == SPEC_F32Copysign { 152 }
+    pub exec const F64Abs: u8 ensures F64Abs == SPEC_F64Abs { 153 }
+    pub exec const F64Neg: u8 ensures F64Neg == SPEC_F64Neg { 154 }
+    pub exec const F64Ceil: u8 ensures F64Ceil == SPEC_F64Ceil { 155 }
+    pub exec const F64Floor: u8 ensures F64Floor == SPEC_F64Floor { 156 }
+    pub exec const F64Trunc: u8 ensures F64Trunc == SPEC_F64Trunc { 157 }
+    pub exec const F64Nearest: u8 ensures F64Nearest == SPEC_F64Nearest { 158 }
+    pub exec const F64Sqrt: u8 ensures F64Sqrt == SPEC_F64Sqrt { 159 }
+    pub exec const F64Add: u8 ensures F64Add == SPEC_F64Add { 160 }
+    pub exec const F64Sub: u8 ensures F64Sub == SPEC_F64Sub { 161 }
+    pub exec const F64Mul: u8 ensures F64Mul == SPEC_F64Mul { 162 }
+    pub exec const F64Div: u8 ensures F64Div == SPEC_F64Div { 163 }
+    pub exec const F64Min: u8 ensures F64Min == SPEC_F64Min { 164 }
+    pub exec const F64Max: u8 ensures F64Max == SPEC_F64Max { 165 }
+    pub exec const F64Copysign: u8 ensures F64Copysign == SPEC_F64Copysign { 166 }
+    pub exec const I32WrapI64: u8 ensures I32WrapI64 == SPEC_I32WrapI64 { 167 }
+    pub exec const I32TruncF32S: u8 ensures I32TruncF32S == SPEC_I32TruncF32S { 168 }
+    pub exec const I32TruncF32U: u8 ensures I32TruncF32U == SPEC_I32TruncF32U { 169 }
+    pub exec const I32TruncF64S: u8 ensures I32TruncF64S == SPEC_I32TruncF64S { 170 }
+    pub exec const I32TruncF64U: u8 ensures I32TruncF64U == SPEC_I32TruncF64U { 171 }
+    pub exec const I64ExtendI32S: u8 ensures I64ExtendI32S == SPEC_I64ExtendI32S { 172 }
+    pub exec const I64ExtendI32U: u8 ensures I64ExtendI32U == SPEC_I64ExtendI32U { 173 }
+    pub exec const I64TruncF32S: u8 ensures I64TruncF32S == SPEC_I64TruncF32S { 174 }
+    pub exec const I64TruncF32U: u8 ensures I64TruncF32U == SPEC_I64TruncF32U { 175 }
+    pub exec const I64TruncF64S: u8 ensures I64TruncF64S == SPEC_I64TruncF64S { 176 }
+    pub exec const I64TruncF64U: u8 ensures I64TruncF64U == SPEC_I64TruncF64U { 177 }
+    pub exec const F32ConvertI32S: u8 ensures F32ConvertI32S == SPEC_F32ConvertI32S { 178 }
+    pub exec const F32ConvertI32U: u8 ensures F32ConvertI32U == SPEC_F32ConvertI32U { 179 }
+    pub exec const F32ConvertI64S: u8 ensures F32ConvertI64S == SPEC_F32ConvertI64S { 180 }
+    pub exec const F32ConvertI64U: u8 ensures F32ConvertI64U == SPEC_F32ConvertI64U { 181 }
+    pub exec const F32DemoteF64: u8 ensures F32DemoteF64 == SPEC_F32DemoteF64 { 182 }
+    pub exec const F64ConvertI32S: u8 ensures F64ConvertI32S == SPEC_F64ConvertI32S { 183 }
+    pub exec const F64ConvertI32U: u8 ensures F64ConvertI32U == SPEC_F64ConvertI32U { 184 }
+    pub exec const F64ConvertI64S: u8 ensures F64ConvertI64S == SPEC_F64ConvertI64S { 185 }
+    pub exec const F64ConvertI64U: u8 ensures F64ConvertI64U == SPEC_F64ConvertI64U { 186 }
+    pub exec const F64PromoteF32: u8 ensures F64PromoteF32 == SPEC_F64PromoteF32 { 187 }
+    pub exec const I32ReinterpretF32: u8 ensures I32ReinterpretF32 == SPEC_I32ReinterpretF32 { 188 }
+    pub exec const I64ReinterpretF64: u8 ensures I64ReinterpretF64 == SPEC_I64ReinterpretF64 { 189 }
+    pub exec const F32ReinterpretI32: u8 ensures F32ReinterpretI32 == SPEC_F32ReinterpretI32 { 190 }
+    pub exec const F64ReinterpretI64: u8 ensures F64ReinterpretI64 == SPEC_F64ReinterpretI64 { 191 }
+    pub exec const I32Extend8S: u8 ensures I32Extend8S == SPEC_I32Extend8S { 192 }
+    pub exec const I32Extend16S: u8 ensures I32Extend16S == SPEC_I32Extend16S { 193 }
+    pub exec const I64Extend8S: u8 ensures I64Extend8S == SPEC_I64Extend8S { 194 }
+    pub exec const I64Extend16S: u8 ensures I64Extend16S == SPEC_I64Extend16S { 195 }
+    pub exec const I64Extend32S: u8 ensures I64Extend32S == SPEC_I64Extend32S { 196 }
+    pub exec const OpcodeFD: u8 ensures OpcodeFD == SPEC_OpcodeFD { 253 }
+}
 
-impl From<BrTableInner> for BrTable {
-    fn ex_from(m: BrTableInner) -> BrTable {
-        let (l, l_n) = m;
-        BrTable { l, l_n }
-    }
-}
 
-pub struct BrTableMapper;
-impl View for BrTableMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for BrTableMapper {
-    type Src = SpecBrTableInner;
-    type Dst = SpecBrTable;
-}
-impl SpecIsoProof for BrTableMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for BrTableMapper {
-    type Src = BrTableInner;
-    type Dst = BrTable;
-    type RefSrc = BrTableInnerRef<'a>;
-}
-type SpecBrTableCombinatorAlias1 = (SpecLabelidxVecCombinator, SpecLabelidxCombinator);
-pub struct SpecBrTableCombinator(pub SpecBrTableCombinatorAlias);
+pub struct SpecInstrBytecodeCombinator(pub SpecInstrBytecodeCombinatorAlias);
 
-impl SpecCombinator for SpecBrTableCombinator {
-    type Type = SpecBrTable;
+impl SpecCombinator for SpecInstrBytecodeCombinator {
+    type Type = u8;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecBrTableCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecBrTableCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecInstrBytecodeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecInstrBytecodeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecBrTableCombinatorAlias = Mapped<SpecBrTableCombinatorAlias1, BrTableMapper>;
-type BrTableCombinatorAlias1 = (LabelidxVecCombinator, LabelidxCombinator);
-pub struct BrTableCombinator1(pub BrTableCombinatorAlias1);
-impl View for BrTableCombinator1 {
-    type V = SpecBrTableCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(BrTableCombinator1, BrTableCombinatorAlias1);
+pub type SpecInstrBytecodeCombinatorAlias = U8;
 
-pub struct BrTableCombinator(pub BrTableCombinatorAlias);
+pub struct InstrBytecodeCombinator(pub InstrBytecodeCombinatorAlias);
 
-impl View for BrTableCombinator {
-    type V = SpecBrTableCombinator;
-    open spec fn view(&self) -> Self::V { SpecBrTableCombinator(self.0@) }
+impl View for InstrBytecodeCombinator {
+    type V = SpecInstrBytecodeCombinator;
+    open spec fn view(&self) -> Self::V { SpecInstrBytecodeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for BrTableCombinator {
-    type Type = BrTable;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrBytecodeCombinator {
+    type Type = u8;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type BrTableCombinatorAlias = Mapped<BrTableCombinator1, BrTableMapper>;
+}
+pub type InstrBytecodeCombinatorAlias = U8;
 
 
-pub open spec fn spec_br_table() -> SpecBrTableCombinator {
-    SpecBrTableCombinator(
-    Mapped {
-        inner: (spec_labelidx_vec(), spec_labelidx()),
-        mapper: BrTableMapper,
-    })
+pub open spec fn spec_instr_bytecode() -> SpecInstrBytecodeCombinator {
+    SpecInstrBytecodeCombinator(U8)
 }
 
                 
-pub fn br_table<'a>() -> (o: BrTableCombinator)
-    ensures o@ == spec_br_table(),
+pub fn instr_bytecode<'a>() -> (o: InstrBytecodeCombinator)
+    ensures o@ == spec_instr_bytecode(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = BrTableCombinator(
-    Mapped {
-        inner: BrTableCombinator1((labelidx_vec(), labelidx())),
-        mapper: BrTableMapper,
-    });
-    assert({
-        &&& combinator@ == spec_br_table()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = InstrBytecodeCombinator(U8);
+    // assert({
+    //     &&& combinator@ == spec_instr_bytecode()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_br_table<'a>(input: &'a [u8]) -> (res: PResult<<BrTableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_instr_bytecode<'a>(input: &'a [u8]) -> (res: PResult<<InstrBytecodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_br_table().spec_parse(input@) == Some((n as int, v@)),
-        spec_br_table().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_instr_bytecode().spec_parse(input@) == Some((n as int, v@)),
+        spec_instr_bytecode().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_br_table().spec_parse(input@) is None,
-        spec_br_table().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_instr_bytecode().spec_parse(input@) is None,
+        spec_instr_bytecode().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = br_table();
+    let combinator = instr_bytecode();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_br_table<'a>(v: <BrTableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_instr_bytecode<'a>(v: <InstrBytecodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_br_table().wf(v@),
+        spec_instr_bytecode().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_br_table().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_br_table().spec_serialize(v@))
+            &&& n == spec_instr_bytecode().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_instr_bytecode().spec_serialize(v@))
         },
 {
-    let combinator = br_table();
+    let combinator = instr_bytecode();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn br_table_len<'a>(v: <BrTableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn instr_bytecode_len<'a>(v: <InstrBytecodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_br_table().wf(v@),
-        spec_br_table().spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_bytecode().wf(v@),
+        spec_instr_bytecode().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_br_table().spec_serialize(v@).len(),
+        serialize_len == spec_instr_bytecode().spec_serialize(v@).len(),
 {
-    let combinator = br_table();
+    let combinator = instr_bytecode();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub type SpecTypeidx = u64;
-pub type Typeidx = u64;
-pub type TypeidxRef<'a> = &'a u64;
+pub type SpecLocalidx = u64;
+pub type Localidx = u64;
+pub type LocalidxRef<'a> = &'a u64;
 
 
-pub struct SpecTypeidxCombinator(pub SpecTypeidxCombinatorAlias);
+pub struct SpecLocalidxCombinator(pub SpecLocalidxCombinatorAlias);
 
-impl SpecCombinator for SpecTypeidxCombinator {
-    type Type = SpecTypeidx;
+impl SpecCombinator for SpecLocalidxCombinator {
+    type Type = SpecLocalidx;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTypeidxCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTypeidxCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecLocalidxCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecLocalidxCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTypeidxCombinatorAlias = UnsignedLEB128;
+pub type SpecLocalidxCombinatorAlias = UnsignedLEB128;
 
-pub struct TypeidxCombinator(pub TypeidxCombinatorAlias);
+pub struct LocalidxCombinator(pub LocalidxCombinatorAlias);
 
-impl View for TypeidxCombinator {
-    type V = SpecTypeidxCombinator;
-    open spec fn view(&self) -> Self::V { SpecTypeidxCombinator(self.0@) }
+impl View for LocalidxCombinator {
+    type V = SpecLocalidxCombinator;
+    open spec fn view(&self) -> Self::V { SpecLocalidxCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TypeidxCombinator {
-    type Type = Typeidx;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LocalidxCombinator {
+    type Type = Localidx;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TypeidxCombinatorAlias = UnsignedLEB128;
+}
+pub type LocalidxCombinatorAlias = UnsignedLEB128;
 
 
-pub open spec fn spec_typeidx() -> SpecTypeidxCombinator {
-    SpecTypeidxCombinator(UnsignedLEB128)
+pub open spec fn spec_localidx() -> SpecLocalidxCombinator {
+    SpecLocalidxCombinator(UnsignedLEB128)
 }
 
                 
-pub fn typeidx<'a>() -> (o: TypeidxCombinator)
-    ensures o@ == spec_typeidx(),
+pub fn localidx<'a>() -> (o: LocalidxCombinator)
+    ensures o@ == spec_localidx(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = TypeidxCombinator(UnsignedLEB128);
-    assert({
-        &&& combinator@ == spec_typeidx()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = LocalidxCombinator(UnsignedLEB128);
+    // assert({
+    //     &&& combinator@ == spec_localidx()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_typeidx<'a>(input: &'a [u8]) -> (res: PResult<<TypeidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_localidx<'a>(input: &'a [u8]) -> (res: PResult<<LocalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_typeidx().spec_parse(input@) == Some((n as int, v@)),
-        spec_typeidx().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_localidx().spec_parse(input@) == Some((n as int, v@)),
+        spec_localidx().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_typeidx().spec_parse(input@) is None,
-        spec_typeidx().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_localidx().spec_parse(input@) is None,
+        spec_localidx().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = typeidx();
+    let combinator = localidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_typeidx<'a>(v: <TypeidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_localidx<'a>(v: <LocalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_typeidx().wf(v@),
+        spec_localidx().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_typeidx().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_typeidx().spec_serialize(v@))
+            &&& n == spec_localidx().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_localidx().spec_serialize(v@))
         },
 {
-    let combinator = typeidx();
+    let combinator = localidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn typeidx_len<'a>(v: <TypeidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn localidx_len<'a>(v: <LocalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_typeidx().wf(v@),
-        spec_typeidx().spec_serialize(v@).len() <= usize::MAX,
+        spec_localidx().wf(v@),
+        spec_localidx().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_typeidx().spec_serialize(v@).len(),
+        serialize_len == spec_localidx().spec_serialize(v@).len(),
 {
-    let combinator = typeidx();
+    let combinator = localidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub type SpecTableidx = u64;
-pub type Tableidx = u64;
-pub type TableidxRef<'a> = &'a u64;
+pub type SpecGlobalidx = u64;
+pub type Globalidx = u64;
+pub type GlobalidxRef<'a> = &'a u64;
 
 
-pub struct SpecTableidxCombinator(pub SpecTableidxCombinatorAlias);
+pub struct SpecGlobalidxCombinator(pub SpecGlobalidxCombinatorAlias);
 
-impl SpecCombinator for SpecTableidxCombinator {
-    type Type = SpecTableidx;
+impl SpecCombinator for SpecGlobalidxCombinator {
+    type Type = SpecGlobalidx;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTableidxCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTableidxCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecGlobalidxCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecGlobalidxCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTableidxCombinatorAlias = UnsignedLEB128;
+pub type SpecGlobalidxCombinatorAlias = UnsignedLEB128;
 
-pub struct TableidxCombinator(pub TableidxCombinatorAlias);
+pub struct GlobalidxCombinator(pub GlobalidxCombinatorAlias);
 
-impl View for TableidxCombinator {
-    type V = SpecTableidxCombinator;
-    open spec fn view(&self) -> Self::V { SpecTableidxCombinator(self.0@) }
+impl View for GlobalidxCombinator {
+    type V = SpecGlobalidxCombinator;
+    open spec fn view(&self) -> Self::V { SpecGlobalidxCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TableidxCombinator {
-    type Type = Tableidx;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GlobalidxCombinator {
+    type Type = Globalidx;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TableidxCombinatorAlias = UnsignedLEB128;
+}
+pub type GlobalidxCombinatorAlias = UnsignedLEB128;
 
 
-pub open spec fn spec_tableidx() -> SpecTableidxCombinator {
-    SpecTableidxCombinator(UnsignedLEB128)
+pub open spec fn spec_globalidx() -> SpecGlobalidxCombinator {
+    SpecGlobalidxCombinator(UnsignedLEB128)
 }
 
                 
-pub fn tableidx<'a>() -> (o: TableidxCombinator)
-    ensures o@ == spec_tableidx(),
+pub fn globalidx<'a>() -> (o: GlobalidxCombinator)
+    ensures o@ == spec_globalidx(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = TableidxCombinator(UnsignedLEB128);
-    assert({
-        &&& combinator@ == spec_tableidx()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = GlobalidxCombinator(UnsignedLEB128);
+    // assert({
+    //     &&& combinator@ == spec_globalidx()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_tableidx<'a>(input: &'a [u8]) -> (res: PResult<<TableidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_globalidx<'a>(input: &'a [u8]) -> (res: PResult<<GlobalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_tableidx().spec_parse(input@) == Some((n as int, v@)),
-        spec_tableidx().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_globalidx().spec_parse(input@) == Some((n as int, v@)),
+        spec_globalidx().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_tableidx().spec_parse(input@) is None,
-        spec_tableidx().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_globalidx().spec_parse(input@) is None,
+        spec_globalidx().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = tableidx();
+    let combinator = globalidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_tableidx<'a>(v: <TableidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_globalidx<'a>(v: <GlobalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_tableidx().wf(v@),
+        spec_globalidx().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_tableidx().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_tableidx().spec_serialize(v@))
+            &&& n == spec_globalidx().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_globalidx().spec_serialize(v@))
         },
 {
-    let combinator = tableidx();
+    let combinator = globalidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn tableidx_len<'a>(v: <TableidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn globalidx_len<'a>(v: <GlobalidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_tableidx().wf(v@),
-        spec_tableidx().spec_serialize(v@).len() <= usize::MAX,
+        spec_globalidx().wf(v@),
+        spec_globalidx().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_tableidx().spec_serialize(v@).len(),
+        serialize_len == spec_globalidx().spec_serialize(v@).len(),
 {
-    let combinator = tableidx();
+    let combinator = globalidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecCallIndirect {
-    pub y: SpecTypeidx,
-    pub x: SpecTableidx,
+pub enum SpecInstrVariable {
+    LocalGet(SpecLocalidx),
+    LocalSet(SpecLocalidx),
+    LocalTee(SpecLocalidx),
+    GlobalGet(SpecGlobalidx),
+    GlobalSet(SpecGlobalidx),
 }
 
-pub type SpecCallIndirectInner = (SpecTypeidx, SpecTableidx);
-
+pub type SpecInstrVariableInner = Either<SpecLocalidx, Either<SpecLocalidx, Either<SpecLocalidx, Either<SpecGlobalidx, SpecGlobalidx>>>>;
 
-impl SpecFrom<SpecCallIndirect> for SpecCallIndirectInner {
-    open spec fn spec_from(m: SpecCallIndirect) -> SpecCallIndirectInner {
-        (m.y, m.x)
+impl SpecFrom<SpecInstrVariable> for SpecInstrVariableInner {
+    open spec fn spec_from(m: SpecInstrVariable) -> SpecInstrVariableInner {
+        match m {
+            SpecInstrVariable::LocalGet(m) => Either::Left(m),
+            SpecInstrVariable::LocalSet(m) => Either::Right(Either::Left(m)),
+            SpecInstrVariable::LocalTee(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecInstrVariable::GlobalGet(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecInstrVariable::GlobalSet(m) => Either::Right(Either::Right(Either::Right(Either::Right(m)))),
+        }
     }
+
 }
 
-impl SpecFrom<SpecCallIndirectInner> for SpecCallIndirect {
-    open spec fn spec_from(m: SpecCallIndirectInner) -> SpecCallIndirect {
-        let (y, x) = m;
-        SpecCallIndirect { y, x }
+                
+impl SpecFrom<SpecInstrVariableInner> for SpecInstrVariable {
+    open spec fn spec_from(m: SpecInstrVariableInner) -> SpecInstrVariable {
+        match m {
+            Either::Left(m) => SpecInstrVariable::LocalGet(m),
+            Either::Right(Either::Left(m)) => SpecInstrVariable::LocalSet(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecInstrVariable::LocalTee(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecInstrVariable::GlobalGet(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(m)))) => SpecInstrVariable::GlobalSet(m),
+        }
     }
+
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CallIndirect {
-    pub y: Typeidx,
-    pub x: Tableidx,
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum InstrVariable {
+    LocalGet(Localidx),
+    LocalSet(Localidx),
+    LocalTee(Localidx),
+    GlobalGet(Globalidx),
+    GlobalSet(Globalidx),
 }
 
-impl View for CallIndirect {
-    type V = SpecCallIndirect;
+pub type InstrVariableInner = Either<Localidx, Either<Localidx, Either<Localidx, Either<Globalidx, Globalidx>>>>;
 
+pub type InstrVariableInnerRef<'a> = Either<&'a Localidx, Either<&'a Localidx, Either<&'a Localidx, Either<&'a Globalidx, &'a Globalidx>>>>;
+
+
+impl View for InstrVariable {
+    type V = SpecInstrVariable;
     open spec fn view(&self) -> Self::V {
-        SpecCallIndirect {
-            y: self.y@,
-            x: self.x@,
+        match self {
+            InstrVariable::LocalGet(m) => SpecInstrVariable::LocalGet(m@),
+            InstrVariable::LocalSet(m) => SpecInstrVariable::LocalSet(m@),
+            InstrVariable::LocalTee(m) => SpecInstrVariable::LocalTee(m@),
+            InstrVariable::GlobalGet(m) => SpecInstrVariable::GlobalGet(m@),
+            InstrVariable::GlobalSet(m) => SpecInstrVariable::GlobalSet(m@),
         }
     }
 }
-pub type CallIndirectInner = (Typeidx, Tableidx);
 
-pub type CallIndirectInnerRef<'a> = (&'a Typeidx, &'a Tableidx);
-impl<'a> From<&'a CallIndirect> for CallIndirectInnerRef<'a> {
-    fn ex_from(m: &'a CallIndirect) -> CallIndirectInnerRef<'a> {
-        (&m.y, &m.x)
+
+impl<'a> From<&'a InstrVariable> for InstrVariableInnerRef<'a> {
+    fn ex_from(m: &'a InstrVariable) -> InstrVariableInnerRef<'a> {
+        match m {
+            InstrVariable::LocalGet(m) => Either::Left(m),
+            InstrVariable::LocalSet(m) => Either::Right(Either::Left(m)),
+            InstrVariable::LocalTee(m) => Either::Right(Either::Right(Either::Left(m))),
+            InstrVariable::GlobalGet(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            InstrVariable::GlobalSet(m) => Either::Right(Either::Right(Either::Right(Either::Right(m)))),
+        }
     }
+
 }
 
-impl From<CallIndirectInner> for CallIndirect {
-    fn ex_from(m: CallIndirectInner) -> CallIndirect {
-        let (y, x) = m;
-        CallIndirect { y, x }
+impl From<InstrVariableInner> for InstrVariable {
+    fn ex_from(m: InstrVariableInner) -> InstrVariable {
+        match m {
+            Either::Left(m) => InstrVariable::LocalGet(m),
+            Either::Right(Either::Left(m)) => InstrVariable::LocalSet(m),
+            Either::Right(Either::Right(Either::Left(m))) => InstrVariable::LocalTee(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => InstrVariable::GlobalGet(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(m)))) => InstrVariable::GlobalSet(m),
+        }
     }
+    
 }
 
-pub struct CallIndirectMapper;
-impl View for CallIndirectMapper {
+
+pub struct InstrVariableMapper;
+impl View for InstrVariableMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CallIndirectMapper {
-    type Src = SpecCallIndirectInner;
-    type Dst = SpecCallIndirect;
+impl SpecIso for InstrVariableMapper {
+    type Src = SpecInstrVariableInner;
+    type Dst = SpecInstrVariable;
 }
-impl SpecIsoProof for CallIndirectMapper {
+impl SpecIsoProof for InstrVariableMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -2136,504 +2631,469 @@ impl SpecIsoProof for CallIndirectMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CallIndirectMapper {
-    type Src = CallIndirectInner;
-    type Dst = CallIndirect;
-    type RefSrc = CallIndirectInnerRef<'a>;
+impl<'a> Iso<'a> for InstrVariableMapper {
+    type Src = InstrVariableInner;
+    type Dst = InstrVariable;
+    type RefSrc = InstrVariableInnerRef<'a>;
 }
-type SpecCallIndirectCombinatorAlias1 = (SpecTypeidxCombinator, SpecTableidxCombinator);
-pub struct SpecCallIndirectCombinator(pub SpecCallIndirectCombinatorAlias);
 
-impl SpecCombinator for SpecCallIndirectCombinator {
-    type Type = SpecCallIndirect;
+type SpecInstrVariableCombinatorAlias1 = Choice<Cond<SpecGlobalidxCombinator>, Cond<SpecGlobalidxCombinator>>;
+type SpecInstrVariableCombinatorAlias2 = Choice<Cond<SpecLocalidxCombinator>, SpecInstrVariableCombinatorAlias1>;
+type SpecInstrVariableCombinatorAlias3 = Choice<Cond<SpecLocalidxCombinator>, SpecInstrVariableCombinatorAlias2>;
+type SpecInstrVariableCombinatorAlias4 = Choice<Cond<SpecLocalidxCombinator>, SpecInstrVariableCombinatorAlias3>;
+pub struct SpecInstrVariableCombinator(pub SpecInstrVariableCombinatorAlias);
+
+impl SpecCombinator for SpecInstrVariableCombinator {
+    type Type = SpecInstrVariable;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCallIndirectCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCallIndirectCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecInstrVariableCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecInstrVariableCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCallIndirectCombinatorAlias = Mapped<SpecCallIndirectCombinatorAlias1, CallIndirectMapper>;
-type CallIndirectCombinatorAlias1 = (TypeidxCombinator, TableidxCombinator);
-pub struct CallIndirectCombinator1(pub CallIndirectCombinatorAlias1);
-impl View for CallIndirectCombinator1 {
-    type V = SpecCallIndirectCombinatorAlias1;
+pub type SpecInstrVariableCombinatorAlias = Mapped<SpecInstrVariableCombinatorAlias4, InstrVariableMapper>;
+type InstrVariableCombinatorAlias1 = Choice<Cond<GlobalidxCombinator>, Cond<GlobalidxCombinator>>;
+type InstrVariableCombinatorAlias2 = Choice<Cond<LocalidxCombinator>, InstrVariableCombinator1>;
+type InstrVariableCombinatorAlias3 = Choice<Cond<LocalidxCombinator>, InstrVariableCombinator2>;
+type InstrVariableCombinatorAlias4 = Choice<Cond<LocalidxCombinator>, InstrVariableCombinator3>;
+pub struct InstrVariableCombinator1(pub InstrVariableCombinatorAlias1);
+impl View for InstrVariableCombinator1 {
+    type V = SpecInstrVariableCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(CallIndirectCombinator1, CallIndirectCombinatorAlias1);
+impl_wrapper_combinator!(InstrVariableCombinator1, InstrVariableCombinatorAlias1);
 
-pub struct CallIndirectCombinator(pub CallIndirectCombinatorAlias);
+pub struct InstrVariableCombinator2(pub InstrVariableCombinatorAlias2);
+impl View for InstrVariableCombinator2 {
+    type V = SpecInstrVariableCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(InstrVariableCombinator2, InstrVariableCombinatorAlias2);
 
-impl View for CallIndirectCombinator {
-    type V = SpecCallIndirectCombinator;
-    open spec fn view(&self) -> Self::V { SpecCallIndirectCombinator(self.0@) }
+pub struct InstrVariableCombinator3(pub InstrVariableCombinatorAlias3);
+impl View for InstrVariableCombinator3 {
+    type V = SpecInstrVariableCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CallIndirectCombinator {
-    type Type = CallIndirect;
+impl_wrapper_combinator!(InstrVariableCombinator3, InstrVariableCombinatorAlias3);
+
+pub struct InstrVariableCombinator4(pub InstrVariableCombinatorAlias4);
+impl View for InstrVariableCombinator4 {
+    type V = SpecInstrVariableCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(InstrVariableCombinator4, InstrVariableCombinatorAlias4);
+
+pub struct InstrVariableCombinator(pub InstrVariableCombinatorAlias);
+
+impl View for InstrVariableCombinator {
+    type V = SpecInstrVariableCombinator;
+    open spec fn view(&self) -> Self::V { SpecInstrVariableCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrVariableCombinator {
+    type Type = InstrVariable;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CallIndirectCombinatorAlias = Mapped<CallIndirectCombinator1, CallIndirectMapper>;
+}
+pub type InstrVariableCombinatorAlias = Mapped<InstrVariableCombinator4, InstrVariableMapper>;
 
 
-pub open spec fn spec_call_indirect() -> SpecCallIndirectCombinator {
-    SpecCallIndirectCombinator(
-    Mapped {
-        inner: (spec_typeidx(), spec_tableidx()),
-        mapper: CallIndirectMapper,
-    })
+pub open spec fn spec_instr_variable(opcode: u8) -> SpecInstrVariableCombinator {
+    SpecInstrVariableCombinator(Mapped { inner: Choice(Cond { cond: opcode == InstrBytecode::SPEC_LocalGet, inner: spec_localidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_LocalSet, inner: spec_localidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_LocalTee, inner: spec_localidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_GlobalGet, inner: spec_globalidx() }, Cond { cond: opcode == InstrBytecode::SPEC_GlobalSet, inner: spec_globalidx() })))), mapper: InstrVariableMapper })
 }
 
-                
-pub fn call_indirect<'a>() -> (o: CallIndirectCombinator)
-    ensures o@ == spec_call_indirect(),
+pub fn instr_variable<'a>(opcode: u8) -> (o: InstrVariableCombinator)
+    requires
+        spec_instr_bytecode().wf(opcode@),
+
+    ensures o@ == spec_instr_variable(opcode@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CallIndirectCombinator(
-    Mapped {
-        inner: CallIndirectCombinator1((typeidx(), tableidx())),
-        mapper: CallIndirectMapper,
-    });
-    assert({
-        &&& combinator@ == spec_call_indirect()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = InstrVariableCombinator(Mapped { inner: InstrVariableCombinator4(Choice::new(Cond { cond: opcode == InstrBytecode::LocalGet, inner: localidx() }, InstrVariableCombinator3(Choice::new(Cond { cond: opcode == InstrBytecode::LocalSet, inner: localidx() }, InstrVariableCombinator2(Choice::new(Cond { cond: opcode == InstrBytecode::LocalTee, inner: localidx() }, InstrVariableCombinator1(Choice::new(Cond { cond: opcode == InstrBytecode::GlobalGet, inner: globalidx() }, Cond { cond: opcode == InstrBytecode::GlobalSet, inner: globalidx() })))))))), mapper: InstrVariableMapper });
+    // assert({
+    //     &&& combinator@ == spec_instr_variable(opcode@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_call_indirect<'a>(input: &'a [u8]) -> (res: PResult<<CallIndirectCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_instr_variable<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrVariableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_call_indirect().spec_parse(input@) == Some((n as int, v@)),
-        spec_call_indirect().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_instr_variable(opcode@).spec_parse(input@) == Some((n as int, v@)),
+        spec_instr_variable(opcode@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_call_indirect().spec_parse(input@) is None,
-        spec_call_indirect().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_instr_variable(opcode@).spec_parse(input@) is None,
+        spec_instr_variable(opcode@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = call_indirect();
+    let combinator = instr_variable( opcode );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_call_indirect<'a>(v: <CallIndirectCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_instr_variable<'a>(v: <InstrVariableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, opcode: u8) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_call_indirect().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_call_indirect().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_call_indirect().spec_serialize(v@))
-        },
-{
-    let combinator = call_indirect();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
-}
-
-pub fn call_indirect_len<'a>(v: <CallIndirectCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_call_indirect().wf(v@),
-        spec_call_indirect().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_call_indirect().spec_serialize(v@).len(),
-{
-    let combinator = call_indirect();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
-}
-
-                
-
-pub enum SpecInstrControl2 {
-    End(SpecEmpty),
-    BrIf(SpecLabelidx),
-    Br(SpecLabelidx),
-    Call(SpecFuncidx),
-    Ret(SpecEmpty),
-    BrTable(SpecBrTable),
-    CallIndirect(SpecCallIndirect),
-}
-
-pub type SpecInstrControl2Inner = Either<SpecEmpty, Either<SpecLabelidx, Either<SpecLabelidx, Either<SpecFuncidx, Either<SpecEmpty, Either<SpecBrTable, SpecCallIndirect>>>>>>;
-
-impl SpecFrom<SpecInstrControl2> for SpecInstrControl2Inner {
-    open spec fn spec_from(m: SpecInstrControl2) -> SpecInstrControl2Inner {
-        match m {
-            SpecInstrControl2::End(m) => Either::Left(m),
-            SpecInstrControl2::BrIf(m) => Either::Right(Either::Left(m)),
-            SpecInstrControl2::Br(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecInstrControl2::Call(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            SpecInstrControl2::Ret(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            SpecInstrControl2::BrTable(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            SpecInstrControl2::CallIndirect(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
-        }
-    }
-
-}
-
-                
-impl SpecFrom<SpecInstrControl2Inner> for SpecInstrControl2 {
-    open spec fn spec_from(m: SpecInstrControl2Inner) -> SpecInstrControl2 {
-        match m {
-            Either::Left(m) => SpecInstrControl2::End(m),
-            Either::Right(Either::Left(m)) => SpecInstrControl2::BrIf(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecInstrControl2::Br(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecInstrControl2::Call(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecInstrControl2::Ret(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecInstrControl2::BrTable(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => SpecInstrControl2::CallIndirect(m),
-        }
-    }
-
-}
-
-
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum InstrControl2<'a> {
-    End(Empty<'a>),
-    BrIf(Labelidx),
-    Br(Labelidx),
-    Call(Funcidx),
-    Ret(Empty<'a>),
-    BrTable(BrTable),
-    CallIndirect(CallIndirect),
-}
-
-pub type InstrControl2Inner<'a> = Either<Empty<'a>, Either<Labelidx, Either<Labelidx, Either<Funcidx, Either<Empty<'a>, Either<BrTable, CallIndirect>>>>>>;
-
-pub type InstrControl2InnerRef<'a> = Either<&'a Empty<'a>, Either<&'a Labelidx, Either<&'a Labelidx, Either<&'a Funcidx, Either<&'a Empty<'a>, Either<&'a BrTable, &'a CallIndirect>>>>>>;
-
-
-impl<'a> View for InstrControl2<'a> {
-    type V = SpecInstrControl2;
-    open spec fn view(&self) -> Self::V {
-        match self {
-            InstrControl2::End(m) => SpecInstrControl2::End(m@),
-            InstrControl2::BrIf(m) => SpecInstrControl2::BrIf(m@),
-            InstrControl2::Br(m) => SpecInstrControl2::Br(m@),
-            InstrControl2::Call(m) => SpecInstrControl2::Call(m@),
-            InstrControl2::Ret(m) => SpecInstrControl2::Ret(m@),
-            InstrControl2::BrTable(m) => SpecInstrControl2::BrTable(m@),
-            InstrControl2::CallIndirect(m) => SpecInstrControl2::CallIndirect(m@),
-        }
-    }
-}
-
-
-impl<'a> From<&'a InstrControl2<'a>> for InstrControl2InnerRef<'a> {
-    fn ex_from(m: &'a InstrControl2<'a>) -> InstrControl2InnerRef<'a> {
-        match m {
-            InstrControl2::End(m) => Either::Left(m),
-            InstrControl2::BrIf(m) => Either::Right(Either::Left(m)),
-            InstrControl2::Br(m) => Either::Right(Either::Right(Either::Left(m))),
-            InstrControl2::Call(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            InstrControl2::Ret(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            InstrControl2::BrTable(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            InstrControl2::CallIndirect(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
-        }
-    }
+        spec_instr_variable(opcode@).wf(v@),
+        spec_instr_bytecode().wf(opcode@),
 
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_instr_variable(opcode@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_instr_variable(opcode@).spec_serialize(v@))
+        },
+{
+    let combinator = instr_variable( opcode );
+    combinator.serialize(v, data, pos)
 }
 
-impl<'a> From<InstrControl2Inner<'a>> for InstrControl2<'a> {
-    fn ex_from(m: InstrControl2Inner<'a>) -> InstrControl2<'a> {
-        match m {
-            Either::Left(m) => InstrControl2::End(m),
-            Either::Right(Either::Left(m)) => InstrControl2::BrIf(m),
-            Either::Right(Either::Right(Either::Left(m))) => InstrControl2::Br(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => InstrControl2::Call(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => InstrControl2::Ret(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => InstrControl2::BrTable(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => InstrControl2::CallIndirect(m),
-        }
-    }
-    
+pub fn instr_variable_len<'a>(v: <InstrVariableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, opcode: u8) -> (serialize_len: usize)
+    requires
+        spec_instr_variable(opcode@).wf(v@),
+        spec_instr_variable(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
+    ensures
+        serialize_len == spec_instr_variable(opcode@).spec_serialize(v@).len(),
+{
+    let combinator = instr_variable( opcode );
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub type SpecLabelidx = u64;
+pub type Labelidx = u64;
+pub type LabelidxRef<'a> = &'a u64;
 
-pub struct InstrControl2Mapper;
-impl View for InstrControl2Mapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for InstrControl2Mapper {
-    type Src = SpecInstrControl2Inner;
-    type Dst = SpecInstrControl2;
-}
-impl SpecIsoProof for InstrControl2Mapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for InstrControl2Mapper {
-    type Src = InstrControl2Inner<'a>;
-    type Dst = InstrControl2<'a>;
-    type RefSrc = InstrControl2InnerRef<'a>;
-}
 
-type SpecInstrControl2CombinatorAlias1 = Choice<Cond<SpecBrTableCombinator>, Cond<SpecCallIndirectCombinator>>;
-type SpecInstrControl2CombinatorAlias2 = Choice<Cond<SpecEmptyCombinator>, SpecInstrControl2CombinatorAlias1>;
-type SpecInstrControl2CombinatorAlias3 = Choice<Cond<SpecFuncidxCombinator>, SpecInstrControl2CombinatorAlias2>;
-type SpecInstrControl2CombinatorAlias4 = Choice<Cond<SpecLabelidxCombinator>, SpecInstrControl2CombinatorAlias3>;
-type SpecInstrControl2CombinatorAlias5 = Choice<Cond<SpecLabelidxCombinator>, SpecInstrControl2CombinatorAlias4>;
-type SpecInstrControl2CombinatorAlias6 = Choice<Cond<SpecEmptyCombinator>, SpecInstrControl2CombinatorAlias5>;
-pub struct SpecInstrControl2Combinator(pub SpecInstrControl2CombinatorAlias);
+pub struct SpecLabelidxCombinator(pub SpecLabelidxCombinatorAlias);
 
-impl SpecCombinator for SpecInstrControl2Combinator {
-    type Type = SpecInstrControl2;
+impl SpecCombinator for SpecLabelidxCombinator {
+    type Type = SpecLabelidx;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecInstrControl2Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecInstrControl2CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecLabelidxCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecLabelidxCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecInstrControl2CombinatorAlias = Mapped<SpecInstrControl2CombinatorAlias6, InstrControl2Mapper>;
-type InstrControl2CombinatorAlias1 = Choice<Cond<BrTableCombinator>, Cond<CallIndirectCombinator>>;
-type InstrControl2CombinatorAlias2 = Choice<Cond<EmptyCombinator>, InstrControl2Combinator1>;
-type InstrControl2CombinatorAlias3 = Choice<Cond<FuncidxCombinator>, InstrControl2Combinator2>;
-type InstrControl2CombinatorAlias4 = Choice<Cond<LabelidxCombinator>, InstrControl2Combinator3>;
-type InstrControl2CombinatorAlias5 = Choice<Cond<LabelidxCombinator>, InstrControl2Combinator4>;
-type InstrControl2CombinatorAlias6 = Choice<Cond<EmptyCombinator>, InstrControl2Combinator5>;
-pub struct InstrControl2Combinator1(pub InstrControl2CombinatorAlias1);
-impl View for InstrControl2Combinator1 {
-    type V = SpecInstrControl2CombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
+pub type SpecLabelidxCombinatorAlias = UnsignedLEB128;
+
+pub struct LabelidxCombinator(pub LabelidxCombinatorAlias);
+
+impl View for LabelidxCombinator {
+    type V = SpecLabelidxCombinator;
+    open spec fn view(&self) -> Self::V { SpecLabelidxCombinator(self.0@) }
 }
-impl_wrapper_combinator!(InstrControl2Combinator1, InstrControl2CombinatorAlias1);
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LabelidxCombinator {
+    type Type = Labelidx;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type LabelidxCombinatorAlias = UnsignedLEB128;
 
-pub struct InstrControl2Combinator2(pub InstrControl2CombinatorAlias2);
-impl View for InstrControl2Combinator2 {
-    type V = SpecInstrControl2CombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
+
+pub open spec fn spec_labelidx() -> SpecLabelidxCombinator {
+    SpecLabelidxCombinator(UnsignedLEB128)
 }
-impl_wrapper_combinator!(InstrControl2Combinator2, InstrControl2CombinatorAlias2);
 
-pub struct InstrControl2Combinator3(pub InstrControl2CombinatorAlias3);
-impl View for InstrControl2Combinator3 {
-    type V = SpecInstrControl2CombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
+                
+pub fn labelidx<'a>() -> (o: LabelidxCombinator)
+    ensures o@ == spec_labelidx(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = LabelidxCombinator(UnsignedLEB128);
+    // assert({
+    //     &&& combinator@ == spec_labelidx()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
 }
-impl_wrapper_combinator!(InstrControl2Combinator3, InstrControl2CombinatorAlias3);
 
-pub struct InstrControl2Combinator4(pub InstrControl2CombinatorAlias4);
-impl View for InstrControl2Combinator4 {
-    type V = SpecInstrControl2CombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
+pub fn parse_labelidx<'a>(input: &'a [u8]) -> (res: PResult<<LabelidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_labelidx().spec_parse(input@) == Some((n as int, v@)),
+        spec_labelidx().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_labelidx().spec_parse(input@) is None,
+        spec_labelidx().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = labelidx();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
-impl_wrapper_combinator!(InstrControl2Combinator4, InstrControl2CombinatorAlias4);
 
-pub struct InstrControl2Combinator5(pub InstrControl2CombinatorAlias5);
-impl View for InstrControl2Combinator5 {
-    type V = SpecInstrControl2CombinatorAlias5;
-    open spec fn view(&self) -> Self::V { self.0@ }
+pub fn serialize_labelidx<'a>(v: <LabelidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_labelidx().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_labelidx().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_labelidx().spec_serialize(v@))
+        },
+{
+    let combinator = labelidx();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
-impl_wrapper_combinator!(InstrControl2Combinator5, InstrControl2CombinatorAlias5);
 
-pub struct InstrControl2Combinator6(pub InstrControl2CombinatorAlias6);
-impl View for InstrControl2Combinator6 {
-    type V = SpecInstrControl2CombinatorAlias6;
-    open spec fn view(&self) -> Self::V { self.0@ }
+pub fn labelidx_len<'a>(v: <LabelidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_labelidx().wf(v@),
+        spec_labelidx().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_labelidx().spec_serialize(v@).len(),
+{
+    let combinator = labelidx();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
-impl_wrapper_combinator!(InstrControl2Combinator6, InstrControl2CombinatorAlias6);
 
-pub struct InstrControl2Combinator(pub InstrControl2CombinatorAlias);
+                
+pub type SpecFuncidx = u64;
+pub type Funcidx = u64;
+pub type FuncidxRef<'a> = &'a u64;
 
-impl View for InstrControl2Combinator {
-    type V = SpecInstrControl2Combinator;
-    open spec fn view(&self) -> Self::V { SpecInstrControl2Combinator(self.0@) }
+
+pub struct SpecFuncidxCombinator(pub SpecFuncidxCombinatorAlias);
+
+impl SpecCombinator for SpecFuncidxCombinator {
+    type Type = SpecFuncidx;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrControl2Combinator {
-    type Type = InstrControl2<'a>;
+impl SecureSpecCombinator for SpecFuncidxCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecFuncidxCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecFuncidxCombinatorAlias = UnsignedLEB128;
+
+pub struct FuncidxCombinator(pub FuncidxCombinatorAlias);
+
+impl View for FuncidxCombinator {
+    type V = SpecFuncidxCombinator;
+    open spec fn view(&self) -> Self::V { SpecFuncidxCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FuncidxCombinator {
+    type Type = Funcidx;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type InstrControl2CombinatorAlias = Mapped<InstrControl2Combinator6, InstrControl2Mapper>;
+}
+pub type FuncidxCombinatorAlias = UnsignedLEB128;
 
 
-pub open spec fn spec_instr_control2(opcode: u8) -> SpecInstrControl2Combinator {
-    SpecInstrControl2Combinator(Mapped { inner: Choice(Cond { cond: opcode == InstrBytecode::SPEC_End, inner: spec_empty() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_BrIf, inner: spec_labelidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Br, inner: spec_labelidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Call, inner: spec_funcidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Ret, inner: spec_empty() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_BrTable, inner: spec_br_table() }, Cond { cond: opcode == InstrBytecode::SPEC_CallIndirect, inner: spec_call_indirect() })))))), mapper: InstrControl2Mapper })
+pub open spec fn spec_funcidx() -> SpecFuncidxCombinator {
+    SpecFuncidxCombinator(UnsignedLEB128)
 }
 
-pub fn instr_control2<'a>(opcode: u8) -> (o: InstrControl2Combinator)
-    ensures o@ == spec_instr_control2(opcode@),
+                
+pub fn funcidx<'a>() -> (o: FuncidxCombinator)
+    ensures o@ == spec_funcidx(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = InstrControl2Combinator(Mapped { inner: InstrControl2Combinator6(Choice::new(Cond { cond: opcode == InstrBytecode::End, inner: empty() }, InstrControl2Combinator5(Choice::new(Cond { cond: opcode == InstrBytecode::BrIf, inner: labelidx() }, InstrControl2Combinator4(Choice::new(Cond { cond: opcode == InstrBytecode::Br, inner: labelidx() }, InstrControl2Combinator3(Choice::new(Cond { cond: opcode == InstrBytecode::Call, inner: funcidx() }, InstrControl2Combinator2(Choice::new(Cond { cond: opcode == InstrBytecode::Ret, inner: empty() }, InstrControl2Combinator1(Choice::new(Cond { cond: opcode == InstrBytecode::BrTable, inner: br_table() }, Cond { cond: opcode == InstrBytecode::CallIndirect, inner: call_indirect() })))))))))))), mapper: InstrControl2Mapper });
-    assert({
-        &&& combinator@ == spec_instr_control2(opcode@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = FuncidxCombinator(UnsignedLEB128);
+    // assert({
+    //     &&& combinator@ == spec_funcidx()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_instr_control2<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrControl2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_funcidx<'a>(input: &'a [u8]) -> (res: PResult<<FuncidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_instr_control2(opcode@).spec_parse(input@) == Some((n as int, v@)),
-        spec_instr_control2(opcode@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_funcidx().spec_parse(input@) == Some((n as int, v@)),
+        spec_funcidx().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_instr_control2(opcode@).spec_parse(input@) is None,
-        spec_instr_control2(opcode@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_funcidx().spec_parse(input@) is None,
+        spec_funcidx().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = instr_control2( opcode );
+    let combinator = funcidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_instr_control2<'a>(v: <InstrControl2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, opcode: u8) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_funcidx<'a>(v: <FuncidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_instr_control2(opcode@).wf(v@),
+        spec_funcidx().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_instr_control2(opcode@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_instr_control2(opcode@).spec_serialize(v@))
+            &&& n == spec_funcidx().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_funcidx().spec_serialize(v@))
         },
 {
-    let combinator = instr_control2( opcode );
-    combinator.serialize(v, data, pos)
+    let combinator = funcidx();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn instr_control2_len<'a>(v: <InstrControl2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, opcode: u8) -> (serialize_len: usize)
+pub fn funcidx_len<'a>(v: <FuncidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_instr_control2(opcode@).wf(v@),
-        spec_instr_control2(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_funcidx().wf(v@),
+        spec_funcidx().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_instr_control2(opcode@).spec_serialize(v@).len(),
+        serialize_len == spec_funcidx().spec_serialize(v@).len(),
 {
-    let combinator = instr_control2( opcode );
+    let combinator = funcidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+                
 
-pub struct SpecEmptyBlock {
-    pub tag: u8,
-    pub body: SpecEmpty,
+pub struct SpecLabelidxVec {
+    pub l: u64,
+    pub v: Seq<SpecLabelidx>,
 }
 
-pub type SpecEmptyBlockInner = (u8, SpecEmpty);
+pub type SpecLabelidxVecInner = (u64, Seq<SpecLabelidx>);
 
 
-impl SpecFrom<SpecEmptyBlock> for SpecEmptyBlockInner {
-    open spec fn spec_from(m: SpecEmptyBlock) -> SpecEmptyBlockInner {
-        (m.tag, m.body)
+impl SpecFrom<SpecLabelidxVec> for SpecLabelidxVecInner {
+    open spec fn spec_from(m: SpecLabelidxVec) -> SpecLabelidxVecInner {
+        (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecEmptyBlockInner> for SpecEmptyBlock {
-    open spec fn spec_from(m: SpecEmptyBlockInner) -> SpecEmptyBlock {
-        let (tag, body) = m;
-        SpecEmptyBlock { tag, body }
+impl SpecFrom<SpecLabelidxVecInner> for SpecLabelidxVec {
+    open spec fn spec_from(m: SpecLabelidxVecInner) -> SpecLabelidxVec {
+        let (l, v) = m;
+        SpecLabelidxVec { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct EmptyBlock<'a> {
-    pub tag: u8,
-    pub body: Empty<'a>,
+pub struct LabelidxVec {
+    pub l: u64,
+    pub v: RepeatResult<Labelidx>,
 }
 
-impl View for EmptyBlock<'_> {
-    type V = SpecEmptyBlock;
+impl View for LabelidxVec {
+    type V = SpecLabelidxVec;
 
     open spec fn view(&self) -> Self::V {
-        SpecEmptyBlock {
-            tag: self.tag@,
-            body: self.body@,
+        SpecLabelidxVec {
+            l: self.l@,
+            v: self.v@,
         }
     }
 }
-pub type EmptyBlockInner<'a> = (u8, Empty<'a>);
+pub type LabelidxVecInner = (u64, RepeatResult<Labelidx>);
 
-pub type EmptyBlockInnerRef<'a> = (&'a u8, &'a Empty<'a>);
-impl<'a> From<&'a EmptyBlock<'a>> for EmptyBlockInnerRef<'a> {
-    fn ex_from(m: &'a EmptyBlock) -> EmptyBlockInnerRef<'a> {
-        (&m.tag, &m.body)
+pub type LabelidxVecInnerRef<'a> = (&'a u64, &'a RepeatResult<Labelidx>);
+impl<'a> From<&'a LabelidxVec> for LabelidxVecInnerRef<'a> {
+    fn ex_from(m: &'a LabelidxVec) -> LabelidxVecInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-impl<'a> From<EmptyBlockInner<'a>> for EmptyBlock<'a> {
-    fn ex_from(m: EmptyBlockInner) -> EmptyBlock {
-        let (tag, body) = m;
-        EmptyBlock { tag, body }
+impl From<LabelidxVecInner> for LabelidxVec {
+    fn ex_from(m: LabelidxVecInner) -> LabelidxVec {
+        let (l, v) = m;
+        LabelidxVec { l, v }
     }
 }
 
-pub struct EmptyBlockMapper;
-impl View for EmptyBlockMapper {
+pub struct LabelidxVecMapper;
+impl View for LabelidxVecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for EmptyBlockMapper {
-    type Src = SpecEmptyBlockInner;
-    type Dst = SpecEmptyBlock;
+impl SpecIso for LabelidxVecMapper {
+    type Src = SpecLabelidxVecInner;
+    type Dst = SpecLabelidxVec;
 }
-impl SpecIsoProof for EmptyBlockMapper {
+impl SpecIsoProof for LabelidxVecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -2641,226 +3101,245 @@ impl SpecIsoProof for EmptyBlockMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for EmptyBlockMapper {
-    type Src = EmptyBlockInner<'a>;
-    type Dst = EmptyBlock<'a>;
-    type RefSrc = EmptyBlockInnerRef<'a>;
+impl<'a> Iso<'a> for LabelidxVecMapper {
+    type Src = LabelidxVecInner;
+    type Dst = LabelidxVec;
+    type RefSrc = LabelidxVecInnerRef<'a>;
 }
-type SpecEmptyBlockCombinatorAlias1 = (Refined<U8, Predicate16713707613369419146>, SpecEmptyCombinator);
-pub struct SpecEmptyBlockCombinator(pub SpecEmptyBlockCombinatorAlias);
 
-impl SpecCombinator for SpecEmptyBlockCombinator {
-    type Type = SpecEmptyBlock;
+pub struct SpecLabelidxVecCombinator(pub SpecLabelidxVecCombinatorAlias);
+
+impl SpecCombinator for SpecLabelidxVecCombinator {
+    type Type = SpecLabelidxVec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecEmptyBlockCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecEmptyBlockCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecLabelidxVecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecLabelidxVecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecEmptyBlockCombinatorAlias = Mapped<SpecEmptyBlockCombinatorAlias1, EmptyBlockMapper>;
-pub struct Predicate16713707613369419146;
-impl View for Predicate16713707613369419146 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u8> for Predicate16713707613369419146 {
-    fn apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        (i == 64)
-    }
-}
-impl SpecPred<u8> for Predicate16713707613369419146 {
-    open spec fn spec_apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        (i == 64)
-    }
-}
-type EmptyBlockCombinatorAlias1 = (Refined<U8, Predicate16713707613369419146>, EmptyCombinator);
-pub struct EmptyBlockCombinator1(pub EmptyBlockCombinatorAlias1);
-impl View for EmptyBlockCombinator1 {
-    type V = SpecEmptyBlockCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(EmptyBlockCombinator1, EmptyBlockCombinatorAlias1);
+pub type SpecLabelidxVecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecLabelidxCombinator>>, LabelidxVecMapper>;
 
-pub struct EmptyBlockCombinator(pub EmptyBlockCombinatorAlias);
+pub struct LabelidxVecCombinator(pub LabelidxVecCombinatorAlias);
 
-impl View for EmptyBlockCombinator {
-    type V = SpecEmptyBlockCombinator;
-    open spec fn view(&self) -> Self::V { SpecEmptyBlockCombinator(self.0@) }
+impl View for LabelidxVecCombinator {
+    type V = SpecLabelidxVecCombinator;
+    open spec fn view(&self) -> Self::V { SpecLabelidxVecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EmptyBlockCombinator {
-    type Type = EmptyBlock<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LabelidxVecCombinator {
+    type Type = LabelidxVec;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type EmptyBlockCombinatorAlias = Mapped<EmptyBlockCombinator1, EmptyBlockMapper>;
+}
+pub type LabelidxVecCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<LabelidxCombinator>, LabelidxVecCont0>, LabelidxVecMapper>;
 
 
-pub open spec fn spec_empty_block() -> SpecEmptyBlockCombinator {
-    SpecEmptyBlockCombinator(
+pub open spec fn spec_labelidx_vec() -> SpecLabelidxVecCombinator {
+    SpecLabelidxVecCombinator(
     Mapped {
-        inner: (Refined { inner: U8, predicate: Predicate16713707613369419146 }, spec_empty()),
-        mapper: EmptyBlockMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_labelidx_vec_cont0(deps)),
+        mapper: LabelidxVecMapper,
     })
 }
 
+pub open spec fn spec_labelidx_vec_cont0(deps: u64) -> RepeatN<SpecLabelidxCombinator> {
+    let l = deps;
+    RepeatN(spec_labelidx(), (usize::spec_from(l)) as usize)
+}
+
+impl View for LabelidxVecCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecLabelidxCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_labelidx_vec_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn empty_block<'a>() -> (o: EmptyBlockCombinator)
-    ensures o@ == spec_empty_block(),
+pub fn labelidx_vec<'a>() -> (o: LabelidxVecCombinator)
+    ensures o@ == spec_labelidx_vec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = EmptyBlockCombinator(
+    let combinator = LabelidxVecCombinator(
     Mapped {
-        inner: EmptyBlockCombinator1((Refined { inner: U8, predicate: Predicate16713707613369419146 }, empty())),
-        mapper: EmptyBlockMapper,
-    });
-    assert({
-        &&& combinator@ == spec_empty_block()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, LabelidxVecCont0),
+        mapper: LabelidxVecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_labelidx_vec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_empty_block<'a>(input: &'a [u8]) -> (res: PResult<<EmptyBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_labelidx_vec<'a>(input: &'a [u8]) -> (res: PResult<<LabelidxVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_empty_block().spec_parse(input@) == Some((n as int, v@)),
-        spec_empty_block().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_labelidx_vec().spec_parse(input@) == Some((n as int, v@)),
+        spec_labelidx_vec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_empty_block().spec_parse(input@) is None,
-        spec_empty_block().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_labelidx_vec().spec_parse(input@) is None,
+        spec_labelidx_vec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = empty_block();
+    let combinator = labelidx_vec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_empty_block<'a>(v: <EmptyBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_labelidx_vec<'a>(v: <LabelidxVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_empty_block().wf(v@),
+        spec_labelidx_vec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_empty_block().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_empty_block().spec_serialize(v@))
+            &&& n == spec_labelidx_vec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_labelidx_vec().spec_serialize(v@))
         },
 {
-    let combinator = empty_block();
+    let combinator = labelidx_vec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn empty_block_len<'a>(v: <EmptyBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn labelidx_vec_len<'a>(v: <LabelidxVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_empty_block().wf(v@),
-        spec_empty_block().spec_serialize(v@).len() <= usize::MAX,
+        spec_labelidx_vec().wf(v@),
+        spec_labelidx_vec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_empty_block().spec_serialize(v@).len(),
+        serialize_len == spec_labelidx_vec().spec_serialize(v@).len(),
 {
-    let combinator = empty_block();
+    let combinator = labelidx_vec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct LabelidxVecCont0;
+type LabelidxVecCont0Type<'a, 'b> = &'b u64;
+type LabelidxVecCont0SType<'a, 'x> = &'x u64;
+type LabelidxVecCont0Input<'a, 'b, 'x> = POrSType<LabelidxVecCont0Type<'a, 'b>, LabelidxVecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<LabelidxVecCont0Input<'a, 'b, 'x>> for LabelidxVecCont0 {
+    type Output = RepeatN<LabelidxCombinator>;
+
+    open spec fn requires(&self, deps: LabelidxVecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: LabelidxVecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_labelidx_vec_cont0(deps@)
+    }
+
+    fn apply(&self, deps: LabelidxVecCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(labelidx(), (usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(labelidx(), (usize::ex_from(l)) as usize)
+            }
+        }
+    }
+}
                 
 
-pub struct SpecValtypeBlock {
-    pub tag: u8,
-    pub body: SpecEmpty,
+pub struct SpecBrTable {
+    pub l: SpecLabelidxVec,
+    pub l_n: SpecLabelidx,
 }
 
-pub type SpecValtypeBlockInner = (u8, SpecEmpty);
+pub type SpecBrTableInner = (SpecLabelidxVec, SpecLabelidx);
 
 
-impl SpecFrom<SpecValtypeBlock> for SpecValtypeBlockInner {
-    open spec fn spec_from(m: SpecValtypeBlock) -> SpecValtypeBlockInner {
-        (m.tag, m.body)
+impl SpecFrom<SpecBrTable> for SpecBrTableInner {
+    open spec fn spec_from(m: SpecBrTable) -> SpecBrTableInner {
+        (m.l, m.l_n)
     }
 }
 
-impl SpecFrom<SpecValtypeBlockInner> for SpecValtypeBlock {
-    open spec fn spec_from(m: SpecValtypeBlockInner) -> SpecValtypeBlock {
-        let (tag, body) = m;
-        SpecValtypeBlock { tag, body }
+impl SpecFrom<SpecBrTableInner> for SpecBrTable {
+    open spec fn spec_from(m: SpecBrTableInner) -> SpecBrTable {
+        let (l, l_n) = m;
+        SpecBrTable { l, l_n }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ValtypeBlock<'a> {
-    pub tag: u8,
-    pub body: Empty<'a>,
+pub struct BrTable {
+    pub l: LabelidxVec,
+    pub l_n: Labelidx,
 }
 
-impl View for ValtypeBlock<'_> {
-    type V = SpecValtypeBlock;
+impl View for BrTable {
+    type V = SpecBrTable;
 
     open spec fn view(&self) -> Self::V {
-        SpecValtypeBlock {
-            tag: self.tag@,
-            body: self.body@,
+        SpecBrTable {
+            l: self.l@,
+            l_n: self.l_n@,
         }
     }
 }
-pub type ValtypeBlockInner<'a> = (u8, Empty<'a>);
+pub type BrTableInner = (LabelidxVec, Labelidx);
 
-pub type ValtypeBlockInnerRef<'a> = (&'a u8, &'a Empty<'a>);
-impl<'a> From<&'a ValtypeBlock<'a>> for ValtypeBlockInnerRef<'a> {
-    fn ex_from(m: &'a ValtypeBlock) -> ValtypeBlockInnerRef<'a> {
-        (&m.tag, &m.body)
+pub type BrTableInnerRef<'a> = (&'a LabelidxVec, &'a Labelidx);
+impl<'a> From<&'a BrTable> for BrTableInnerRef<'a> {
+    fn ex_from(m: &'a BrTable) -> BrTableInnerRef<'a> {
+        (&m.l, &m.l_n)
     }
 }
 
-impl<'a> From<ValtypeBlockInner<'a>> for ValtypeBlock<'a> {
-    fn ex_from(m: ValtypeBlockInner) -> ValtypeBlock {
-        let (tag, body) = m;
-        ValtypeBlock { tag, body }
+impl From<BrTableInner> for BrTable {
+    fn ex_from(m: BrTableInner) -> BrTable {
+        let (l, l_n) = m;
+        BrTable { l, l_n }
     }
 }
 
-pub struct ValtypeBlockMapper;
-impl View for ValtypeBlockMapper {
+pub struct BrTableMapper;
+impl View for BrTableMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ValtypeBlockMapper {
-    type Src = SpecValtypeBlockInner;
-    type Dst = SpecValtypeBlock;
+impl SpecIso for BrTableMapper {
+    type Src = SpecBrTableInner;
+    type Dst = SpecBrTable;
 }
-impl SpecIsoProof for ValtypeBlockMapper {
+impl SpecIsoProof for BrTableMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -2868,480 +3347,324 @@ impl SpecIsoProof for ValtypeBlockMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ValtypeBlockMapper {
-    type Src = ValtypeBlockInner<'a>;
-    type Dst = ValtypeBlock<'a>;
-    type RefSrc = ValtypeBlockInnerRef<'a>;
+impl<'a> Iso<'a> for BrTableMapper {
+    type Src = BrTableInner;
+    type Dst = BrTable;
+    type RefSrc = BrTableInnerRef<'a>;
 }
-type SpecValtypeBlockCombinatorAlias1 = (Refined<U8, Predicate17051755724411564727>, SpecEmptyCombinator);
-pub struct SpecValtypeBlockCombinator(pub SpecValtypeBlockCombinatorAlias);
+type SpecBrTableCombinatorAlias1 = (SpecLabelidxVecCombinator, SpecLabelidxCombinator);
+pub struct SpecBrTableCombinator(pub SpecBrTableCombinatorAlias);
 
-impl SpecCombinator for SpecValtypeBlockCombinator {
-    type Type = SpecValtypeBlock;
+impl SpecCombinator for SpecBrTableCombinator {
+    type Type = SpecBrTable;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecValtypeBlockCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecValtypeBlockCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecBrTableCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecBrTableCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecValtypeBlockCombinatorAlias = Mapped<SpecValtypeBlockCombinatorAlias1, ValtypeBlockMapper>;
-pub struct Predicate17051755724411564727;
-impl View for Predicate17051755724411564727 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u8> for Predicate17051755724411564727 {
-    fn apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        (i == 123) || (i == 124) || (i == 125) || (i == 126) || (i == 127) || (i == 111) || (i == 112)
-    }
-}
-impl SpecPred<u8> for Predicate17051755724411564727 {
-    open spec fn spec_apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        (i == 123) || (i == 124) || (i == 125) || (i == 126) || (i == 127) || (i == 111) || (i == 112)
-    }
-}
-type ValtypeBlockCombinatorAlias1 = (Refined<U8, Predicate17051755724411564727>, EmptyCombinator);
-pub struct ValtypeBlockCombinator1(pub ValtypeBlockCombinatorAlias1);
-impl View for ValtypeBlockCombinator1 {
-    type V = SpecValtypeBlockCombinatorAlias1;
+pub type SpecBrTableCombinatorAlias = Mapped<SpecBrTableCombinatorAlias1, BrTableMapper>;
+type BrTableCombinatorAlias1 = (LabelidxVecCombinator, LabelidxCombinator);
+pub struct BrTableCombinator1(pub BrTableCombinatorAlias1);
+impl View for BrTableCombinator1 {
+    type V = SpecBrTableCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ValtypeBlockCombinator1, ValtypeBlockCombinatorAlias1);
+impl_wrapper_combinator!(BrTableCombinator1, BrTableCombinatorAlias1);
 
-pub struct ValtypeBlockCombinator(pub ValtypeBlockCombinatorAlias);
+pub struct BrTableCombinator(pub BrTableCombinatorAlias);
 
-impl View for ValtypeBlockCombinator {
-    type V = SpecValtypeBlockCombinator;
-    open spec fn view(&self) -> Self::V { SpecValtypeBlockCombinator(self.0@) }
+impl View for BrTableCombinator {
+    type V = SpecBrTableCombinator;
+    open spec fn view(&self) -> Self::V { SpecBrTableCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ValtypeBlockCombinator {
-    type Type = ValtypeBlock<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for BrTableCombinator {
+    type Type = BrTable;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ValtypeBlockCombinatorAlias = Mapped<ValtypeBlockCombinator1, ValtypeBlockMapper>;
+}
+pub type BrTableCombinatorAlias = Mapped<BrTableCombinator1, BrTableMapper>;
 
 
-pub open spec fn spec_valtype_block() -> SpecValtypeBlockCombinator {
-    SpecValtypeBlockCombinator(
+pub open spec fn spec_br_table() -> SpecBrTableCombinator {
+    SpecBrTableCombinator(
     Mapped {
-        inner: (Refined { inner: U8, predicate: Predicate17051755724411564727 }, spec_empty()),
-        mapper: ValtypeBlockMapper,
+        inner: (spec_labelidx_vec(), spec_labelidx()),
+        mapper: BrTableMapper,
     })
 }
 
                 
-pub fn valtype_block<'a>() -> (o: ValtypeBlockCombinator)
-    ensures o@ == spec_valtype_block(),
+pub fn br_table<'a>() -> (o: BrTableCombinator)
+    ensures o@ == spec_br_table(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ValtypeBlockCombinator(
+    let combinator = BrTableCombinator(
     Mapped {
-        inner: ValtypeBlockCombinator1((Refined { inner: U8, predicate: Predicate17051755724411564727 }, empty())),
-        mapper: ValtypeBlockMapper,
-    });
-    assert({
-        &&& combinator@ == spec_valtype_block()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: BrTableCombinator1((labelidx_vec(), labelidx())),
+        mapper: BrTableMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_br_table()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_valtype_block<'a>(input: &'a [u8]) -> (res: PResult<<ValtypeBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_br_table<'a>(input: &'a [u8]) -> (res: PResult<<BrTableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_valtype_block().spec_parse(input@) == Some((n as int, v@)),
-        spec_valtype_block().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_br_table().spec_parse(input@) == Some((n as int, v@)),
+        spec_br_table().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_valtype_block().spec_parse(input@) is None,
-        spec_valtype_block().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_br_table().spec_parse(input@) is None,
+        spec_br_table().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = valtype_block();
+    let combinator = br_table();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_valtype_block<'a>(v: <ValtypeBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_br_table<'a>(v: <BrTableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_valtype_block().wf(v@),
+        spec_br_table().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_valtype_block().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_valtype_block().spec_serialize(v@))
+            &&& n == spec_br_table().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_br_table().spec_serialize(v@))
         },
 {
-    let combinator = valtype_block();
+    let combinator = br_table();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn valtype_block_len<'a>(v: <ValtypeBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn br_table_len<'a>(v: <BrTableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_valtype_block().wf(v@),
-        spec_valtype_block().spec_serialize(v@).len() <= usize::MAX,
+        spec_br_table().wf(v@),
+        spec_br_table().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_valtype_block().spec_serialize(v@).len(),
+        serialize_len == spec_br_table().spec_serialize(v@).len(),
 {
-    let combinator = valtype_block();
+    let combinator = br_table();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
+pub type SpecTypeidx = u64;
+pub type Typeidx = u64;
+pub type TypeidxRef<'a> = &'a u64;
 
-pub struct SpecTypeidxBlock {
-    pub tag: u8,
-    pub body: u64,
-}
-
-pub type SpecTypeidxBlockInner = (u8, u64);
-
-
-impl SpecFrom<SpecTypeidxBlock> for SpecTypeidxBlockInner {
-    open spec fn spec_from(m: SpecTypeidxBlock) -> SpecTypeidxBlockInner {
-        (m.tag, m.body)
-    }
-}
-
-impl SpecFrom<SpecTypeidxBlockInner> for SpecTypeidxBlock {
-    open spec fn spec_from(m: SpecTypeidxBlockInner) -> SpecTypeidxBlock {
-        let (tag, body) = m;
-        SpecTypeidxBlock { tag, body }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct TypeidxBlock {
-    pub tag: u8,
-    pub body: u64,
-}
-
-impl View for TypeidxBlock {
-    type V = SpecTypeidxBlock;
-
-    open spec fn view(&self) -> Self::V {
-        SpecTypeidxBlock {
-            tag: self.tag@,
-            body: self.body@,
-        }
-    }
-}
-pub type TypeidxBlockInner = (u8, u64);
-
-pub type TypeidxBlockInnerRef<'a> = (&'a u8, &'a u64);
-impl<'a> From<&'a TypeidxBlock> for TypeidxBlockInnerRef<'a> {
-    fn ex_from(m: &'a TypeidxBlock) -> TypeidxBlockInnerRef<'a> {
-        (&m.tag, &m.body)
-    }
-}
-
-impl From<TypeidxBlockInner> for TypeidxBlock {
-    fn ex_from(m: TypeidxBlockInner) -> TypeidxBlock {
-        let (tag, body) = m;
-        TypeidxBlock { tag, body }
-    }
-}
 
-pub struct TypeidxBlockMapper;
-impl View for TypeidxBlockMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for TypeidxBlockMapper {
-    type Src = SpecTypeidxBlockInner;
-    type Dst = SpecTypeidxBlock;
-}
-impl SpecIsoProof for TypeidxBlockMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for TypeidxBlockMapper {
-    type Src = TypeidxBlockInner;
-    type Dst = TypeidxBlock;
-    type RefSrc = TypeidxBlockInnerRef<'a>;
-}
-type SpecTypeidxBlockCombinatorAlias1 = (Refined<U8, Predicate2396169508742552609>, UnsignedLEB128);
-pub struct SpecTypeidxBlockCombinator(pub SpecTypeidxBlockCombinatorAlias);
+pub struct SpecTypeidxCombinator(pub SpecTypeidxCombinatorAlias);
 
-impl SpecCombinator for SpecTypeidxBlockCombinator {
-    type Type = SpecTypeidxBlock;
+impl SpecCombinator for SpecTypeidxCombinator {
+    type Type = SpecTypeidx;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTypeidxBlockCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTypeidxBlockCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTypeidxCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTypeidxCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTypeidxBlockCombinatorAlias = Mapped<SpecTypeidxBlockCombinatorAlias1, TypeidxBlockMapper>;
-pub struct Predicate2396169508742552609;
-impl View for Predicate2396169508742552609 {
-    type V = Self;
-
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl Pred<u8> for Predicate2396169508742552609 {
-    fn apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        !((i == 64) || (i == 123) || (i == 124) || (i == 125) || (i == 126) || (i == 127) || (i == 111) || (i == 112))
-    }
-}
-impl SpecPred<u8> for Predicate2396169508742552609 {
-    open spec fn spec_apply(&self, i: &u8) -> bool {
-        let i = (*i);
-        !((i == 64) || (i == 123) || (i == 124) || (i == 125) || (i == 126) || (i == 127) || (i == 111) || (i == 112))
-    }
-}
-type TypeidxBlockCombinatorAlias1 = (Refined<U8, Predicate2396169508742552609>, UnsignedLEB128);
-pub struct TypeidxBlockCombinator1(pub TypeidxBlockCombinatorAlias1);
-impl View for TypeidxBlockCombinator1 {
-    type V = SpecTypeidxBlockCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(TypeidxBlockCombinator1, TypeidxBlockCombinatorAlias1);
+pub type SpecTypeidxCombinatorAlias = UnsignedLEB128;
 
-pub struct TypeidxBlockCombinator(pub TypeidxBlockCombinatorAlias);
+pub struct TypeidxCombinator(pub TypeidxCombinatorAlias);
 
-impl View for TypeidxBlockCombinator {
-    type V = SpecTypeidxBlockCombinator;
-    open spec fn view(&self) -> Self::V { SpecTypeidxBlockCombinator(self.0@) }
+impl View for TypeidxCombinator {
+    type V = SpecTypeidxCombinator;
+    open spec fn view(&self) -> Self::V { SpecTypeidxCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TypeidxBlockCombinator {
-    type Type = TypeidxBlock;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TypeidxCombinator {
+    type Type = Typeidx;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TypeidxBlockCombinatorAlias = Mapped<TypeidxBlockCombinator1, TypeidxBlockMapper>;
+}
+pub type TypeidxCombinatorAlias = UnsignedLEB128;
 
 
-pub open spec fn spec_typeidx_block() -> SpecTypeidxBlockCombinator {
-    SpecTypeidxBlockCombinator(
-    Mapped {
-        inner: (Refined { inner: U8, predicate: Predicate2396169508742552609 }, UnsignedLEB128),
-        mapper: TypeidxBlockMapper,
-    })
+pub open spec fn spec_typeidx() -> SpecTypeidxCombinator {
+    SpecTypeidxCombinator(UnsignedLEB128)
 }
 
                 
-pub fn typeidx_block<'a>() -> (o: TypeidxBlockCombinator)
-    ensures o@ == spec_typeidx_block(),
+pub fn typeidx<'a>() -> (o: TypeidxCombinator)
+    ensures o@ == spec_typeidx(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = TypeidxBlockCombinator(
-    Mapped {
-        inner: TypeidxBlockCombinator1((Refined { inner: U8, predicate: Predicate2396169508742552609 }, UnsignedLEB128)),
-        mapper: TypeidxBlockMapper,
-    });
-    assert({
-        &&& combinator@ == spec_typeidx_block()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = TypeidxCombinator(UnsignedLEB128);
+    // assert({
+    //     &&& combinator@ == spec_typeidx()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_typeidx_block<'a>(input: &'a [u8]) -> (res: PResult<<TypeidxBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_typeidx<'a>(input: &'a [u8]) -> (res: PResult<<TypeidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_typeidx_block().spec_parse(input@) == Some((n as int, v@)),
-        spec_typeidx_block().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_typeidx().spec_parse(input@) == Some((n as int, v@)),
+        spec_typeidx().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_typeidx_block().spec_parse(input@) is None,
-        spec_typeidx_block().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_typeidx().spec_parse(input@) is None,
+        spec_typeidx().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = typeidx_block();
+    let combinator = typeidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_typeidx_block<'a>(v: <TypeidxBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_typeidx<'a>(v: <TypeidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_typeidx_block().wf(v@),
+        spec_typeidx().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_typeidx_block().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_typeidx_block().spec_serialize(v@))
+            &&& n == spec_typeidx().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_typeidx().spec_serialize(v@))
         },
 {
-    let combinator = typeidx_block();
+    let combinator = typeidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn typeidx_block_len<'a>(v: <TypeidxBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn typeidx_len<'a>(v: <TypeidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_typeidx_block().wf(v@),
-        spec_typeidx_block().spec_serialize(v@).len() <= usize::MAX,
+        spec_typeidx().wf(v@),
+        spec_typeidx().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_typeidx_block().spec_serialize(v@).len(),
+        serialize_len == spec_typeidx().spec_serialize(v@).len(),
 {
-    let combinator = typeidx_block();
+    let combinator = typeidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub enum SpecBlocktype {
-    Empty(SpecEmptyBlock),
-    ValType(SpecValtypeBlock),
-    TypeIdx(SpecTypeidxBlock),
+pub struct SpecCallIndirect {
+    pub y: SpecTypeidx,
+    pub x: SpecTableidx,
 }
 
-pub type SpecBlocktypeInner = Either<SpecEmptyBlock, Either<SpecValtypeBlock, SpecTypeidxBlock>>;
+pub type SpecCallIndirectInner = (SpecTypeidx, SpecTableidx);
 
-impl SpecFrom<SpecBlocktype> for SpecBlocktypeInner {
-    open spec fn spec_from(m: SpecBlocktype) -> SpecBlocktypeInner {
-        match m {
-            SpecBlocktype::Empty(m) => Either::Left(m),
-            SpecBlocktype::ValType(m) => Either::Right(Either::Left(m)),
-            SpecBlocktype::TypeIdx(m) => Either::Right(Either::Right(m)),
-        }
-    }
 
+impl SpecFrom<SpecCallIndirect> for SpecCallIndirectInner {
+    open spec fn spec_from(m: SpecCallIndirect) -> SpecCallIndirectInner {
+        (m.y, m.x)
+    }
 }
 
-                
-impl SpecFrom<SpecBlocktypeInner> for SpecBlocktype {
-    open spec fn spec_from(m: SpecBlocktypeInner) -> SpecBlocktype {
-        match m {
-            Either::Left(m) => SpecBlocktype::Empty(m),
-            Either::Right(Either::Left(m)) => SpecBlocktype::ValType(m),
-            Either::Right(Either::Right(m)) => SpecBlocktype::TypeIdx(m),
-        }
+impl SpecFrom<SpecCallIndirectInner> for SpecCallIndirect {
+    open spec fn spec_from(m: SpecCallIndirectInner) -> SpecCallIndirect {
+        let (y, x) = m;
+        SpecCallIndirect { y, x }
     }
-
 }
-
-
-
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Blocktype<'a> {
-    Empty(EmptyBlock<'a>),
-    ValType(ValtypeBlock<'a>),
-    TypeIdx(TypeidxBlock),
-}
-
-pub type BlocktypeInner<'a> = Either<EmptyBlock<'a>, Either<ValtypeBlock<'a>, TypeidxBlock>>;
 
-pub type BlocktypeInnerRef<'a> = Either<&'a EmptyBlock<'a>, Either<&'a ValtypeBlock<'a>, &'a TypeidxBlock>>;
+pub struct CallIndirect {
+    pub y: Typeidx,
+    pub x: Tableidx,
+}
 
+impl View for CallIndirect {
+    type V = SpecCallIndirect;
 
-impl<'a> View for Blocktype<'a> {
-    type V = SpecBlocktype;
     open spec fn view(&self) -> Self::V {
-        match self {
-            Blocktype::Empty(m) => SpecBlocktype::Empty(m@),
-            Blocktype::ValType(m) => SpecBlocktype::ValType(m@),
-            Blocktype::TypeIdx(m) => SpecBlocktype::TypeIdx(m@),
+        SpecCallIndirect {
+            y: self.y@,
+            x: self.x@,
         }
     }
 }
+pub type CallIndirectInner = (Typeidx, Tableidx);
 
-
-impl<'a> From<&'a Blocktype<'a>> for BlocktypeInnerRef<'a> {
-    fn ex_from(m: &'a Blocktype<'a>) -> BlocktypeInnerRef<'a> {
-        match m {
-            Blocktype::Empty(m) => Either::Left(m),
-            Blocktype::ValType(m) => Either::Right(Either::Left(m)),
-            Blocktype::TypeIdx(m) => Either::Right(Either::Right(m)),
-        }
+pub type CallIndirectInnerRef<'a> = (&'a Typeidx, &'a Tableidx);
+impl<'a> From<&'a CallIndirect> for CallIndirectInnerRef<'a> {
+    fn ex_from(m: &'a CallIndirect) -> CallIndirectInnerRef<'a> {
+        (&m.y, &m.x)
     }
-
 }
 
-impl<'a> From<BlocktypeInner<'a>> for Blocktype<'a> {
-    fn ex_from(m: BlocktypeInner<'a>) -> Blocktype<'a> {
-        match m {
-            Either::Left(m) => Blocktype::Empty(m),
-            Either::Right(Either::Left(m)) => Blocktype::ValType(m),
-            Either::Right(Either::Right(m)) => Blocktype::TypeIdx(m),
-        }
+impl From<CallIndirectInner> for CallIndirect {
+    fn ex_from(m: CallIndirectInner) -> CallIndirect {
+        let (y, x) = m;
+        CallIndirect { y, x }
     }
-    
 }
 
-
-pub struct BlocktypeMapper;
-impl View for BlocktypeMapper {
+pub struct CallIndirectMapper;
+impl View for CallIndirectMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for BlocktypeMapper {
-    type Src = SpecBlocktypeInner;
-    type Dst = SpecBlocktype;
+impl SpecIso for CallIndirectMapper {
+    type Src = SpecCallIndirectInner;
+    type Dst = SpecCallIndirect;
 }
-impl SpecIsoProof for BlocktypeMapper {
+impl SpecIsoProof for CallIndirectMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -3349,198 +3672,179 @@ impl SpecIsoProof for BlocktypeMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for BlocktypeMapper {
-    type Src = BlocktypeInner<'a>;
-    type Dst = Blocktype<'a>;
-    type RefSrc = BlocktypeInnerRef<'a>;
-}
-
-type SpecBlocktypeCombinatorAlias1 = Choice<SpecValtypeBlockCombinator, SpecTypeidxBlockCombinator>;
-type SpecBlocktypeCombinatorAlias2 = Choice<SpecEmptyBlockCombinator, SpecBlocktypeCombinatorAlias1>;
-impl DisjointFrom<SpecEmptyBlockCombinator> for SpecValtypeBlockCombinator {
-    open spec fn disjoint_from(&self, other: &SpecEmptyBlockCombinator) -> bool
-    { self.0.disjoint_from(&other.0) }
-    proof fn parse_disjoint_on(&self, other: &SpecEmptyBlockCombinator, buf: Seq<u8>) 
-    { self.0.parse_disjoint_on(&other.0, buf); }
-}
-
-impl DisjointFrom<SpecEmptyBlockCombinator> for SpecTypeidxBlockCombinator {
-    open spec fn disjoint_from(&self, other: &SpecEmptyBlockCombinator) -> bool
-    { self.0.disjoint_from(&other.0) }
-    proof fn parse_disjoint_on(&self, other: &SpecEmptyBlockCombinator, buf: Seq<u8>) 
-    { self.0.parse_disjoint_on(&other.0, buf); }
-}
-
-impl DisjointFrom<SpecValtypeBlockCombinator> for SpecTypeidxBlockCombinator {
-    open spec fn disjoint_from(&self, other: &SpecValtypeBlockCombinator) -> bool
-    { self.0.disjoint_from(&other.0) }
-    proof fn parse_disjoint_on(&self, other: &SpecValtypeBlockCombinator, buf: Seq<u8>) 
-    { self.0.parse_disjoint_on(&other.0, buf); }
+impl<'a> Iso<'a> for CallIndirectMapper {
+    type Src = CallIndirectInner;
+    type Dst = CallIndirect;
+    type RefSrc = CallIndirectInnerRef<'a>;
 }
-pub struct SpecBlocktypeCombinator(pub SpecBlocktypeCombinatorAlias);
+type SpecCallIndirectCombinatorAlias1 = (SpecTypeidxCombinator, SpecTableidxCombinator);
+pub struct SpecCallIndirectCombinator(pub SpecCallIndirectCombinatorAlias);
 
-impl SpecCombinator for SpecBlocktypeCombinator {
-    type Type = SpecBlocktype;
+impl SpecCombinator for SpecCallIndirectCombinator {
+    type Type = SpecCallIndirect;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecBlocktypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecBlocktypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCallIndirectCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCallIndirectCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecBlocktypeCombinatorAlias = Mapped<SpecBlocktypeCombinatorAlias2, BlocktypeMapper>;
-type BlocktypeCombinatorAlias1 = Choice<ValtypeBlockCombinator, TypeidxBlockCombinator>;
-type BlocktypeCombinatorAlias2 = Choice<EmptyBlockCombinator, BlocktypeCombinator1>;
-pub struct BlocktypeCombinator1(pub BlocktypeCombinatorAlias1);
-impl View for BlocktypeCombinator1 {
-    type V = SpecBlocktypeCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(BlocktypeCombinator1, BlocktypeCombinatorAlias1);
-
-pub struct BlocktypeCombinator2(pub BlocktypeCombinatorAlias2);
-impl View for BlocktypeCombinator2 {
-    type V = SpecBlocktypeCombinatorAlias2;
+pub type SpecCallIndirectCombinatorAlias = Mapped<SpecCallIndirectCombinatorAlias1, CallIndirectMapper>;
+type CallIndirectCombinatorAlias1 = (TypeidxCombinator, TableidxCombinator);
+pub struct CallIndirectCombinator1(pub CallIndirectCombinatorAlias1);
+impl View for CallIndirectCombinator1 {
+    type V = SpecCallIndirectCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(BlocktypeCombinator2, BlocktypeCombinatorAlias2);
+impl_wrapper_combinator!(CallIndirectCombinator1, CallIndirectCombinatorAlias1);
 
-pub struct BlocktypeCombinator(pub BlocktypeCombinatorAlias);
+pub struct CallIndirectCombinator(pub CallIndirectCombinatorAlias);
 
-impl View for BlocktypeCombinator {
-    type V = SpecBlocktypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecBlocktypeCombinator(self.0@) }
+impl View for CallIndirectCombinator {
+    type V = SpecCallIndirectCombinator;
+    open spec fn view(&self) -> Self::V { SpecCallIndirectCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for BlocktypeCombinator {
-    type Type = Blocktype<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CallIndirectCombinator {
+    type Type = CallIndirect;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type BlocktypeCombinatorAlias = Mapped<BlocktypeCombinator2, BlocktypeMapper>;
+}
+pub type CallIndirectCombinatorAlias = Mapped<CallIndirectCombinator1, CallIndirectMapper>;
 
 
-pub open spec fn spec_blocktype() -> SpecBlocktypeCombinator {
-    SpecBlocktypeCombinator(Mapped { inner: Choice(spec_empty_block(), Choice(spec_valtype_block(), spec_typeidx_block())), mapper: BlocktypeMapper })
+pub open spec fn spec_call_indirect() -> SpecCallIndirectCombinator {
+    SpecCallIndirectCombinator(
+    Mapped {
+        inner: (spec_typeidx(), spec_tableidx()),
+        mapper: CallIndirectMapper,
+    })
 }
 
                 
-pub fn blocktype<'a>() -> (o: BlocktypeCombinator)
-    ensures o@ == spec_blocktype(),
+pub fn call_indirect<'a>() -> (o: CallIndirectCombinator)
+    ensures o@ == spec_call_indirect(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = BlocktypeCombinator(Mapped { inner: BlocktypeCombinator2(Choice::new(empty_block(), BlocktypeCombinator1(Choice::new(valtype_block(), typeidx_block())))), mapper: BlocktypeMapper });
-    assert({
-        &&& combinator@ == spec_blocktype()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = CallIndirectCombinator(
+    Mapped {
+        inner: CallIndirectCombinator1((typeidx(), tableidx())),
+        mapper: CallIndirectMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_call_indirect()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_blocktype<'a>(input: &'a [u8]) -> (res: PResult<<BlocktypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_call_indirect<'a>(input: &'a [u8]) -> (res: PResult<<CallIndirectCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_blocktype().spec_parse(input@) == Some((n as int, v@)),
-        spec_blocktype().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_call_indirect().spec_parse(input@) == Some((n as int, v@)),
+        spec_call_indirect().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_blocktype().spec_parse(input@) is None,
-        spec_blocktype().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_call_indirect().spec_parse(input@) is None,
+        spec_call_indirect().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = blocktype();
+    let combinator = call_indirect();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_blocktype<'a>(v: <BlocktypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_call_indirect<'a>(v: <CallIndirectCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_blocktype().wf(v@),
+        spec_call_indirect().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_blocktype().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_blocktype().spec_serialize(v@))
+            &&& n == spec_call_indirect().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_call_indirect().spec_serialize(v@))
         },
 {
-    let combinator = blocktype();
+    let combinator = call_indirect();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn blocktype_len<'a>(v: <BlocktypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn call_indirect_len<'a>(v: <CallIndirectCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_blocktype().wf(v@),
-        spec_blocktype().spec_serialize(v@).len() <= usize::MAX,
+        spec_call_indirect().wf(v@),
+        spec_call_indirect().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_blocktype().spec_serialize(v@).len(),
+        serialize_len == spec_call_indirect().spec_serialize(v@).len(),
 {
-    let combinator = blocktype();
+    let combinator = call_indirect();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub enum SpecInstrControl1 {
-    If(SpecBlocktype),
-    Block(SpecBlocktype),
-    Loop(SpecBlocktype),
-    Else(SpecEmpty),
-    Unreachable(SpecEmpty),
-    Nop(SpecEmpty),
+pub enum SpecInstrControl2 {
+    End(SpecEmpty),
+    BrIf(SpecLabelidx),
+    Br(SpecLabelidx),
+    Call(SpecFuncidx),
+    Ret(SpecEmpty),
+    BrTable(SpecBrTable),
+    CallIndirect(SpecCallIndirect),
 }
 
-pub type SpecInstrControl1Inner = Either<SpecBlocktype, Either<SpecBlocktype, Either<SpecBlocktype, Either<SpecEmpty, Either<SpecEmpty, SpecEmpty>>>>>;
+pub type SpecInstrControl2Inner = Either<SpecEmpty, Either<SpecLabelidx, Either<SpecLabelidx, Either<SpecFuncidx, Either<SpecEmpty, Either<SpecBrTable, SpecCallIndirect>>>>>>;
 
-impl SpecFrom<SpecInstrControl1> for SpecInstrControl1Inner {
-    open spec fn spec_from(m: SpecInstrControl1) -> SpecInstrControl1Inner {
+impl SpecFrom<SpecInstrControl2> for SpecInstrControl2Inner {
+    open spec fn spec_from(m: SpecInstrControl2) -> SpecInstrControl2Inner {
         match m {
-            SpecInstrControl1::If(m) => Either::Left(m),
-            SpecInstrControl1::Block(m) => Either::Right(Either::Left(m)),
-            SpecInstrControl1::Loop(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecInstrControl1::Else(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            SpecInstrControl1::Unreachable(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            SpecInstrControl1::Nop(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))),
+            SpecInstrControl2::End(m) => Either::Left(m),
+            SpecInstrControl2::BrIf(m) => Either::Right(Either::Left(m)),
+            SpecInstrControl2::Br(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecInstrControl2::Call(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecInstrControl2::Ret(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecInstrControl2::BrTable(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            SpecInstrControl2::CallIndirect(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
         }
     }
 
 }
 
                 
-impl SpecFrom<SpecInstrControl1Inner> for SpecInstrControl1 {
-    open spec fn spec_from(m: SpecInstrControl1Inner) -> SpecInstrControl1 {
+impl SpecFrom<SpecInstrControl2Inner> for SpecInstrControl2 {
+    open spec fn spec_from(m: SpecInstrControl2Inner) -> SpecInstrControl2 {
         match m {
-            Either::Left(m) => SpecInstrControl1::If(m),
-            Either::Right(Either::Left(m)) => SpecInstrControl1::Block(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecInstrControl1::Loop(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecInstrControl1::Else(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecInstrControl1::Unreachable(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))) => SpecInstrControl1::Nop(m),
+            Either::Left(m) => SpecInstrControl2::End(m),
+            Either::Right(Either::Left(m)) => SpecInstrControl2::BrIf(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecInstrControl2::Br(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecInstrControl2::Call(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecInstrControl2::Ret(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecInstrControl2::BrTable(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => SpecInstrControl2::CallIndirect(m),
         }
     }
 
@@ -3549,76 +3853,80 @@ impl SpecFrom<SpecInstrControl1Inner> for SpecInstrControl1 {
 
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum InstrControl1<'a> {
-    If(Blocktype<'a>),
-    Block(Blocktype<'a>),
-    Loop(Blocktype<'a>),
-    Else(Empty<'a>),
-    Unreachable(Empty<'a>),
-    Nop(Empty<'a>),
+pub enum InstrControl2<'a> {
+    End(Empty<'a>),
+    BrIf(Labelidx),
+    Br(Labelidx),
+    Call(Funcidx),
+    Ret(Empty<'a>),
+    BrTable(BrTable),
+    CallIndirect(CallIndirect),
 }
 
-pub type InstrControl1Inner<'a> = Either<Blocktype<'a>, Either<Blocktype<'a>, Either<Blocktype<'a>, Either<Empty<'a>, Either<Empty<'a>, Empty<'a>>>>>>;
+pub type InstrControl2Inner<'a> = Either<Empty<'a>, Either<Labelidx, Either<Labelidx, Either<Funcidx, Either<Empty<'a>, Either<BrTable, CallIndirect>>>>>>;
 
-pub type InstrControl1InnerRef<'a> = Either<&'a Blocktype<'a>, Either<&'a Blocktype<'a>, Either<&'a Blocktype<'a>, Either<&'a Empty<'a>, Either<&'a Empty<'a>, &'a Empty<'a>>>>>>;
+pub type InstrControl2InnerRef<'a> = Either<&'a Empty<'a>, Either<&'a Labelidx, Either<&'a Labelidx, Either<&'a Funcidx, Either<&'a Empty<'a>, Either<&'a BrTable, &'a CallIndirect>>>>>>;
 
 
-impl<'a> View for InstrControl1<'a> {
-    type V = SpecInstrControl1;
+impl<'a> View for InstrControl2<'a> {
+    type V = SpecInstrControl2;
     open spec fn view(&self) -> Self::V {
         match self {
-            InstrControl1::If(m) => SpecInstrControl1::If(m@),
-            InstrControl1::Block(m) => SpecInstrControl1::Block(m@),
-            InstrControl1::Loop(m) => SpecInstrControl1::Loop(m@),
-            InstrControl1::Else(m) => SpecInstrControl1::Else(m@),
-            InstrControl1::Unreachable(m) => SpecInstrControl1::Unreachable(m@),
-            InstrControl1::Nop(m) => SpecInstrControl1::Nop(m@),
+            InstrControl2::End(m) => SpecInstrControl2::End(m@),
+            InstrControl2::BrIf(m) => SpecInstrControl2::BrIf(m@),
+            InstrControl2::Br(m) => SpecInstrControl2::Br(m@),
+            InstrControl2::Call(m) => SpecInstrControl2::Call(m@),
+            InstrControl2::Ret(m) => SpecInstrControl2::Ret(m@),
+            InstrControl2::BrTable(m) => SpecInstrControl2::BrTable(m@),
+            InstrControl2::CallIndirect(m) => SpecInstrControl2::CallIndirect(m@),
         }
     }
 }
 
 
-impl<'a> From<&'a InstrControl1<'a>> for InstrControl1InnerRef<'a> {
-    fn ex_from(m: &'a InstrControl1<'a>) -> InstrControl1InnerRef<'a> {
+impl<'a> From<&'a InstrControl2<'a>> for InstrControl2InnerRef<'a> {
+    fn ex_from(m: &'a InstrControl2<'a>) -> InstrControl2InnerRef<'a> {
         match m {
-            InstrControl1::If(m) => Either::Left(m),
-            InstrControl1::Block(m) => Either::Right(Either::Left(m)),
-            InstrControl1::Loop(m) => Either::Right(Either::Right(Either::Left(m))),
-            InstrControl1::Else(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            InstrControl1::Unreachable(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            InstrControl1::Nop(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))),
+            InstrControl2::End(m) => Either::Left(m),
+            InstrControl2::BrIf(m) => Either::Right(Either::Left(m)),
+            InstrControl2::Br(m) => Either::Right(Either::Right(Either::Left(m))),
+            InstrControl2::Call(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            InstrControl2::Ret(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            InstrControl2::BrTable(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            InstrControl2::CallIndirect(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
         }
     }
 
 }
 
-impl<'a> From<InstrControl1Inner<'a>> for InstrControl1<'a> {
-    fn ex_from(m: InstrControl1Inner<'a>) -> InstrControl1<'a> {
+impl<'a> From<InstrControl2Inner<'a>> for InstrControl2<'a> {
+    fn ex_from(m: InstrControl2Inner<'a>) -> InstrControl2<'a> {
         match m {
-            Either::Left(m) => InstrControl1::If(m),
-            Either::Right(Either::Left(m)) => InstrControl1::Block(m),
-            Either::Right(Either::Right(Either::Left(m))) => InstrControl1::Loop(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => InstrControl1::Else(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => InstrControl1::Unreachable(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))) => InstrControl1::Nop(m),
+            Either::Left(m) => InstrControl2::End(m),
+            Either::Right(Either::Left(m)) => InstrControl2::BrIf(m),
+            Either::Right(Either::Right(Either::Left(m))) => InstrControl2::Br(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => InstrControl2::Call(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => InstrControl2::Ret(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => InstrControl2::BrTable(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => InstrControl2::CallIndirect(m),
         }
     }
     
 }
 
 
-pub struct InstrControl1Mapper;
-impl View for InstrControl1Mapper {
+pub struct InstrControl2Mapper;
+impl View for InstrControl2Mapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for InstrControl1Mapper {
-    type Src = SpecInstrControl1Inner;
-    type Dst = SpecInstrControl1;
+impl SpecIso for InstrControl2Mapper {
+    type Src = SpecInstrControl2Inner;
+    type Dst = SpecInstrControl2;
 }
-impl SpecIsoProof for InstrControl1Mapper {
+impl SpecIsoProof for InstrControl2Mapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -3626,233 +3934,251 @@ impl SpecIsoProof for InstrControl1Mapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for InstrControl1Mapper {
-    type Src = InstrControl1Inner<'a>;
-    type Dst = InstrControl1<'a>;
-    type RefSrc = InstrControl1InnerRef<'a>;
+impl<'a> Iso<'a> for InstrControl2Mapper {
+    type Src = InstrControl2Inner<'a>;
+    type Dst = InstrControl2<'a>;
+    type RefSrc = InstrControl2InnerRef<'a>;
 }
 
-type SpecInstrControl1CombinatorAlias1 = Choice<Cond<SpecEmptyCombinator>, Cond<SpecEmptyCombinator>>;
-type SpecInstrControl1CombinatorAlias2 = Choice<Cond<SpecEmptyCombinator>, SpecInstrControl1CombinatorAlias1>;
-type SpecInstrControl1CombinatorAlias3 = Choice<Cond<SpecBlocktypeCombinator>, SpecInstrControl1CombinatorAlias2>;
-type SpecInstrControl1CombinatorAlias4 = Choice<Cond<SpecBlocktypeCombinator>, SpecInstrControl1CombinatorAlias3>;
-type SpecInstrControl1CombinatorAlias5 = Choice<Cond<SpecBlocktypeCombinator>, SpecInstrControl1CombinatorAlias4>;
-pub struct SpecInstrControl1Combinator(pub SpecInstrControl1CombinatorAlias);
+type SpecInstrControl2CombinatorAlias1 = Choice<Cond<SpecBrTableCombinator>, Cond<SpecCallIndirectCombinator>>;
+type SpecInstrControl2CombinatorAlias2 = Choice<Cond<SpecEmptyCombinator>, SpecInstrControl2CombinatorAlias1>;
+type SpecInstrControl2CombinatorAlias3 = Choice<Cond<SpecFuncidxCombinator>, SpecInstrControl2CombinatorAlias2>;
+type SpecInstrControl2CombinatorAlias4 = Choice<Cond<SpecLabelidxCombinator>, SpecInstrControl2CombinatorAlias3>;
+type SpecInstrControl2CombinatorAlias5 = Choice<Cond<SpecLabelidxCombinator>, SpecInstrControl2CombinatorAlias4>;
+type SpecInstrControl2CombinatorAlias6 = Choice<Cond<SpecEmptyCombinator>, SpecInstrControl2CombinatorAlias5>;
+pub struct SpecInstrControl2Combinator(pub SpecInstrControl2CombinatorAlias);
 
-impl SpecCombinator for SpecInstrControl1Combinator {
-    type Type = SpecInstrControl1;
+impl SpecCombinator for SpecInstrControl2Combinator {
+    type Type = SpecInstrControl2;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecInstrControl1Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecInstrControl1CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecInstrControl2Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecInstrControl2CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecInstrControl1CombinatorAlias = Mapped<SpecInstrControl1CombinatorAlias5, InstrControl1Mapper>;
-type InstrControl1CombinatorAlias1 = Choice<Cond<EmptyCombinator>, Cond<EmptyCombinator>>;
-type InstrControl1CombinatorAlias2 = Choice<Cond<EmptyCombinator>, InstrControl1Combinator1>;
-type InstrControl1CombinatorAlias3 = Choice<Cond<BlocktypeCombinator>, InstrControl1Combinator2>;
-type InstrControl1CombinatorAlias4 = Choice<Cond<BlocktypeCombinator>, InstrControl1Combinator3>;
-type InstrControl1CombinatorAlias5 = Choice<Cond<BlocktypeCombinator>, InstrControl1Combinator4>;
-pub struct InstrControl1Combinator1(pub InstrControl1CombinatorAlias1);
-impl View for InstrControl1Combinator1 {
-    type V = SpecInstrControl1CombinatorAlias1;
+pub type SpecInstrControl2CombinatorAlias = Mapped<SpecInstrControl2CombinatorAlias6, InstrControl2Mapper>;
+type InstrControl2CombinatorAlias1 = Choice<Cond<BrTableCombinator>, Cond<CallIndirectCombinator>>;
+type InstrControl2CombinatorAlias2 = Choice<Cond<EmptyCombinator>, InstrControl2Combinator1>;
+type InstrControl2CombinatorAlias3 = Choice<Cond<FuncidxCombinator>, InstrControl2Combinator2>;
+type InstrControl2CombinatorAlias4 = Choice<Cond<LabelidxCombinator>, InstrControl2Combinator3>;
+type InstrControl2CombinatorAlias5 = Choice<Cond<LabelidxCombinator>, InstrControl2Combinator4>;
+type InstrControl2CombinatorAlias6 = Choice<Cond<EmptyCombinator>, InstrControl2Combinator5>;
+pub struct InstrControl2Combinator1(pub InstrControl2CombinatorAlias1);
+impl View for InstrControl2Combinator1 {
+    type V = SpecInstrControl2CombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(InstrControl1Combinator1, InstrControl1CombinatorAlias1);
+impl_wrapper_combinator!(InstrControl2Combinator1, InstrControl2CombinatorAlias1);
 
-pub struct InstrControl1Combinator2(pub InstrControl1CombinatorAlias2);
-impl View for InstrControl1Combinator2 {
-    type V = SpecInstrControl1CombinatorAlias2;
+pub struct InstrControl2Combinator2(pub InstrControl2CombinatorAlias2);
+impl View for InstrControl2Combinator2 {
+    type V = SpecInstrControl2CombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(InstrControl2Combinator2, InstrControl2CombinatorAlias2);
+
+pub struct InstrControl2Combinator3(pub InstrControl2CombinatorAlias3);
+impl View for InstrControl2Combinator3 {
+    type V = SpecInstrControl2CombinatorAlias3;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(InstrControl1Combinator2, InstrControl1CombinatorAlias2);
+impl_wrapper_combinator!(InstrControl2Combinator3, InstrControl2CombinatorAlias3);
 
-pub struct InstrControl1Combinator3(pub InstrControl1CombinatorAlias3);
-impl View for InstrControl1Combinator3 {
-    type V = SpecInstrControl1CombinatorAlias3;
+pub struct InstrControl2Combinator4(pub InstrControl2CombinatorAlias4);
+impl View for InstrControl2Combinator4 {
+    type V = SpecInstrControl2CombinatorAlias4;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(InstrControl1Combinator3, InstrControl1CombinatorAlias3);
+impl_wrapper_combinator!(InstrControl2Combinator4, InstrControl2CombinatorAlias4);
 
-pub struct InstrControl1Combinator4(pub InstrControl1CombinatorAlias4);
-impl View for InstrControl1Combinator4 {
-    type V = SpecInstrControl1CombinatorAlias4;
+pub struct InstrControl2Combinator5(pub InstrControl2CombinatorAlias5);
+impl View for InstrControl2Combinator5 {
+    type V = SpecInstrControl2CombinatorAlias5;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(InstrControl1Combinator4, InstrControl1CombinatorAlias4);
+impl_wrapper_combinator!(InstrControl2Combinator5, InstrControl2CombinatorAlias5);
 
-pub struct InstrControl1Combinator5(pub InstrControl1CombinatorAlias5);
-impl View for InstrControl1Combinator5 {
-    type V = SpecInstrControl1CombinatorAlias5;
+pub struct InstrControl2Combinator6(pub InstrControl2CombinatorAlias6);
+impl View for InstrControl2Combinator6 {
+    type V = SpecInstrControl2CombinatorAlias6;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(InstrControl1Combinator5, InstrControl1CombinatorAlias5);
+impl_wrapper_combinator!(InstrControl2Combinator6, InstrControl2CombinatorAlias6);
 
-pub struct InstrControl1Combinator(pub InstrControl1CombinatorAlias);
+pub struct InstrControl2Combinator(pub InstrControl2CombinatorAlias);
 
-impl View for InstrControl1Combinator {
-    type V = SpecInstrControl1Combinator;
-    open spec fn view(&self) -> Self::V { SpecInstrControl1Combinator(self.0@) }
+impl View for InstrControl2Combinator {
+    type V = SpecInstrControl2Combinator;
+    open spec fn view(&self) -> Self::V { SpecInstrControl2Combinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrControl1Combinator {
-    type Type = InstrControl1<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrControl2Combinator {
+    type Type = InstrControl2<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type InstrControl1CombinatorAlias = Mapped<InstrControl1Combinator5, InstrControl1Mapper>;
+}
+pub type InstrControl2CombinatorAlias = Mapped<InstrControl2Combinator6, InstrControl2Mapper>;
 
 
-pub open spec fn spec_instr_control1(opcode: u8) -> SpecInstrControl1Combinator {
-    SpecInstrControl1Combinator(Mapped { inner: Choice(Cond { cond: opcode == InstrBytecode::SPEC_If, inner: spec_blocktype() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Block, inner: spec_blocktype() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Loop, inner: spec_blocktype() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Else, inner: spec_empty() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Unreachable, inner: spec_empty() }, Cond { cond: opcode == InstrBytecode::SPEC_Nop, inner: spec_empty() }))))), mapper: InstrControl1Mapper })
+pub open spec fn spec_instr_control2(opcode: u8) -> SpecInstrControl2Combinator {
+    SpecInstrControl2Combinator(Mapped { inner: Choice(Cond { cond: opcode == InstrBytecode::SPEC_End, inner: spec_empty() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_BrIf, inner: spec_labelidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Br, inner: spec_labelidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Call, inner: spec_funcidx() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Ret, inner: spec_empty() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_BrTable, inner: spec_br_table() }, Cond { cond: opcode == InstrBytecode::SPEC_CallIndirect, inner: spec_call_indirect() })))))), mapper: InstrControl2Mapper })
 }
 
-pub fn instr_control1<'a>(opcode: u8) -> (o: InstrControl1Combinator)
-    ensures o@ == spec_instr_control1(opcode@),
+pub fn instr_control2<'a>(opcode: u8) -> (o: InstrControl2Combinator)
+    requires
+        spec_instr_bytecode().wf(opcode@),
+
+    ensures o@ == spec_instr_control2(opcode@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = InstrControl1Combinator(Mapped { inner: InstrControl1Combinator5(Choice::new(Cond { cond: opcode == InstrBytecode::If, inner: blocktype() }, InstrControl1Combinator4(Choice::new(Cond { cond: opcode == InstrBytecode::Block, inner: blocktype() }, InstrControl1Combinator3(Choice::new(Cond { cond: opcode == InstrBytecode::Loop, inner: blocktype() }, InstrControl1Combinator2(Choice::new(Cond { cond: opcode == InstrBytecode::Else, inner: empty() }, InstrControl1Combinator1(Choice::new(Cond { cond: opcode == InstrBytecode::Unreachable, inner: empty() }, Cond { cond: opcode == InstrBytecode::Nop, inner: empty() })))))))))), mapper: InstrControl1Mapper });
-    assert({
-        &&& combinator@ == spec_instr_control1(opcode@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = InstrControl2Combinator(Mapped { inner: InstrControl2Combinator6(Choice::new(Cond { cond: opcode == InstrBytecode::End, inner: empty() }, InstrControl2Combinator5(Choice::new(Cond { cond: opcode == InstrBytecode::BrIf, inner: labelidx() }, InstrControl2Combinator4(Choice::new(Cond { cond: opcode == InstrBytecode::Br, inner: labelidx() }, InstrControl2Combinator3(Choice::new(Cond { cond: opcode == InstrBytecode::Call, inner: funcidx() }, InstrControl2Combinator2(Choice::new(Cond { cond: opcode == InstrBytecode::Ret, inner: empty() }, InstrControl2Combinator1(Choice::new(Cond { cond: opcode == InstrBytecode::BrTable, inner: br_table() }, Cond { cond: opcode == InstrBytecode::CallIndirect, inner: call_indirect() })))))))))))), mapper: InstrControl2Mapper });
+    // assert({
+    //     &&& combinator@ == spec_instr_control2(opcode@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_instr_control1<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrControl1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_instr_control2<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrControl2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_instr_control1(opcode@).spec_parse(input@) == Some((n as int, v@)),
-        spec_instr_control1(opcode@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_instr_control2(opcode@).spec_parse(input@) == Some((n as int, v@)),
+        spec_instr_control2(opcode@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_instr_control1(opcode@).spec_parse(input@) is None,
-        spec_instr_control1(opcode@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_instr_control2(opcode@).spec_parse(input@) is None,
+        spec_instr_control2(opcode@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = instr_control1( opcode );
+    let combinator = instr_control2( opcode );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_instr_control1<'a>(v: <InstrControl1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, opcode: u8) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_instr_control2<'a>(v: <InstrControl2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, opcode: u8) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_instr_control1(opcode@).wf(v@),
+        spec_instr_control2(opcode@).wf(v@),
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_instr_control1(opcode@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_instr_control1(opcode@).spec_serialize(v@))
+            &&& n == spec_instr_control2(opcode@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_instr_control2(opcode@).spec_serialize(v@))
         },
 {
-    let combinator = instr_control1( opcode );
+    let combinator = instr_control2( opcode );
     combinator.serialize(v, data, pos)
 }
 
-pub fn instr_control1_len<'a>(v: <InstrControl1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, opcode: u8) -> (serialize_len: usize)
+pub fn instr_control2_len<'a>(v: <InstrControl2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, opcode: u8) -> (serialize_len: usize)
     requires
-        spec_instr_control1(opcode@).wf(v@),
-        spec_instr_control1(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_control2(opcode@).wf(v@),
+        spec_instr_control2(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
-        serialize_len == spec_instr_control1(opcode@).spec_serialize(v@).len(),
+        serialize_len == spec_instr_control2(opcode@).spec_serialize(v@).len(),
 {
-    let combinator = instr_control1( opcode );
+    let combinator = instr_control2( opcode );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
 
-pub struct SpecMemarg {
-    pub align: u64,
-    pub offset: u64,
+pub struct SpecEmptyBlock {
+    pub tag: u8,
+    pub body: SpecEmpty,
 }
 
-pub type SpecMemargInner = (u64, u64);
+pub type SpecEmptyBlockInner = (u8, SpecEmpty);
 
 
-impl SpecFrom<SpecMemarg> for SpecMemargInner {
-    open spec fn spec_from(m: SpecMemarg) -> SpecMemargInner {
-        (m.align, m.offset)
+impl SpecFrom<SpecEmptyBlock> for SpecEmptyBlockInner {
+    open spec fn spec_from(m: SpecEmptyBlock) -> SpecEmptyBlockInner {
+        (m.tag, m.body)
     }
 }
 
-impl SpecFrom<SpecMemargInner> for SpecMemarg {
-    open spec fn spec_from(m: SpecMemargInner) -> SpecMemarg {
-        let (align, offset) = m;
-        SpecMemarg { align, offset }
+impl SpecFrom<SpecEmptyBlockInner> for SpecEmptyBlock {
+    open spec fn spec_from(m: SpecEmptyBlockInner) -> SpecEmptyBlock {
+        let (tag, body) = m;
+        SpecEmptyBlock { tag, body }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Memarg {
-    pub align: u64,
-    pub offset: u64,
+pub struct EmptyBlock<'a> {
+    pub tag: u8,
+    pub body: Empty<'a>,
 }
 
-impl View for Memarg {
-    type V = SpecMemarg;
+impl View for EmptyBlock<'_> {
+    type V = SpecEmptyBlock;
 
     open spec fn view(&self) -> Self::V {
-        SpecMemarg {
-            align: self.align@,
-            offset: self.offset@,
+        SpecEmptyBlock {
+            tag: self.tag@,
+            body: self.body@,
         }
     }
 }
-pub type MemargInner = (u64, u64);
+pub type EmptyBlockInner<'a> = (u8, Empty<'a>);
 
-pub type MemargInnerRef<'a> = (&'a u64, &'a u64);
-impl<'a> From<&'a Memarg> for MemargInnerRef<'a> {
-    fn ex_from(m: &'a Memarg) -> MemargInnerRef<'a> {
-        (&m.align, &m.offset)
+pub type EmptyBlockInnerRef<'a> = (&'a u8, &'a Empty<'a>);
+impl<'a> From<&'a EmptyBlock<'a>> for EmptyBlockInnerRef<'a> {
+    fn ex_from(m: &'a EmptyBlock) -> EmptyBlockInnerRef<'a> {
+        (&m.tag, &m.body)
     }
 }
 
-impl From<MemargInner> for Memarg {
-    fn ex_from(m: MemargInner) -> Memarg {
-        let (align, offset) = m;
-        Memarg { align, offset }
+impl<'a> From<EmptyBlockInner<'a>> for EmptyBlock<'a> {
+    fn ex_from(m: EmptyBlockInner) -> EmptyBlock {
+        let (tag, body) = m;
+        EmptyBlock { tag, body }
     }
 }
 
-pub struct MemargMapper;
-impl View for MemargMapper {
+pub struct EmptyBlockMapper;
+impl View for EmptyBlockMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for MemargMapper {
-    type Src = SpecMemargInner;
-    type Dst = SpecMemarg;
+impl SpecIso for EmptyBlockMapper {
+    type Src = SpecEmptyBlockInner;
+    type Dst = SpecEmptyBlock;
 }
-impl SpecIsoProof for MemargMapper {
+impl SpecIsoProof for EmptyBlockMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -3860,203 +4186,226 @@ impl SpecIsoProof for MemargMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for MemargMapper {
-    type Src = MemargInner;
-    type Dst = Memarg;
-    type RefSrc = MemargInnerRef<'a>;
+impl<'a> Iso<'a> for EmptyBlockMapper {
+    type Src = EmptyBlockInner<'a>;
+    type Dst = EmptyBlock<'a>;
+    type RefSrc = EmptyBlockInnerRef<'a>;
 }
-type SpecMemargCombinatorAlias1 = (UnsignedLEB128, UnsignedLEB128);
-pub struct SpecMemargCombinator(pub SpecMemargCombinatorAlias);
+type SpecEmptyBlockCombinatorAlias1 = (Refined<U8, Predicate16713707613369419146>, SpecEmptyCombinator);
+pub struct SpecEmptyBlockCombinator(pub SpecEmptyBlockCombinatorAlias);
 
-impl SpecCombinator for SpecMemargCombinator {
-    type Type = SpecMemarg;
+impl SpecCombinator for SpecEmptyBlockCombinator {
+    type Type = SpecEmptyBlock;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecMemargCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecMemargCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecEmptyBlockCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecEmptyBlockCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecMemargCombinatorAlias = Mapped<SpecMemargCombinatorAlias1, MemargMapper>;
-type MemargCombinatorAlias1 = (UnsignedLEB128, UnsignedLEB128);
-pub struct MemargCombinator1(pub MemargCombinatorAlias1);
-impl View for MemargCombinator1 {
-    type V = SpecMemargCombinatorAlias1;
+pub type SpecEmptyBlockCombinatorAlias = Mapped<SpecEmptyBlockCombinatorAlias1, EmptyBlockMapper>;
+pub struct Predicate16713707613369419146;
+impl View for Predicate16713707613369419146 {
+    type V = Self;
+
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate16713707613369419146 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 64)
+    }
+}
+impl SpecPred<u8> for Predicate16713707613369419146 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 64)
+    }
+}
+type EmptyBlockCombinatorAlias1 = (Refined<U8, Predicate16713707613369419146>, EmptyCombinator);
+pub struct EmptyBlockCombinator1(pub EmptyBlockCombinatorAlias1);
+impl View for EmptyBlockCombinator1 {
+    type V = SpecEmptyBlockCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(MemargCombinator1, MemargCombinatorAlias1);
+impl_wrapper_combinator!(EmptyBlockCombinator1, EmptyBlockCombinatorAlias1);
 
-pub struct MemargCombinator(pub MemargCombinatorAlias);
+pub struct EmptyBlockCombinator(pub EmptyBlockCombinatorAlias);
 
-impl View for MemargCombinator {
-    type V = SpecMemargCombinator;
-    open spec fn view(&self) -> Self::V { SpecMemargCombinator(self.0@) }
+impl View for EmptyBlockCombinator {
+    type V = SpecEmptyBlockCombinator;
+    open spec fn view(&self) -> Self::V { SpecEmptyBlockCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemargCombinator {
-    type Type = Memarg;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for EmptyBlockCombinator {
+    type Type = EmptyBlock<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type MemargCombinatorAlias = Mapped<MemargCombinator1, MemargMapper>;
+}
+pub type EmptyBlockCombinatorAlias = Mapped<EmptyBlockCombinator1, EmptyBlockMapper>;
 
 
-pub open spec fn spec_memarg() -> SpecMemargCombinator {
-    SpecMemargCombinator(
+pub open spec fn spec_empty_block() -> SpecEmptyBlockCombinator {
+    SpecEmptyBlockCombinator(
     Mapped {
-        inner: (UnsignedLEB128, UnsignedLEB128),
-        mapper: MemargMapper,
+        inner: (Refined { inner: U8, predicate: Predicate16713707613369419146 }, spec_empty()),
+        mapper: EmptyBlockMapper,
     })
 }
 
                 
-pub fn memarg<'a>() -> (o: MemargCombinator)
-    ensures o@ == spec_memarg(),
+pub fn empty_block<'a>() -> (o: EmptyBlockCombinator)
+    ensures o@ == spec_empty_block(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = MemargCombinator(
+    let combinator = EmptyBlockCombinator(
     Mapped {
-        inner: MemargCombinator1((UnsignedLEB128, UnsignedLEB128)),
-        mapper: MemargMapper,
-    });
-    assert({
-        &&& combinator@ == spec_memarg()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: EmptyBlockCombinator1((Refined { inner: U8, predicate: Predicate16713707613369419146 }, empty())),
+        mapper: EmptyBlockMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_empty_block()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_memarg<'a>(input: &'a [u8]) -> (res: PResult<<MemargCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_empty_block<'a>(input: &'a [u8]) -> (res: PResult<<EmptyBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_memarg().spec_parse(input@) == Some((n as int, v@)),
-        spec_memarg().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_empty_block().spec_parse(input@) == Some((n as int, v@)),
+        spec_empty_block().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_memarg().spec_parse(input@) is None,
-        spec_memarg().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_empty_block().spec_parse(input@) is None,
+        spec_empty_block().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = memarg();
+    let combinator = empty_block();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_memarg<'a>(v: <MemargCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_empty_block<'a>(v: <EmptyBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_memarg().wf(v@),
+        spec_empty_block().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_memarg().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_memarg().spec_serialize(v@))
+            &&& n == spec_empty_block().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_empty_block().spec_serialize(v@))
         },
 {
-    let combinator = memarg();
+    let combinator = empty_block();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn memarg_len<'a>(v: <MemargCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn empty_block_len<'a>(v: <EmptyBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_memarg().wf(v@),
-        spec_memarg().spec_serialize(v@).len() <= usize::MAX,
+        spec_empty_block().wf(v@),
+        spec_empty_block().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_memarg().spec_serialize(v@).len(),
+        serialize_len == spec_empty_block().spec_serialize(v@).len(),
 {
-    let combinator = memarg();
+    let combinator = empty_block();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecByteZero {
-    pub zero: u8,
+pub struct SpecValtypeBlock {
+    pub tag: u8,
+    pub body: SpecEmpty,
 }
 
-pub type SpecByteZeroInner = u8;
+pub type SpecValtypeBlockInner = (u8, SpecEmpty);
 
 
-impl SpecFrom<SpecByteZero> for SpecByteZeroInner {
-    open spec fn spec_from(m: SpecByteZero) -> SpecByteZeroInner {
-        m.zero
+impl SpecFrom<SpecValtypeBlock> for SpecValtypeBlockInner {
+    open spec fn spec_from(m: SpecValtypeBlock) -> SpecValtypeBlockInner {
+        (m.tag, m.body)
     }
 }
 
-impl SpecFrom<SpecByteZeroInner> for SpecByteZero {
-    open spec fn spec_from(m: SpecByteZeroInner) -> SpecByteZero {
-        let zero = m;
-        SpecByteZero { zero }
+impl SpecFrom<SpecValtypeBlockInner> for SpecValtypeBlock {
+    open spec fn spec_from(m: SpecValtypeBlockInner) -> SpecValtypeBlock {
+        let (tag, body) = m;
+        SpecValtypeBlock { tag, body }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ByteZero {
-    pub zero: u8,
+pub struct ValtypeBlock<'a> {
+    pub tag: u8,
+    pub body: Empty<'a>,
 }
 
-impl View for ByteZero {
-    type V = SpecByteZero;
+impl View for ValtypeBlock<'_> {
+    type V = SpecValtypeBlock;
 
     open spec fn view(&self) -> Self::V {
-        SpecByteZero {
-            zero: self.zero@,
+        SpecValtypeBlock {
+            tag: self.tag@,
+            body: self.body@,
         }
     }
 }
-pub type ByteZeroInner = u8;
+pub type ValtypeBlockInner<'a> = (u8, Empty<'a>);
 
-pub type ByteZeroInnerRef<'a> = &'a u8;
-impl<'a> From<&'a ByteZero> for ByteZeroInnerRef<'a> {
-    fn ex_from(m: &'a ByteZero) -> ByteZeroInnerRef<'a> {
-        &m.zero
+pub type ValtypeBlockInnerRef<'a> = (&'a u8, &'a Empty<'a>);
+impl<'a> From<&'a ValtypeBlock<'a>> for ValtypeBlockInnerRef<'a> {
+    fn ex_from(m: &'a ValtypeBlock) -> ValtypeBlockInnerRef<'a> {
+        (&m.tag, &m.body)
     }
 }
 
-impl From<ByteZeroInner> for ByteZero {
-    fn ex_from(m: ByteZeroInner) -> ByteZero {
-        let zero = m;
-        ByteZero { zero }
+impl<'a> From<ValtypeBlockInner<'a>> for ValtypeBlock<'a> {
+    fn ex_from(m: ValtypeBlockInner) -> ValtypeBlock {
+        let (tag, body) = m;
+        ValtypeBlock { tag, body }
     }
 }
 
-pub struct ByteZeroMapper;
-impl View for ByteZeroMapper {
+pub struct ValtypeBlockMapper;
+impl View for ValtypeBlockMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ByteZeroMapper {
-    type Src = SpecByteZeroInner;
-    type Dst = SpecByteZero;
+impl SpecIso for ValtypeBlockMapper {
+    type Src = SpecValtypeBlockInner;
+    type Dst = SpecValtypeBlock;
 }
-impl SpecIsoProof for ByteZeroMapper {
+impl SpecIsoProof for ValtypeBlockMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -4064,255 +4413,226 @@ impl SpecIsoProof for ByteZeroMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ByteZeroMapper {
-    type Src = ByteZeroInner;
-    type Dst = ByteZero;
-    type RefSrc = ByteZeroInnerRef<'a>;
+impl<'a> Iso<'a> for ValtypeBlockMapper {
+    type Src = ValtypeBlockInner<'a>;
+    type Dst = ValtypeBlock<'a>;
+    type RefSrc = ValtypeBlockInnerRef<'a>;
 }
-pub const BYTEZEROZERO_CONST: u8 = 0;
-
-pub struct SpecByteZeroCombinator(pub SpecByteZeroCombinatorAlias);
+type SpecValtypeBlockCombinatorAlias1 = (Refined<U8, Predicate17051755724411564727>, SpecEmptyCombinator);
+pub struct SpecValtypeBlockCombinator(pub SpecValtypeBlockCombinatorAlias);
 
-impl SpecCombinator for SpecByteZeroCombinator {
-    type Type = SpecByteZero;
+impl SpecCombinator for SpecValtypeBlockCombinator {
+    type Type = SpecValtypeBlock;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecByteZeroCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecByteZeroCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecValtypeBlockCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecValtypeBlockCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecByteZeroCombinatorAlias = Mapped<Refined<U8, TagPred<u8>>, ByteZeroMapper>;
+pub type SpecValtypeBlockCombinatorAlias = Mapped<SpecValtypeBlockCombinatorAlias1, ValtypeBlockMapper>;
+pub struct Predicate17051755724411564727;
+impl View for Predicate17051755724411564727 {
+    type V = Self;
 
-pub struct ByteZeroCombinator(pub ByteZeroCombinatorAlias);
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl Pred<u8> for Predicate17051755724411564727 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 123) || (i == 124) || (i == 125) || (i == 126) || (i == 127) || (i == 111) || (i == 112)
+    }
+}
+impl SpecPred<u8> for Predicate17051755724411564727 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        (i == 123) || (i == 124) || (i == 125) || (i == 126) || (i == 127) || (i == 111) || (i == 112)
+    }
+}
+type ValtypeBlockCombinatorAlias1 = (Refined<U8, Predicate17051755724411564727>, EmptyCombinator);
+pub struct ValtypeBlockCombinator1(pub ValtypeBlockCombinatorAlias1);
+impl View for ValtypeBlockCombinator1 {
+    type V = SpecValtypeBlockCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ValtypeBlockCombinator1, ValtypeBlockCombinatorAlias1);
 
-impl View for ByteZeroCombinator {
-    type V = SpecByteZeroCombinator;
-    open spec fn view(&self) -> Self::V { SpecByteZeroCombinator(self.0@) }
+pub struct ValtypeBlockCombinator(pub ValtypeBlockCombinatorAlias);
+
+impl View for ValtypeBlockCombinator {
+    type V = SpecValtypeBlockCombinator;
+    open spec fn view(&self) -> Self::V { SpecValtypeBlockCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ByteZeroCombinator {
-    type Type = ByteZero;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ValtypeBlockCombinator {
+    type Type = ValtypeBlock<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ByteZeroCombinatorAlias = Mapped<Refined<U8, TagPred<u8>>, ByteZeroMapper>;
+}
+pub type ValtypeBlockCombinatorAlias = Mapped<ValtypeBlockCombinator1, ValtypeBlockMapper>;
 
 
-pub open spec fn spec_byte_zero() -> SpecByteZeroCombinator {
-    SpecByteZeroCombinator(
+pub open spec fn spec_valtype_block() -> SpecValtypeBlockCombinator {
+    SpecValtypeBlockCombinator(
     Mapped {
-        inner: Refined { inner: U8, predicate: TagPred(BYTEZEROZERO_CONST) },
-        mapper: ByteZeroMapper,
+        inner: (Refined { inner: U8, predicate: Predicate17051755724411564727 }, spec_empty()),
+        mapper: ValtypeBlockMapper,
     })
 }
 
                 
-pub fn byte_zero<'a>() -> (o: ByteZeroCombinator)
-    ensures o@ == spec_byte_zero(),
+pub fn valtype_block<'a>() -> (o: ValtypeBlockCombinator)
+    ensures o@ == spec_valtype_block(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ByteZeroCombinator(
+    let combinator = ValtypeBlockCombinator(
     Mapped {
-        inner: Refined { inner: U8, predicate: TagPred(BYTEZEROZERO_CONST) },
-        mapper: ByteZeroMapper,
-    });
-    assert({
-        &&& combinator@ == spec_byte_zero()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: ValtypeBlockCombinator1((Refined { inner: U8, predicate: Predicate17051755724411564727 }, empty())),
+        mapper: ValtypeBlockMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_valtype_block()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_byte_zero<'a>(input: &'a [u8]) -> (res: PResult<<ByteZeroCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_valtype_block<'a>(input: &'a [u8]) -> (res: PResult<<ValtypeBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_byte_zero().spec_parse(input@) == Some((n as int, v@)),
-        spec_byte_zero().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_valtype_block().spec_parse(input@) == Some((n as int, v@)),
+        spec_valtype_block().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_byte_zero().spec_parse(input@) is None,
-        spec_byte_zero().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_valtype_block().spec_parse(input@) is None,
+        spec_valtype_block().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = byte_zero();
+    let combinator = valtype_block();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_byte_zero<'a>(v: <ByteZeroCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_valtype_block<'a>(v: <ValtypeBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_byte_zero().wf(v@),
+        spec_valtype_block().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_byte_zero().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_byte_zero().spec_serialize(v@))
+            &&& n == spec_valtype_block().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_valtype_block().spec_serialize(v@))
         },
 {
-    let combinator = byte_zero();
+    let combinator = valtype_block();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn byte_zero_len<'a>(v: <ByteZeroCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn valtype_block_len<'a>(v: <ValtypeBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_byte_zero().wf(v@),
-        spec_byte_zero().spec_serialize(v@).len() <= usize::MAX,
+        spec_valtype_block().wf(v@),
+        spec_valtype_block().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_byte_zero().spec_serialize(v@).len(),
+        serialize_len == spec_valtype_block().spec_serialize(v@).len(),
 {
-    let combinator = byte_zero();
+    let combinator = valtype_block();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub enum SpecInstrMemory {
-    I32Store(SpecMemarg),
-    I32Load(SpecMemarg),
-    I64Store(SpecMemarg),
-    I64Load(SpecMemarg),
-    MemorySize(SpecByteZero),
-    MemoryGrow(SpecByteZero),
-    Unrecognized(SpecMemarg),
-}
-
-pub type SpecInstrMemoryInner = Either<SpecMemarg, Either<SpecMemarg, Either<SpecMemarg, Either<SpecMemarg, Either<SpecByteZero, Either<SpecByteZero, SpecMemarg>>>>>>;
-
-impl SpecFrom<SpecInstrMemory> for SpecInstrMemoryInner {
-    open spec fn spec_from(m: SpecInstrMemory) -> SpecInstrMemoryInner {
-        match m {
-            SpecInstrMemory::I32Store(m) => Either::Left(m),
-            SpecInstrMemory::I32Load(m) => Either::Right(Either::Left(m)),
-            SpecInstrMemory::I64Store(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecInstrMemory::I64Load(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            SpecInstrMemory::MemorySize(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            SpecInstrMemory::MemoryGrow(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            SpecInstrMemory::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
-        }
-    }
-
-}
-
-                
-impl SpecFrom<SpecInstrMemoryInner> for SpecInstrMemory {
-    open spec fn spec_from(m: SpecInstrMemoryInner) -> SpecInstrMemory {
-        match m {
-            Either::Left(m) => SpecInstrMemory::I32Store(m),
-            Either::Right(Either::Left(m)) => SpecInstrMemory::I32Load(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecInstrMemory::I64Store(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecInstrMemory::I64Load(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecInstrMemory::MemorySize(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecInstrMemory::MemoryGrow(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => SpecInstrMemory::Unrecognized(m),
-        }
-    }
-
+pub struct SpecTypeidxBlock {
+    pub tag: u8,
+    pub body: u64,
 }
 
+pub type SpecTypeidxBlockInner = (u8, u64);
 
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum InstrMemory {
-    I32Store(Memarg),
-    I32Load(Memarg),
-    I64Store(Memarg),
-    I64Load(Memarg),
-    MemorySize(ByteZero),
-    MemoryGrow(ByteZero),
-    Unrecognized(Memarg),
+impl SpecFrom<SpecTypeidxBlock> for SpecTypeidxBlockInner {
+    open spec fn spec_from(m: SpecTypeidxBlock) -> SpecTypeidxBlockInner {
+        (m.tag, m.body)
+    }
 }
 
-pub type InstrMemoryInner = Either<Memarg, Either<Memarg, Either<Memarg, Either<Memarg, Either<ByteZero, Either<ByteZero, Memarg>>>>>>;
+impl SpecFrom<SpecTypeidxBlockInner> for SpecTypeidxBlock {
+    open spec fn spec_from(m: SpecTypeidxBlockInner) -> SpecTypeidxBlock {
+        let (tag, body) = m;
+        SpecTypeidxBlock { tag, body }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub type InstrMemoryInnerRef<'a> = Either<&'a Memarg, Either<&'a Memarg, Either<&'a Memarg, Either<&'a Memarg, Either<&'a ByteZero, Either<&'a ByteZero, &'a Memarg>>>>>>;
+pub struct TypeidxBlock {
+    pub tag: u8,
+    pub body: u64,
+}
 
+impl View for TypeidxBlock {
+    type V = SpecTypeidxBlock;
 
-impl View for InstrMemory {
-    type V = SpecInstrMemory;
     open spec fn view(&self) -> Self::V {
-        match self {
-            InstrMemory::I32Store(m) => SpecInstrMemory::I32Store(m@),
-            InstrMemory::I32Load(m) => SpecInstrMemory::I32Load(m@),
-            InstrMemory::I64Store(m) => SpecInstrMemory::I64Store(m@),
-            InstrMemory::I64Load(m) => SpecInstrMemory::I64Load(m@),
-            InstrMemory::MemorySize(m) => SpecInstrMemory::MemorySize(m@),
-            InstrMemory::MemoryGrow(m) => SpecInstrMemory::MemoryGrow(m@),
-            InstrMemory::Unrecognized(m) => SpecInstrMemory::Unrecognized(m@),
+        SpecTypeidxBlock {
+            tag: self.tag@,
+            body: self.body@,
         }
     }
 }
+pub type TypeidxBlockInner = (u8, u64);
 
-
-impl<'a> From<&'a InstrMemory> for InstrMemoryInnerRef<'a> {
-    fn ex_from(m: &'a InstrMemory) -> InstrMemoryInnerRef<'a> {
-        match m {
-            InstrMemory::I32Store(m) => Either::Left(m),
-            InstrMemory::I32Load(m) => Either::Right(Either::Left(m)),
-            InstrMemory::I64Store(m) => Either::Right(Either::Right(Either::Left(m))),
-            InstrMemory::I64Load(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            InstrMemory::MemorySize(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            InstrMemory::MemoryGrow(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            InstrMemory::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
-        }
+pub type TypeidxBlockInnerRef<'a> = (&'a u8, &'a u64);
+impl<'a> From<&'a TypeidxBlock> for TypeidxBlockInnerRef<'a> {
+    fn ex_from(m: &'a TypeidxBlock) -> TypeidxBlockInnerRef<'a> {
+        (&m.tag, &m.body)
     }
-
 }
 
-impl From<InstrMemoryInner> for InstrMemory {
-    fn ex_from(m: InstrMemoryInner) -> InstrMemory {
-        match m {
-            Either::Left(m) => InstrMemory::I32Store(m),
-            Either::Right(Either::Left(m)) => InstrMemory::I32Load(m),
-            Either::Right(Either::Right(Either::Left(m))) => InstrMemory::I64Store(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => InstrMemory::I64Load(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => InstrMemory::MemorySize(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => InstrMemory::MemoryGrow(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => InstrMemory::Unrecognized(m),
-        }
+impl From<TypeidxBlockInner> for TypeidxBlock {
+    fn ex_from(m: TypeidxBlockInner) -> TypeidxBlock {
+        let (tag, body) = m;
+        TypeidxBlock { tag, body }
     }
-    
 }
 
-
-pub struct InstrMemoryMapper;
-impl View for InstrMemoryMapper {
+pub struct TypeidxBlockMapper;
+impl View for TypeidxBlockMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for InstrMemoryMapper {
-    type Src = SpecInstrMemoryInner;
-    type Dst = SpecInstrMemory;
+impl SpecIso for TypeidxBlockMapper {
+    type Src = SpecTypeidxBlockInner;
+    type Dst = SpecTypeidxBlock;
 }
-impl SpecIsoProof for InstrMemoryMapper {
+impl SpecIsoProof for TypeidxBlockMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -4320,427 +4640,452 @@ impl SpecIsoProof for InstrMemoryMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for InstrMemoryMapper {
-    type Src = InstrMemoryInner;
-    type Dst = InstrMemory;
-    type RefSrc = InstrMemoryInnerRef<'a>;
+impl<'a> Iso<'a> for TypeidxBlockMapper {
+    type Src = TypeidxBlockInner;
+    type Dst = TypeidxBlock;
+    type RefSrc = TypeidxBlockInnerRef<'a>;
 }
+type SpecTypeidxBlockCombinatorAlias1 = (Refined<U8, Predicate2396169508742552609>, UnsignedLEB128);
+pub struct SpecTypeidxBlockCombinator(pub SpecTypeidxBlockCombinatorAlias);
 
-type SpecInstrMemoryCombinatorAlias1 = Choice<Cond<SpecByteZeroCombinator>, Cond<SpecMemargCombinator>>;
-type SpecInstrMemoryCombinatorAlias2 = Choice<Cond<SpecByteZeroCombinator>, SpecInstrMemoryCombinatorAlias1>;
-type SpecInstrMemoryCombinatorAlias3 = Choice<Cond<SpecMemargCombinator>, SpecInstrMemoryCombinatorAlias2>;
-type SpecInstrMemoryCombinatorAlias4 = Choice<Cond<SpecMemargCombinator>, SpecInstrMemoryCombinatorAlias3>;
-type SpecInstrMemoryCombinatorAlias5 = Choice<Cond<SpecMemargCombinator>, SpecInstrMemoryCombinatorAlias4>;
-type SpecInstrMemoryCombinatorAlias6 = Choice<Cond<SpecMemargCombinator>, SpecInstrMemoryCombinatorAlias5>;
-pub struct SpecInstrMemoryCombinator(pub SpecInstrMemoryCombinatorAlias);
-
-impl SpecCombinator for SpecInstrMemoryCombinator {
-    type Type = SpecInstrMemory;
+impl SpecCombinator for SpecTypeidxBlockCombinator {
+    type Type = SpecTypeidxBlock;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecInstrMemoryCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecInstrMemoryCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTypeidxBlockCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTypeidxBlockCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecInstrMemoryCombinatorAlias = Mapped<SpecInstrMemoryCombinatorAlias6, InstrMemoryMapper>;
-type InstrMemoryCombinatorAlias1 = Choice<Cond<ByteZeroCombinator>, Cond<MemargCombinator>>;
-type InstrMemoryCombinatorAlias2 = Choice<Cond<ByteZeroCombinator>, InstrMemoryCombinator1>;
-type InstrMemoryCombinatorAlias3 = Choice<Cond<MemargCombinator>, InstrMemoryCombinator2>;
-type InstrMemoryCombinatorAlias4 = Choice<Cond<MemargCombinator>, InstrMemoryCombinator3>;
-type InstrMemoryCombinatorAlias5 = Choice<Cond<MemargCombinator>, InstrMemoryCombinator4>;
-type InstrMemoryCombinatorAlias6 = Choice<Cond<MemargCombinator>, InstrMemoryCombinator5>;
-pub struct InstrMemoryCombinator1(pub InstrMemoryCombinatorAlias1);
-impl View for InstrMemoryCombinator1 {
-    type V = SpecInstrMemoryCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(InstrMemoryCombinator1, InstrMemoryCombinatorAlias1);
-
-pub struct InstrMemoryCombinator2(pub InstrMemoryCombinatorAlias2);
-impl View for InstrMemoryCombinator2 {
-    type V = SpecInstrMemoryCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(InstrMemoryCombinator2, InstrMemoryCombinatorAlias2);
+pub type SpecTypeidxBlockCombinatorAlias = Mapped<SpecTypeidxBlockCombinatorAlias1, TypeidxBlockMapper>;
+pub struct Predicate2396169508742552609;
+impl View for Predicate2396169508742552609 {
+    type V = Self;
 
-pub struct InstrMemoryCombinator3(pub InstrMemoryCombinatorAlias3);
-impl View for InstrMemoryCombinator3 {
-    type V = SpecInstrMemoryCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
 }
-impl_wrapper_combinator!(InstrMemoryCombinator3, InstrMemoryCombinatorAlias3);
-
-pub struct InstrMemoryCombinator4(pub InstrMemoryCombinatorAlias4);
-impl View for InstrMemoryCombinator4 {
-    type V = SpecInstrMemoryCombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
+impl Pred<u8> for Predicate2396169508742552609 {
+    fn apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        !((i == 64) || (i == 123) || (i == 124) || (i == 125) || (i == 126) || (i == 127) || (i == 111) || (i == 112))
+    }
 }
-impl_wrapper_combinator!(InstrMemoryCombinator4, InstrMemoryCombinatorAlias4);
-
-pub struct InstrMemoryCombinator5(pub InstrMemoryCombinatorAlias5);
-impl View for InstrMemoryCombinator5 {
-    type V = SpecInstrMemoryCombinatorAlias5;
-    open spec fn view(&self) -> Self::V { self.0@ }
+impl SpecPred<u8> for Predicate2396169508742552609 {
+    open spec fn spec_apply(&self, i: &u8) -> bool {
+        let i = (*i);
+        !((i == 64) || (i == 123) || (i == 124) || (i == 125) || (i == 126) || (i == 127) || (i == 111) || (i == 112))
+    }
 }
-impl_wrapper_combinator!(InstrMemoryCombinator5, InstrMemoryCombinatorAlias5);
-
-pub struct InstrMemoryCombinator6(pub InstrMemoryCombinatorAlias6);
-impl View for InstrMemoryCombinator6 {
-    type V = SpecInstrMemoryCombinatorAlias6;
+type TypeidxBlockCombinatorAlias1 = (Refined<U8, Predicate2396169508742552609>, UnsignedLEB128);
+pub struct TypeidxBlockCombinator1(pub TypeidxBlockCombinatorAlias1);
+impl View for TypeidxBlockCombinator1 {
+    type V = SpecTypeidxBlockCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(InstrMemoryCombinator6, InstrMemoryCombinatorAlias6);
+impl_wrapper_combinator!(TypeidxBlockCombinator1, TypeidxBlockCombinatorAlias1);
 
-pub struct InstrMemoryCombinator(pub InstrMemoryCombinatorAlias);
+pub struct TypeidxBlockCombinator(pub TypeidxBlockCombinatorAlias);
 
-impl View for InstrMemoryCombinator {
-    type V = SpecInstrMemoryCombinator;
-    open spec fn view(&self) -> Self::V { SpecInstrMemoryCombinator(self.0@) }
+impl View for TypeidxBlockCombinator {
+    type V = SpecTypeidxBlockCombinator;
+    open spec fn view(&self) -> Self::V { SpecTypeidxBlockCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrMemoryCombinator {
-    type Type = InstrMemory;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TypeidxBlockCombinator {
+    type Type = TypeidxBlock;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type InstrMemoryCombinatorAlias = Mapped<InstrMemoryCombinator6, InstrMemoryMapper>;
+}
+pub type TypeidxBlockCombinatorAlias = Mapped<TypeidxBlockCombinator1, TypeidxBlockMapper>;
 
 
-pub open spec fn spec_instr_memory(opcode: u8) -> SpecInstrMemoryCombinator {
-    SpecInstrMemoryCombinator(Mapped { inner: Choice(Cond { cond: opcode == InstrBytecode::SPEC_I32Store, inner: spec_memarg() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_I32Load, inner: spec_memarg() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_I64Store, inner: spec_memarg() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_I64Load, inner: spec_memarg() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_MemorySize, inner: spec_byte_zero() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_MemoryGrow, inner: spec_byte_zero() }, Cond { cond: !(opcode == InstrBytecode::SPEC_I32Store || opcode == InstrBytecode::SPEC_I32Load || opcode == InstrBytecode::SPEC_I64Store || opcode == InstrBytecode::SPEC_I64Load || opcode == InstrBytecode::SPEC_MemorySize || opcode == InstrBytecode::SPEC_MemoryGrow), inner: spec_memarg() })))))), mapper: InstrMemoryMapper })
+pub open spec fn spec_typeidx_block() -> SpecTypeidxBlockCombinator {
+    SpecTypeidxBlockCombinator(
+    Mapped {
+        inner: (Refined { inner: U8, predicate: Predicate2396169508742552609 }, UnsignedLEB128),
+        mapper: TypeidxBlockMapper,
+    })
 }
 
-pub fn instr_memory<'a>(opcode: u8) -> (o: InstrMemoryCombinator)
-    ensures o@ == spec_instr_memory(opcode@),
+                
+pub fn typeidx_block<'a>() -> (o: TypeidxBlockCombinator)
+    ensures o@ == spec_typeidx_block(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = InstrMemoryCombinator(Mapped { inner: InstrMemoryCombinator6(Choice::new(Cond { cond: opcode == InstrBytecode::I32Store, inner: memarg() }, InstrMemoryCombinator5(Choice::new(Cond { cond: opcode == InstrBytecode::I32Load, inner: memarg() }, InstrMemoryCombinator4(Choice::new(Cond { cond: opcode == InstrBytecode::I64Store, inner: memarg() }, InstrMemoryCombinator3(Choice::new(Cond { cond: opcode == InstrBytecode::I64Load, inner: memarg() }, InstrMemoryCombinator2(Choice::new(Cond { cond: opcode == InstrBytecode::MemorySize, inner: byte_zero() }, InstrMemoryCombinator1(Choice::new(Cond { cond: opcode == InstrBytecode::MemoryGrow, inner: byte_zero() }, Cond { cond: !(opcode == InstrBytecode::I32Store || opcode == InstrBytecode::I32Load || opcode == InstrBytecode::I64Store || opcode == InstrBytecode::I64Load || opcode == InstrBytecode::MemorySize || opcode == InstrBytecode::MemoryGrow), inner: memarg() })))))))))))), mapper: InstrMemoryMapper });
-    assert({
-        &&& combinator@ == spec_instr_memory(opcode@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = TypeidxBlockCombinator(
+    Mapped {
+        inner: TypeidxBlockCombinator1((Refined { inner: U8, predicate: Predicate2396169508742552609 }, UnsignedLEB128)),
+        mapper: TypeidxBlockMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_typeidx_block()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_instr_memory<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrMemoryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_typeidx_block<'a>(input: &'a [u8]) -> (res: PResult<<TypeidxBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_instr_memory(opcode@).spec_parse(input@) == Some((n as int, v@)),
-        spec_instr_memory(opcode@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_typeidx_block().spec_parse(input@) == Some((n as int, v@)),
+        spec_typeidx_block().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_instr_memory(opcode@).spec_parse(input@) is None,
-        spec_instr_memory(opcode@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_typeidx_block().spec_parse(input@) is None,
+        spec_typeidx_block().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = instr_memory( opcode );
+    let combinator = typeidx_block();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_instr_memory<'a>(v: <InstrMemoryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, opcode: u8) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_typeidx_block<'a>(v: <TypeidxBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_instr_memory(opcode@).wf(v@),
+        spec_typeidx_block().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_instr_memory(opcode@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_instr_memory(opcode@).spec_serialize(v@))
+            &&& n == spec_typeidx_block().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_typeidx_block().spec_serialize(v@))
         },
 {
-    let combinator = instr_memory( opcode );
-    combinator.serialize(v, data, pos)
+    let combinator = typeidx_block();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn instr_memory_len<'a>(v: <InstrMemoryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, opcode: u8) -> (serialize_len: usize)
+pub fn typeidx_block_len<'a>(v: <TypeidxBlockCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_instr_memory(opcode@).wf(v@),
-        spec_instr_memory(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_typeidx_block().wf(v@),
+        spec_typeidx_block().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_instr_memory(opcode@).spec_serialize(v@).len(),
+        serialize_len == spec_typeidx_block().spec_serialize(v@).len(),
 {
-    let combinator = instr_memory( opcode );
+    let combinator = typeidx_block();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+                
 
-pub spec const SPEC_Reftype_FuncRef: u8 = 112;
-pub spec const SPEC_Reftype_ExternRef: u8 = 111;
-pub exec static EXEC_Reftype_FuncRef: u8 ensures EXEC_Reftype_FuncRef == SPEC_Reftype_FuncRef { 112 }
-pub exec static EXEC_Reftype_ExternRef: u8 ensures EXEC_Reftype_ExternRef == SPEC_Reftype_ExternRef { 111 }
+pub enum SpecBlocktype {
+    Empty(SpecEmptyBlock),
+    ValType(SpecValtypeBlock),
+    TypeIdx(SpecTypeidxBlock),
+}
+
+pub type SpecBlocktypeInner = Either<SpecEmptyBlock, Either<SpecValtypeBlock, SpecTypeidxBlock>>;
+
+impl SpecFrom<SpecBlocktype> for SpecBlocktypeInner {
+    open spec fn spec_from(m: SpecBlocktype) -> SpecBlocktypeInner {
+        match m {
+            SpecBlocktype::Empty(m) => Either::Left(m),
+            SpecBlocktype::ValType(m) => Either::Right(Either::Left(m)),
+            SpecBlocktype::TypeIdx(m) => Either::Right(Either::Right(m)),
+        }
+    }
 
-#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
-pub enum Reftype {
-    FuncRef = 112,
-ExternRef = 111
 }
-pub type SpecReftype = Reftype;
 
-pub type ReftypeInner = u8;
+                
+impl SpecFrom<SpecBlocktypeInner> for SpecBlocktype {
+    open spec fn spec_from(m: SpecBlocktypeInner) -> SpecBlocktype {
+        match m {
+            Either::Left(m) => SpecBlocktype::Empty(m),
+            Either::Right(Either::Left(m)) => SpecBlocktype::ValType(m),
+            Either::Right(Either::Right(m)) => SpecBlocktype::TypeIdx(m),
+        }
+    }
 
-pub type ReftypeInnerRef<'a> = &'a u8;
+}
 
-impl View for Reftype {
-    type V = Self;
 
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Blocktype<'a> {
+    Empty(EmptyBlock<'a>),
+    ValType(ValtypeBlock<'a>),
+    TypeIdx(TypeidxBlock),
 }
 
-impl SpecTryFrom<ReftypeInner> for Reftype {
-    type Error = ();
+pub type BlocktypeInner<'a> = Either<EmptyBlock<'a>, Either<ValtypeBlock<'a>, TypeidxBlock>>;
 
-    open spec fn spec_try_from(v: ReftypeInner) -> Result<Reftype, ()> {
-        match v {
-            112u8 => Ok(Reftype::FuncRef),
-            111u8 => Ok(Reftype::ExternRef),
-            _ => Err(()),
-        }
-    }
-}
+pub type BlocktypeInnerRef<'a> = Either<&'a EmptyBlock<'a>, Either<&'a ValtypeBlock<'a>, &'a TypeidxBlock>>;
 
-impl SpecTryFrom<Reftype> for ReftypeInner {
-    type Error = ();
 
-    open spec fn spec_try_from(v: Reftype) -> Result<ReftypeInner, ()> {
-        match v {
-            Reftype::FuncRef => Ok(SPEC_Reftype_FuncRef),
-            Reftype::ExternRef => Ok(SPEC_Reftype_ExternRef),
+impl<'a> View for Blocktype<'a> {
+    type V = SpecBlocktype;
+    open spec fn view(&self) -> Self::V {
+        match self {
+            Blocktype::Empty(m) => SpecBlocktype::Empty(m@),
+            Blocktype::ValType(m) => SpecBlocktype::ValType(m@),
+            Blocktype::TypeIdx(m) => SpecBlocktype::TypeIdx(m@),
         }
     }
 }
 
-impl TryFrom<ReftypeInner> for Reftype {
-    type Error = ();
 
-    fn ex_try_from(v: ReftypeInner) -> Result<Reftype, ()> {
-        match v {
-            112u8 => Ok(Reftype::FuncRef),
-            111u8 => Ok(Reftype::ExternRef),
-            _ => Err(()),
+impl<'a> From<&'a Blocktype<'a>> for BlocktypeInnerRef<'a> {
+    fn ex_from(m: &'a Blocktype<'a>) -> BlocktypeInnerRef<'a> {
+        match m {
+            Blocktype::Empty(m) => Either::Left(m),
+            Blocktype::ValType(m) => Either::Right(Either::Left(m)),
+            Blocktype::TypeIdx(m) => Either::Right(Either::Right(m)),
         }
     }
-}
 
-impl<'a> TryFrom<&'a Reftype> for ReftypeInnerRef<'a> {
-    type Error = ();
+}
 
-    fn ex_try_from(v: &'a Reftype) -> Result<ReftypeInnerRef<'a>, ()> {
-        match v {
-            Reftype::FuncRef => Ok(&EXEC_Reftype_FuncRef),
-            Reftype::ExternRef => Ok(&EXEC_Reftype_ExternRef),
+impl<'a> From<BlocktypeInner<'a>> for Blocktype<'a> {
+    fn ex_from(m: BlocktypeInner<'a>) -> Blocktype<'a> {
+        match m {
+            Either::Left(m) => Blocktype::Empty(m),
+            Either::Right(Either::Left(m)) => Blocktype::ValType(m),
+            Either::Right(Either::Right(m)) => Blocktype::TypeIdx(m),
         }
     }
+    
 }
 
-pub struct ReftypeMapper;
 
-impl View for ReftypeMapper {
+pub struct BlocktypeMapper;
+impl View for BlocktypeMapper {
     type V = Self;
-
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-
-impl SpecPartialIso for ReftypeMapper {
-    type Src = ReftypeInner;
-    type Dst = Reftype;
+impl SpecIso for BlocktypeMapper {
+    type Src = SpecBlocktypeInner;
+    type Dst = SpecBlocktype;
 }
-
-impl SpecPartialIsoProof for ReftypeMapper {
-    proof fn spec_iso(s: Self::Src) { 
-        assert(
-            Self::spec_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_rev_apply(v) is Ok
-            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
-        });
+impl SpecIsoProof for BlocktypeMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
-
-    proof fn spec_iso_rev(s: Self::Dst) { 
-        assert(
-            Self::spec_rev_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_apply(v) is Ok
-            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
-        });
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
+impl<'a> Iso<'a> for BlocktypeMapper {
+    type Src = BlocktypeInner<'a>;
+    type Dst = Blocktype<'a>;
+    type RefSrc = BlocktypeInnerRef<'a>;
+}
 
-impl<'a> PartialIso<'a> for ReftypeMapper {
-    type Src = ReftypeInner;
-    type Dst = Reftype;
-    type RefSrc = ReftypeInnerRef<'a>;
+type SpecBlocktypeCombinatorAlias1 = Choice<SpecValtypeBlockCombinator, SpecTypeidxBlockCombinator>;
+type SpecBlocktypeCombinatorAlias2 = Choice<SpecEmptyBlockCombinator, SpecBlocktypeCombinatorAlias1>;
+impl DisjointFrom<SpecEmptyBlockCombinator> for SpecValtypeBlockCombinator {
+    open spec fn disjoint_from(&self, other: &SpecEmptyBlockCombinator) -> bool
+    { self.0.disjoint_from(&other.0) }
+    proof fn parse_disjoint_on(&self, other: &SpecEmptyBlockCombinator, buf: Seq<u8>)
+    { self.0.parse_disjoint_on(&other.0, buf); }
 }
 
+impl DisjointFrom<SpecEmptyBlockCombinator> for SpecTypeidxBlockCombinator {
+    open spec fn disjoint_from(&self, other: &SpecEmptyBlockCombinator) -> bool
+    { self.0.disjoint_from(&other.0) }
+    proof fn parse_disjoint_on(&self, other: &SpecEmptyBlockCombinator, buf: Seq<u8>)
+    { self.0.parse_disjoint_on(&other.0, buf); }
+}
 
-pub struct SpecReftypeCombinator(pub SpecReftypeCombinatorAlias);
+impl DisjointFrom<SpecValtypeBlockCombinator> for SpecTypeidxBlockCombinator {
+    open spec fn disjoint_from(&self, other: &SpecValtypeBlockCombinator) -> bool
+    { self.0.disjoint_from(&other.0) }
+    proof fn parse_disjoint_on(&self, other: &SpecValtypeBlockCombinator, buf: Seq<u8>)
+    { self.0.parse_disjoint_on(&other.0, buf); }
+}
+pub struct SpecBlocktypeCombinator(pub SpecBlocktypeCombinatorAlias);
 
-impl SpecCombinator for SpecReftypeCombinator {
-    type Type = SpecReftype;
+impl SpecCombinator for SpecBlocktypeCombinator {
+    type Type = SpecBlocktype;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecReftypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecReftypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecBlocktypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecBlocktypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecReftypeCombinatorAlias = TryMap<U8, ReftypeMapper>;
+pub type SpecBlocktypeCombinatorAlias = Mapped<SpecBlocktypeCombinatorAlias2, BlocktypeMapper>;
+type BlocktypeCombinatorAlias1 = Choice<ValtypeBlockCombinator, TypeidxBlockCombinator>;
+type BlocktypeCombinatorAlias2 = Choice<EmptyBlockCombinator, BlocktypeCombinator1>;
+pub struct BlocktypeCombinator1(pub BlocktypeCombinatorAlias1);
+impl View for BlocktypeCombinator1 {
+    type V = SpecBlocktypeCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(BlocktypeCombinator1, BlocktypeCombinatorAlias1);
 
-pub struct ReftypeCombinator(pub ReftypeCombinatorAlias);
+pub struct BlocktypeCombinator2(pub BlocktypeCombinatorAlias2);
+impl View for BlocktypeCombinator2 {
+    type V = SpecBlocktypeCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(BlocktypeCombinator2, BlocktypeCombinatorAlias2);
 
-impl View for ReftypeCombinator {
-    type V = SpecReftypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecReftypeCombinator(self.0@) }
+pub struct BlocktypeCombinator(pub BlocktypeCombinatorAlias);
+
+impl View for BlocktypeCombinator {
+    type V = SpecBlocktypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecBlocktypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ReftypeCombinator {
-    type Type = Reftype;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for BlocktypeCombinator {
+    type Type = Blocktype<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ReftypeCombinatorAlias = TryMap<U8, ReftypeMapper>;
+}
+pub type BlocktypeCombinatorAlias = Mapped<BlocktypeCombinator2, BlocktypeMapper>;
 
 
-pub open spec fn spec_reftype() -> SpecReftypeCombinator {
-    SpecReftypeCombinator(TryMap { inner: U8, mapper: ReftypeMapper })
+pub open spec fn spec_blocktype() -> SpecBlocktypeCombinator {
+    SpecBlocktypeCombinator(Mapped { inner: Choice(spec_empty_block(), Choice(spec_valtype_block(), spec_typeidx_block())), mapper: BlocktypeMapper })
 }
 
                 
-pub fn reftype<'a>() -> (o: ReftypeCombinator)
-    ensures o@ == spec_reftype(),
+pub fn blocktype<'a>() -> (o: BlocktypeCombinator)
+    ensures o@ == spec_blocktype(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ReftypeCombinator(TryMap { inner: U8, mapper: ReftypeMapper });
-    assert({
-        &&& combinator@ == spec_reftype()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = BlocktypeCombinator(Mapped { inner: BlocktypeCombinator2(Choice::new(empty_block(), BlocktypeCombinator1(Choice::new(valtype_block(), typeidx_block())))), mapper: BlocktypeMapper });
+    // assert({
+    //     &&& combinator@ == spec_blocktype()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_reftype<'a>(input: &'a [u8]) -> (res: PResult<<ReftypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_blocktype<'a>(input: &'a [u8]) -> (res: PResult<<BlocktypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_reftype().spec_parse(input@) == Some((n as int, v@)),
-        spec_reftype().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_blocktype().spec_parse(input@) == Some((n as int, v@)),
+        spec_blocktype().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_reftype().spec_parse(input@) is None,
-        spec_reftype().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_blocktype().spec_parse(input@) is None,
+        spec_blocktype().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = reftype();
+    let combinator = blocktype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_reftype<'a>(v: <ReftypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_blocktype<'a>(v: <BlocktypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_reftype().wf(v@),
+        spec_blocktype().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_reftype().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_reftype().spec_serialize(v@))
+            &&& n == spec_blocktype().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_blocktype().spec_serialize(v@))
         },
 {
-    let combinator = reftype();
+    let combinator = blocktype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn reftype_len<'a>(v: <ReftypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn blocktype_len<'a>(v: <BlocktypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_reftype().wf(v@),
-        spec_reftype().spec_serialize(v@).len() <= usize::MAX,
+        spec_blocktype().wf(v@),
+        spec_blocktype().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_reftype().spec_serialize(v@).len(),
+        serialize_len == spec_blocktype().spec_serialize(v@).len(),
 {
-    let combinator = reftype();
+    let combinator = blocktype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub enum SpecInstrReference {
-    RefNull(SpecReftype),
-    RefIsNull(SpecEmpty),
-    RefFunc(SpecFuncidx),
+pub enum SpecInstrControl1 {
+    If(SpecBlocktype),
+    Block(SpecBlocktype),
+    Loop(SpecBlocktype),
+    Else(SpecEmpty),
+    Unreachable(SpecEmpty),
+    Nop(SpecEmpty),
 }
 
-pub type SpecInstrReferenceInner = Either<SpecReftype, Either<SpecEmpty, SpecFuncidx>>;
+pub type SpecInstrControl1Inner = Either<SpecBlocktype, Either<SpecBlocktype, Either<SpecBlocktype, Either<SpecEmpty, Either<SpecEmpty, SpecEmpty>>>>>;
 
-impl SpecFrom<SpecInstrReference> for SpecInstrReferenceInner {
-    open spec fn spec_from(m: SpecInstrReference) -> SpecInstrReferenceInner {
+impl SpecFrom<SpecInstrControl1> for SpecInstrControl1Inner {
+    open spec fn spec_from(m: SpecInstrControl1) -> SpecInstrControl1Inner {
         match m {
-            SpecInstrReference::RefNull(m) => Either::Left(m),
-            SpecInstrReference::RefIsNull(m) => Either::Right(Either::Left(m)),
-            SpecInstrReference::RefFunc(m) => Either::Right(Either::Right(m)),
+            SpecInstrControl1::If(m) => Either::Left(m),
+            SpecInstrControl1::Block(m) => Either::Right(Either::Left(m)),
+            SpecInstrControl1::Loop(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecInstrControl1::Else(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecInstrControl1::Unreachable(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecInstrControl1::Nop(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))),
         }
     }
 
 }
 
                 
-impl SpecFrom<SpecInstrReferenceInner> for SpecInstrReference {
-    open spec fn spec_from(m: SpecInstrReferenceInner) -> SpecInstrReference {
-        match m {
-            Either::Left(m) => SpecInstrReference::RefNull(m),
-            Either::Right(Either::Left(m)) => SpecInstrReference::RefIsNull(m),
-            Either::Right(Either::Right(m)) => SpecInstrReference::RefFunc(m),
+impl SpecFrom<SpecInstrControl1Inner> for SpecInstrControl1 {
+    open spec fn spec_from(m: SpecInstrControl1Inner) -> SpecInstrControl1 {
+        match m {
+            Either::Left(m) => SpecInstrControl1::If(m),
+            Either::Right(Either::Left(m)) => SpecInstrControl1::Block(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecInstrControl1::Loop(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecInstrControl1::Else(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecInstrControl1::Unreachable(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))) => SpecInstrControl1::Nop(m),
         }
     }
 
@@ -4749,64 +5094,76 @@ impl SpecFrom<SpecInstrReferenceInner> for SpecInstrReference {
 
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum InstrReference<'a> {
-    RefNull(Reftype),
-    RefIsNull(Empty<'a>),
-    RefFunc(Funcidx),
+pub enum InstrControl1<'a> {
+    If(Blocktype<'a>),
+    Block(Blocktype<'a>),
+    Loop(Blocktype<'a>),
+    Else(Empty<'a>),
+    Unreachable(Empty<'a>),
+    Nop(Empty<'a>),
 }
 
-pub type InstrReferenceInner<'a> = Either<Reftype, Either<Empty<'a>, Funcidx>>;
+pub type InstrControl1Inner<'a> = Either<Blocktype<'a>, Either<Blocktype<'a>, Either<Blocktype<'a>, Either<Empty<'a>, Either<Empty<'a>, Empty<'a>>>>>>;
 
-pub type InstrReferenceInnerRef<'a> = Either<&'a Reftype, Either<&'a Empty<'a>, &'a Funcidx>>;
+pub type InstrControl1InnerRef<'a> = Either<&'a Blocktype<'a>, Either<&'a Blocktype<'a>, Either<&'a Blocktype<'a>, Either<&'a Empty<'a>, Either<&'a Empty<'a>, &'a Empty<'a>>>>>>;
 
 
-impl<'a> View for InstrReference<'a> {
-    type V = SpecInstrReference;
+impl<'a> View for InstrControl1<'a> {
+    type V = SpecInstrControl1;
     open spec fn view(&self) -> Self::V {
         match self {
-            InstrReference::RefNull(m) => SpecInstrReference::RefNull(m@),
-            InstrReference::RefIsNull(m) => SpecInstrReference::RefIsNull(m@),
-            InstrReference::RefFunc(m) => SpecInstrReference::RefFunc(m@),
+            InstrControl1::If(m) => SpecInstrControl1::If(m@),
+            InstrControl1::Block(m) => SpecInstrControl1::Block(m@),
+            InstrControl1::Loop(m) => SpecInstrControl1::Loop(m@),
+            InstrControl1::Else(m) => SpecInstrControl1::Else(m@),
+            InstrControl1::Unreachable(m) => SpecInstrControl1::Unreachable(m@),
+            InstrControl1::Nop(m) => SpecInstrControl1::Nop(m@),
         }
     }
 }
 
 
-impl<'a> From<&'a InstrReference<'a>> for InstrReferenceInnerRef<'a> {
-    fn ex_from(m: &'a InstrReference<'a>) -> InstrReferenceInnerRef<'a> {
+impl<'a> From<&'a InstrControl1<'a>> for InstrControl1InnerRef<'a> {
+    fn ex_from(m: &'a InstrControl1<'a>) -> InstrControl1InnerRef<'a> {
         match m {
-            InstrReference::RefNull(m) => Either::Left(m),
-            InstrReference::RefIsNull(m) => Either::Right(Either::Left(m)),
-            InstrReference::RefFunc(m) => Either::Right(Either::Right(m)),
+            InstrControl1::If(m) => Either::Left(m),
+            InstrControl1::Block(m) => Either::Right(Either::Left(m)),
+            InstrControl1::Loop(m) => Either::Right(Either::Right(Either::Left(m))),
+            InstrControl1::Else(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            InstrControl1::Unreachable(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            InstrControl1::Nop(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))),
         }
     }
 
 }
 
-impl<'a> From<InstrReferenceInner<'a>> for InstrReference<'a> {
-    fn ex_from(m: InstrReferenceInner<'a>) -> InstrReference<'a> {
+impl<'a> From<InstrControl1Inner<'a>> for InstrControl1<'a> {
+    fn ex_from(m: InstrControl1Inner<'a>) -> InstrControl1<'a> {
         match m {
-            Either::Left(m) => InstrReference::RefNull(m),
-            Either::Right(Either::Left(m)) => InstrReference::RefIsNull(m),
-            Either::Right(Either::Right(m)) => InstrReference::RefFunc(m),
+            Either::Left(m) => InstrControl1::If(m),
+            Either::Right(Either::Left(m)) => InstrControl1::Block(m),
+            Either::Right(Either::Right(Either::Left(m))) => InstrControl1::Loop(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => InstrControl1::Else(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => InstrControl1::Unreachable(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))) => InstrControl1::Nop(m),
         }
     }
     
 }
 
 
-pub struct InstrReferenceMapper;
-impl View for InstrReferenceMapper {
+pub struct InstrControl1Mapper;
+impl View for InstrControl1Mapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for InstrReferenceMapper {
-    type Src = SpecInstrReferenceInner;
-    type Dst = SpecInstrReference;
+impl SpecIso for InstrControl1Mapper {
+    type Src = SpecInstrControl1Inner;
+    type Dst = SpecInstrControl1;
 }
-impl SpecIsoProof for InstrReferenceMapper {
+impl SpecIsoProof for InstrControl1Mapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -4814,622 +5171,620 @@ impl SpecIsoProof for InstrReferenceMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for InstrReferenceMapper {
-    type Src = InstrReferenceInner<'a>;
-    type Dst = InstrReference<'a>;
-    type RefSrc = InstrReferenceInnerRef<'a>;
+impl<'a> Iso<'a> for InstrControl1Mapper {
+    type Src = InstrControl1Inner<'a>;
+    type Dst = InstrControl1<'a>;
+    type RefSrc = InstrControl1InnerRef<'a>;
 }
 
-type SpecInstrReferenceCombinatorAlias1 = Choice<Cond<SpecEmptyCombinator>, Cond<SpecFuncidxCombinator>>;
-type SpecInstrReferenceCombinatorAlias2 = Choice<Cond<SpecReftypeCombinator>, SpecInstrReferenceCombinatorAlias1>;
-pub struct SpecInstrReferenceCombinator(pub SpecInstrReferenceCombinatorAlias);
+type SpecInstrControl1CombinatorAlias1 = Choice<Cond<SpecEmptyCombinator>, Cond<SpecEmptyCombinator>>;
+type SpecInstrControl1CombinatorAlias2 = Choice<Cond<SpecEmptyCombinator>, SpecInstrControl1CombinatorAlias1>;
+type SpecInstrControl1CombinatorAlias3 = Choice<Cond<SpecBlocktypeCombinator>, SpecInstrControl1CombinatorAlias2>;
+type SpecInstrControl1CombinatorAlias4 = Choice<Cond<SpecBlocktypeCombinator>, SpecInstrControl1CombinatorAlias3>;
+type SpecInstrControl1CombinatorAlias5 = Choice<Cond<SpecBlocktypeCombinator>, SpecInstrControl1CombinatorAlias4>;
+pub struct SpecInstrControl1Combinator(pub SpecInstrControl1CombinatorAlias);
 
-impl SpecCombinator for SpecInstrReferenceCombinator {
-    type Type = SpecInstrReference;
+impl SpecCombinator for SpecInstrControl1Combinator {
+    type Type = SpecInstrControl1;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecInstrReferenceCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecInstrReferenceCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecInstrControl1Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecInstrControl1CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecInstrReferenceCombinatorAlias = Mapped<SpecInstrReferenceCombinatorAlias2, InstrReferenceMapper>;
-type InstrReferenceCombinatorAlias1 = Choice<Cond<EmptyCombinator>, Cond<FuncidxCombinator>>;
-type InstrReferenceCombinatorAlias2 = Choice<Cond<ReftypeCombinator>, InstrReferenceCombinator1>;
-pub struct InstrReferenceCombinator1(pub InstrReferenceCombinatorAlias1);
-impl View for InstrReferenceCombinator1 {
-    type V = SpecInstrReferenceCombinatorAlias1;
+pub type SpecInstrControl1CombinatorAlias = Mapped<SpecInstrControl1CombinatorAlias5, InstrControl1Mapper>;
+type InstrControl1CombinatorAlias1 = Choice<Cond<EmptyCombinator>, Cond<EmptyCombinator>>;
+type InstrControl1CombinatorAlias2 = Choice<Cond<EmptyCombinator>, InstrControl1Combinator1>;
+type InstrControl1CombinatorAlias3 = Choice<Cond<BlocktypeCombinator>, InstrControl1Combinator2>;
+type InstrControl1CombinatorAlias4 = Choice<Cond<BlocktypeCombinator>, InstrControl1Combinator3>;
+type InstrControl1CombinatorAlias5 = Choice<Cond<BlocktypeCombinator>, InstrControl1Combinator4>;
+pub struct InstrControl1Combinator1(pub InstrControl1CombinatorAlias1);
+impl View for InstrControl1Combinator1 {
+    type V = SpecInstrControl1CombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(InstrReferenceCombinator1, InstrReferenceCombinatorAlias1);
+impl_wrapper_combinator!(InstrControl1Combinator1, InstrControl1CombinatorAlias1);
 
-pub struct InstrReferenceCombinator2(pub InstrReferenceCombinatorAlias2);
-impl View for InstrReferenceCombinator2 {
-    type V = SpecInstrReferenceCombinatorAlias2;
+pub struct InstrControl1Combinator2(pub InstrControl1CombinatorAlias2);
+impl View for InstrControl1Combinator2 {
+    type V = SpecInstrControl1CombinatorAlias2;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(InstrReferenceCombinator2, InstrReferenceCombinatorAlias2);
+impl_wrapper_combinator!(InstrControl1Combinator2, InstrControl1CombinatorAlias2);
 
-pub struct InstrReferenceCombinator(pub InstrReferenceCombinatorAlias);
+pub struct InstrControl1Combinator3(pub InstrControl1CombinatorAlias3);
+impl View for InstrControl1Combinator3 {
+    type V = SpecInstrControl1CombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(InstrControl1Combinator3, InstrControl1CombinatorAlias3);
 
-impl View for InstrReferenceCombinator {
-    type V = SpecInstrReferenceCombinator;
-    open spec fn view(&self) -> Self::V { SpecInstrReferenceCombinator(self.0@) }
+pub struct InstrControl1Combinator4(pub InstrControl1CombinatorAlias4);
+impl View for InstrControl1Combinator4 {
+    type V = SpecInstrControl1CombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrReferenceCombinator {
-    type Type = InstrReference<'a>;
+impl_wrapper_combinator!(InstrControl1Combinator4, InstrControl1CombinatorAlias4);
+
+pub struct InstrControl1Combinator5(pub InstrControl1CombinatorAlias5);
+impl View for InstrControl1Combinator5 {
+    type V = SpecInstrControl1CombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(InstrControl1Combinator5, InstrControl1CombinatorAlias5);
+
+pub struct InstrControl1Combinator(pub InstrControl1CombinatorAlias);
+
+impl View for InstrControl1Combinator {
+    type V = SpecInstrControl1Combinator;
+    open spec fn view(&self) -> Self::V { SpecInstrControl1Combinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrControl1Combinator {
+    type Type = InstrControl1<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type InstrReferenceCombinatorAlias = Mapped<InstrReferenceCombinator2, InstrReferenceMapper>;
+}
+pub type InstrControl1CombinatorAlias = Mapped<InstrControl1Combinator5, InstrControl1Mapper>;
 
 
-pub open spec fn spec_instr_reference(opcode: u8) -> SpecInstrReferenceCombinator {
-    SpecInstrReferenceCombinator(Mapped { inner: Choice(Cond { cond: opcode == InstrBytecode::SPEC_RefNull, inner: spec_reftype() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_RefIsNull, inner: spec_empty() }, Cond { cond: opcode == InstrBytecode::SPEC_RefFunc, inner: spec_funcidx() })), mapper: InstrReferenceMapper })
+pub open spec fn spec_instr_control1(opcode: u8) -> SpecInstrControl1Combinator {
+    SpecInstrControl1Combinator(Mapped { inner: Choice(Cond { cond: opcode == InstrBytecode::SPEC_If, inner: spec_blocktype() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Block, inner: spec_blocktype() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Loop, inner: spec_blocktype() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Else, inner: spec_empty() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_Unreachable, inner: spec_empty() }, Cond { cond: opcode == InstrBytecode::SPEC_Nop, inner: spec_empty() }))))), mapper: InstrControl1Mapper })
 }
 
-pub fn instr_reference<'a>(opcode: u8) -> (o: InstrReferenceCombinator)
-    ensures o@ == spec_instr_reference(opcode@),
+pub fn instr_control1<'a>(opcode: u8) -> (o: InstrControl1Combinator)
+    requires
+        spec_instr_bytecode().wf(opcode@),
+
+    ensures o@ == spec_instr_control1(opcode@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = InstrReferenceCombinator(Mapped { inner: InstrReferenceCombinator2(Choice::new(Cond { cond: opcode == InstrBytecode::RefNull, inner: reftype() }, InstrReferenceCombinator1(Choice::new(Cond { cond: opcode == InstrBytecode::RefIsNull, inner: empty() }, Cond { cond: opcode == InstrBytecode::RefFunc, inner: funcidx() })))), mapper: InstrReferenceMapper });
-    assert({
-        &&& combinator@ == spec_instr_reference(opcode@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = InstrControl1Combinator(Mapped { inner: InstrControl1Combinator5(Choice::new(Cond { cond: opcode == InstrBytecode::If, inner: blocktype() }, InstrControl1Combinator4(Choice::new(Cond { cond: opcode == InstrBytecode::Block, inner: blocktype() }, InstrControl1Combinator3(Choice::new(Cond { cond: opcode == InstrBytecode::Loop, inner: blocktype() }, InstrControl1Combinator2(Choice::new(Cond { cond: opcode == InstrBytecode::Else, inner: empty() }, InstrControl1Combinator1(Choice::new(Cond { cond: opcode == InstrBytecode::Unreachable, inner: empty() }, Cond { cond: opcode == InstrBytecode::Nop, inner: empty() })))))))))), mapper: InstrControl1Mapper });
+    // assert({
+    //     &&& combinator@ == spec_instr_control1(opcode@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_instr_reference<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrReferenceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_instr_control1<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrControl1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_instr_reference(opcode@).spec_parse(input@) == Some((n as int, v@)),
-        spec_instr_reference(opcode@).spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_instr_control1(opcode@).spec_parse(input@) == Some((n as int, v@)),
+        spec_instr_control1(opcode@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_instr_reference(opcode@).spec_parse(input@) is None,
-        spec_instr_reference(opcode@).spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_instr_control1(opcode@).spec_parse(input@) is None,
+        spec_instr_control1(opcode@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = instr_reference( opcode );
+    let combinator = instr_control1( opcode );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_instr_reference<'a>(v: <InstrReferenceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, opcode: u8) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_instr_control1<'a>(v: <InstrControl1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, opcode: u8) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_instr_reference(opcode@).wf(v@),
+        spec_instr_control1(opcode@).wf(v@),
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_instr_reference(opcode@).spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_instr_reference(opcode@).spec_serialize(v@))
+            &&& n == spec_instr_control1(opcode@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_instr_control1(opcode@).spec_serialize(v@))
         },
 {
-    let combinator = instr_reference( opcode );
+    let combinator = instr_control1( opcode );
     combinator.serialize(v, data, pos)
 }
 
-pub fn instr_reference_len<'a>(v: <InstrReferenceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, opcode: u8) -> (serialize_len: usize)
+pub fn instr_control1_len<'a>(v: <InstrControl1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, opcode: u8) -> (serialize_len: usize)
     requires
-        spec_instr_reference(opcode@).wf(v@),
-        spec_instr_reference(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_control1(opcode@).wf(v@),
+        spec_instr_control1(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
-        serialize_len == spec_instr_reference(opcode@).spec_serialize(v@).len(),
+        serialize_len == spec_instr_control1(opcode@).spec_serialize(v@).len(),
 {
-    let combinator = instr_reference( opcode );
+    let combinator = instr_control1( opcode );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
 
-pub spec const SPEC_Numtype_I32: u8 = 127;
-pub spec const SPEC_Numtype_I64: u8 = 126;
-pub spec const SPEC_Numtype_F32: u8 = 125;
-pub spec const SPEC_Numtype_F64: u8 = 124;
-pub exec static EXEC_Numtype_I32: u8 ensures EXEC_Numtype_I32 == SPEC_Numtype_I32 { 127 }
-pub exec static EXEC_Numtype_I64: u8 ensures EXEC_Numtype_I64 == SPEC_Numtype_I64 { 126 }
-pub exec static EXEC_Numtype_F32: u8 ensures EXEC_Numtype_F32 == SPEC_Numtype_F32 { 125 }
-pub exec static EXEC_Numtype_F64: u8 ensures EXEC_Numtype_F64 == SPEC_Numtype_F64 { 124 }
-
-#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
-pub enum Numtype {
-    I32 = 127,
-I64 = 126,
-F32 = 125,
-F64 = 124
+pub struct SpecMemarg {
+    pub align: u64,
+    pub offset: u64,
 }
-pub type SpecNumtype = Numtype;
-
-pub type NumtypeInner = u8;
 
-pub type NumtypeInnerRef<'a> = &'a u8;
+pub type SpecMemargInner = (u64, u64);
 
-impl View for Numtype {
-    type V = Self;
 
-    open spec fn view(&self) -> Self::V {
-        *self
+impl SpecFrom<SpecMemarg> for SpecMemargInner {
+    open spec fn spec_from(m: SpecMemarg) -> SpecMemargInner {
+        (m.align, m.offset)
     }
 }
 
-impl SpecTryFrom<NumtypeInner> for Numtype {
-    type Error = ();
-
-    open spec fn spec_try_from(v: NumtypeInner) -> Result<Numtype, ()> {
-        match v {
-            127u8 => Ok(Numtype::I32),
-            126u8 => Ok(Numtype::I64),
-            125u8 => Ok(Numtype::F32),
-            124u8 => Ok(Numtype::F64),
-            _ => Err(()),
-        }
+impl SpecFrom<SpecMemargInner> for SpecMemarg {
+    open spec fn spec_from(m: SpecMemargInner) -> SpecMemarg {
+        let (align, offset) = m;
+        SpecMemarg { align, offset }
     }
 }
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Memarg {
+    pub align: u64,
+    pub offset: u64,
+}
 
-impl SpecTryFrom<Numtype> for NumtypeInner {
-    type Error = ();
+impl View for Memarg {
+    type V = SpecMemarg;
 
-    open spec fn spec_try_from(v: Numtype) -> Result<NumtypeInner, ()> {
-        match v {
-            Numtype::I32 => Ok(SPEC_Numtype_I32),
-            Numtype::I64 => Ok(SPEC_Numtype_I64),
-            Numtype::F32 => Ok(SPEC_Numtype_F32),
-            Numtype::F64 => Ok(SPEC_Numtype_F64),
+    open spec fn view(&self) -> Self::V {
+        SpecMemarg {
+            align: self.align@,
+            offset: self.offset@,
         }
     }
 }
+pub type MemargInner = (u64, u64);
 
-impl TryFrom<NumtypeInner> for Numtype {
-    type Error = ();
-
-    fn ex_try_from(v: NumtypeInner) -> Result<Numtype, ()> {
-        match v {
-            127u8 => Ok(Numtype::I32),
-            126u8 => Ok(Numtype::I64),
-            125u8 => Ok(Numtype::F32),
-            124u8 => Ok(Numtype::F64),
-            _ => Err(()),
-        }
+pub type MemargInnerRef<'a> = (&'a u64, &'a u64);
+impl<'a> From<&'a Memarg> for MemargInnerRef<'a> {
+    fn ex_from(m: &'a Memarg) -> MemargInnerRef<'a> {
+        (&m.align, &m.offset)
     }
 }
 
-impl<'a> TryFrom<&'a Numtype> for NumtypeInnerRef<'a> {
-    type Error = ();
-
-    fn ex_try_from(v: &'a Numtype) -> Result<NumtypeInnerRef<'a>, ()> {
-        match v {
-            Numtype::I32 => Ok(&EXEC_Numtype_I32),
-            Numtype::I64 => Ok(&EXEC_Numtype_I64),
-            Numtype::F32 => Ok(&EXEC_Numtype_F32),
-            Numtype::F64 => Ok(&EXEC_Numtype_F64),
-        }
+impl From<MemargInner> for Memarg {
+    fn ex_from(m: MemargInner) -> Memarg {
+        let (align, offset) = m;
+        Memarg { align, offset }
     }
 }
 
-pub struct NumtypeMapper;
-
-impl View for NumtypeMapper {
+pub struct MemargMapper;
+impl View for MemargMapper {
     type V = Self;
-
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-
-impl SpecPartialIso for NumtypeMapper {
-    type Src = NumtypeInner;
-    type Dst = Numtype;
+impl SpecIso for MemargMapper {
+    type Src = SpecMemargInner;
+    type Dst = SpecMemarg;
 }
-
-impl SpecPartialIsoProof for NumtypeMapper {
-    proof fn spec_iso(s: Self::Src) { 
-        assert(
-            Self::spec_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_rev_apply(v) is Ok
-            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
-        });
+impl SpecIsoProof for MemargMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
-
-    proof fn spec_iso_rev(s: Self::Dst) { 
-        assert(
-            Self::spec_rev_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_apply(v) is Ok
-            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
-        });
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-
-impl<'a> PartialIso<'a> for NumtypeMapper {
-    type Src = NumtypeInner;
-    type Dst = Numtype;
-    type RefSrc = NumtypeInnerRef<'a>;
+impl<'a> Iso<'a> for MemargMapper {
+    type Src = MemargInner;
+    type Dst = Memarg;
+    type RefSrc = MemargInnerRef<'a>;
 }
+type SpecMemargCombinatorAlias1 = (UnsignedLEB128, UnsignedLEB128);
+pub struct SpecMemargCombinator(pub SpecMemargCombinatorAlias);
 
-
-pub struct SpecNumtypeCombinator(pub SpecNumtypeCombinatorAlias);
-
-impl SpecCombinator for SpecNumtypeCombinator {
-    type Type = SpecNumtype;
+impl SpecCombinator for SpecMemargCombinator {
+    type Type = SpecMemarg;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecNumtypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecNumtypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecMemargCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMemargCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecNumtypeCombinatorAlias = TryMap<U8, NumtypeMapper>;
+pub type SpecMemargCombinatorAlias = Mapped<SpecMemargCombinatorAlias1, MemargMapper>;
+type MemargCombinatorAlias1 = (UnsignedLEB128, UnsignedLEB128);
+pub struct MemargCombinator1(pub MemargCombinatorAlias1);
+impl View for MemargCombinator1 {
+    type V = SpecMemargCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(MemargCombinator1, MemargCombinatorAlias1);
 
-pub struct NumtypeCombinator(pub NumtypeCombinatorAlias);
+pub struct MemargCombinator(pub MemargCombinatorAlias);
 
-impl View for NumtypeCombinator {
-    type V = SpecNumtypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecNumtypeCombinator(self.0@) }
+impl View for MemargCombinator {
+    type V = SpecMemargCombinator;
+    open spec fn view(&self) -> Self::V { SpecMemargCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NumtypeCombinator {
-    type Type = Numtype;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemargCombinator {
+    type Type = Memarg;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type NumtypeCombinatorAlias = TryMap<U8, NumtypeMapper>;
+}
+pub type MemargCombinatorAlias = Mapped<MemargCombinator1, MemargMapper>;
 
 
-pub open spec fn spec_numtype() -> SpecNumtypeCombinator {
-    SpecNumtypeCombinator(TryMap { inner: U8, mapper: NumtypeMapper })
+pub open spec fn spec_memarg() -> SpecMemargCombinator {
+    SpecMemargCombinator(
+    Mapped {
+        inner: (UnsignedLEB128, UnsignedLEB128),
+        mapper: MemargMapper,
+    })
 }
 
                 
-pub fn numtype<'a>() -> (o: NumtypeCombinator)
-    ensures o@ == spec_numtype(),
+pub fn memarg<'a>() -> (o: MemargCombinator)
+    ensures o@ == spec_memarg(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = NumtypeCombinator(TryMap { inner: U8, mapper: NumtypeMapper });
-    assert({
-        &&& combinator@ == spec_numtype()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = MemargCombinator(
+    Mapped {
+        inner: MemargCombinator1((UnsignedLEB128, UnsignedLEB128)),
+        mapper: MemargMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_memarg()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_numtype<'a>(input: &'a [u8]) -> (res: PResult<<NumtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_memarg<'a>(input: &'a [u8]) -> (res: PResult<<MemargCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_numtype().spec_parse(input@) == Some((n as int, v@)),
-        spec_numtype().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_memarg().spec_parse(input@) == Some((n as int, v@)),
+        spec_memarg().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_numtype().spec_parse(input@) is None,
-        spec_numtype().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_memarg().spec_parse(input@) is None,
+        spec_memarg().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = numtype();
+    let combinator = memarg();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_numtype<'a>(v: <NumtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_memarg<'a>(v: <MemargCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_numtype().wf(v@),
+        spec_memarg().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_numtype().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_numtype().spec_serialize(v@))
+            &&& n == spec_memarg().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_memarg().spec_serialize(v@))
         },
 {
-    let combinator = numtype();
+    let combinator = memarg();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn numtype_len<'a>(v: <NumtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn memarg_len<'a>(v: <MemargCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_numtype().wf(v@),
-        spec_numtype().spec_serialize(v@).len() <= usize::MAX,
+        spec_memarg().wf(v@),
+        spec_memarg().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_numtype().spec_serialize(v@).len(),
+        serialize_len == spec_memarg().spec_serialize(v@).len(),
 {
-    let combinator = numtype();
+    let combinator = memarg();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub spec const SPEC_Vectype_V128: u8 = 123;
-pub exec static EXEC_Vectype_V128: u8 ensures EXEC_Vectype_V128 == SPEC_Vectype_V128 { 123 }
-
-#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
-pub enum Vectype {
-    V128 = 123
+pub struct SpecByteZero {
+    pub zero: u8,
 }
-pub type SpecVectype = Vectype;
-
-pub type VectypeInner = u8;
 
-pub type VectypeInnerRef<'a> = &'a u8;
+pub type SpecByteZeroInner = u8;
 
-impl View for Vectype {
-    type V = Self;
 
-    open spec fn view(&self) -> Self::V {
-        *self
+impl SpecFrom<SpecByteZero> for SpecByteZeroInner {
+    open spec fn spec_from(m: SpecByteZero) -> SpecByteZeroInner {
+        m.zero
     }
 }
 
-impl SpecTryFrom<VectypeInner> for Vectype {
-    type Error = ();
-
-    open spec fn spec_try_from(v: VectypeInner) -> Result<Vectype, ()> {
-        match v {
-            123u8 => Ok(Vectype::V128),
-            _ => Err(()),
-        }
+impl SpecFrom<SpecByteZeroInner> for SpecByteZero {
+    open spec fn spec_from(m: SpecByteZeroInner) -> SpecByteZero {
+        let zero = m;
+        SpecByteZero { zero }
     }
 }
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-impl SpecTryFrom<Vectype> for VectypeInner {
-    type Error = ();
-
-    open spec fn spec_try_from(v: Vectype) -> Result<VectypeInner, ()> {
-        match v {
-            Vectype::V128 => Ok(SPEC_Vectype_V128),
-        }
-    }
+pub struct ByteZero {
+    pub zero: u8,
 }
 
-impl TryFrom<VectypeInner> for Vectype {
-    type Error = ();
+impl View for ByteZero {
+    type V = SpecByteZero;
 
-    fn ex_try_from(v: VectypeInner) -> Result<Vectype, ()> {
-        match v {
-            123u8 => Ok(Vectype::V128),
-            _ => Err(()),
+    open spec fn view(&self) -> Self::V {
+        SpecByteZero {
+            zero: self.zero@,
         }
     }
 }
+pub type ByteZeroInner = u8;
 
-impl<'a> TryFrom<&'a Vectype> for VectypeInnerRef<'a> {
-    type Error = ();
-
-    fn ex_try_from(v: &'a Vectype) -> Result<VectypeInnerRef<'a>, ()> {
-        match v {
-            Vectype::V128 => Ok(&EXEC_Vectype_V128),
-        }
+pub type ByteZeroInnerRef<'a> = &'a u8;
+impl<'a> From<&'a ByteZero> for ByteZeroInnerRef<'a> {
+    fn ex_from(m: &'a ByteZero) -> ByteZeroInnerRef<'a> {
+        &m.zero
     }
 }
 
-pub struct VectypeMapper;
+impl From<ByteZeroInner> for ByteZero {
+    fn ex_from(m: ByteZeroInner) -> ByteZero {
+        let zero = m;
+        ByteZero { zero }
+    }
+}
 
-impl View for VectypeMapper {
+pub struct ByteZeroMapper;
+impl View for ByteZeroMapper {
     type V = Self;
-
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-
-impl SpecPartialIso for VectypeMapper {
-    type Src = VectypeInner;
-    type Dst = Vectype;
+impl SpecIso for ByteZeroMapper {
+    type Src = SpecByteZeroInner;
+    type Dst = SpecByteZero;
 }
-
-impl SpecPartialIsoProof for VectypeMapper {
-    proof fn spec_iso(s: Self::Src) { 
-        assert(
-            Self::spec_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_rev_apply(v) is Ok
-            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
-        });
+impl SpecIsoProof for ByteZeroMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
-
-    proof fn spec_iso_rev(s: Self::Dst) { 
-        assert(
-            Self::spec_rev_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_apply(v) is Ok
-            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
-        });
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-
-impl<'a> PartialIso<'a> for VectypeMapper {
-    type Src = VectypeInner;
-    type Dst = Vectype;
-    type RefSrc = VectypeInnerRef<'a>;
+impl<'a> Iso<'a> for ByteZeroMapper {
+    type Src = ByteZeroInner;
+    type Dst = ByteZero;
+    type RefSrc = ByteZeroInnerRef<'a>;
 }
+pub const BYTEZEROZERO_CONST: u8 = 0;
 
+pub struct SpecByteZeroCombinator(pub SpecByteZeroCombinatorAlias);
 
-pub struct SpecVectypeCombinator(pub SpecVectypeCombinatorAlias);
-
-impl SpecCombinator for SpecVectypeCombinator {
-    type Type = SpecVectype;
+impl SpecCombinator for SpecByteZeroCombinator {
+    type Type = SpecByteZero;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecVectypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecVectypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecByteZeroCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecByteZeroCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecVectypeCombinatorAlias = TryMap<U8, VectypeMapper>;
+pub type SpecByteZeroCombinatorAlias = Mapped<Refined<U8, TagPred<u8>>, ByteZeroMapper>;
 
-pub struct VectypeCombinator(pub VectypeCombinatorAlias);
+pub struct ByteZeroCombinator(pub ByteZeroCombinatorAlias);
 
-impl View for VectypeCombinator {
-    type V = SpecVectypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecVectypeCombinator(self.0@) }
+impl View for ByteZeroCombinator {
+    type V = SpecByteZeroCombinator;
+    open spec fn view(&self) -> Self::V { SpecByteZeroCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for VectypeCombinator {
-    type Type = Vectype;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ByteZeroCombinator {
+    type Type = ByteZero;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type VectypeCombinatorAlias = TryMap<U8, VectypeMapper>;
+}
+pub type ByteZeroCombinatorAlias = Mapped<Refined<U8, TagPred<u8>>, ByteZeroMapper>;
 
 
-pub open spec fn spec_vectype() -> SpecVectypeCombinator {
-    SpecVectypeCombinator(TryMap { inner: U8, mapper: VectypeMapper })
+pub open spec fn spec_byte_zero() -> SpecByteZeroCombinator {
+    SpecByteZeroCombinator(
+    Mapped {
+        inner: Refined { inner: U8, predicate: TagPred(BYTEZEROZERO_CONST) },
+        mapper: ByteZeroMapper,
+    })
 }
 
                 
-pub fn vectype<'a>() -> (o: VectypeCombinator)
-    ensures o@ == spec_vectype(),
+pub fn byte_zero<'a>() -> (o: ByteZeroCombinator)
+    ensures o@ == spec_byte_zero(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = VectypeCombinator(TryMap { inner: U8, mapper: VectypeMapper });
-    assert({
-        &&& combinator@ == spec_vectype()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ByteZeroCombinator(
+    Mapped {
+        inner: Refined { inner: U8, predicate: TagPred(BYTEZEROZERO_CONST) },
+        mapper: ByteZeroMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_byte_zero()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_vectype<'a>(input: &'a [u8]) -> (res: PResult<<VectypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_byte_zero<'a>(input: &'a [u8]) -> (res: PResult<<ByteZeroCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_vectype().spec_parse(input@) == Some((n as int, v@)),
-        spec_vectype().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_byte_zero().spec_parse(input@) == Some((n as int, v@)),
+        spec_byte_zero().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_vectype().spec_parse(input@) is None,
-        spec_vectype().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_byte_zero().spec_parse(input@) is None,
+        spec_byte_zero().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = vectype();
+    let combinator = byte_zero();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_vectype<'a>(v: <VectypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_byte_zero<'a>(v: <ByteZeroCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_vectype().wf(v@),
+        spec_byte_zero().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_vectype().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_vectype().spec_serialize(v@))
+            &&& n == spec_byte_zero().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_byte_zero().spec_serialize(v@))
         },
 {
-    let combinator = vectype();
+    let combinator = byte_zero();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn vectype_len<'a>(v: <VectypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn byte_zero_len<'a>(v: <ByteZeroCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_vectype().wf(v@),
-        spec_vectype().spec_serialize(v@).len() <= usize::MAX,
+        spec_byte_zero().wf(v@),
+        spec_byte_zero().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_vectype().spec_serialize(v@).len(),
+        serialize_len == spec_byte_zero().spec_serialize(v@).len(),
 {
-    let combinator = vectype();
+    let combinator = byte_zero();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub enum SpecValtype {
-    NumTy(SpecNumtype),
-    VecTy(SpecVectype),
-    RefTy(SpecReftype),
+pub enum SpecInstrMemory {
+    I32Store(SpecMemarg),
+    I32Load(SpecMemarg),
+    I64Store(SpecMemarg),
+    I64Load(SpecMemarg),
+    MemorySize(SpecByteZero),
+    MemoryGrow(SpecByteZero),
+    Unrecognized(SpecMemarg),
 }
 
-pub type SpecValtypeInner = Either<SpecNumtype, Either<SpecVectype, SpecReftype>>;
+pub type SpecInstrMemoryInner = Either<SpecMemarg, Either<SpecMemarg, Either<SpecMemarg, Either<SpecMemarg, Either<SpecByteZero, Either<SpecByteZero, SpecMemarg>>>>>>;
 
-impl SpecFrom<SpecValtype> for SpecValtypeInner {
-    open spec fn spec_from(m: SpecValtype) -> SpecValtypeInner {
+impl SpecFrom<SpecInstrMemory> for SpecInstrMemoryInner {
+    open spec fn spec_from(m: SpecInstrMemory) -> SpecInstrMemoryInner {
         match m {
-            SpecValtype::NumTy(m) => Either::Left(m),
-            SpecValtype::VecTy(m) => Either::Right(Either::Left(m)),
-            SpecValtype::RefTy(m) => Either::Right(Either::Right(m)),
+            SpecInstrMemory::I32Store(m) => Either::Left(m),
+            SpecInstrMemory::I32Load(m) => Either::Right(Either::Left(m)),
+            SpecInstrMemory::I64Store(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecInstrMemory::I64Load(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecInstrMemory::MemorySize(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecInstrMemory::MemoryGrow(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            SpecInstrMemory::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
         }
     }
 
 }
 
                 
-impl SpecFrom<SpecValtypeInner> for SpecValtype {
-    open spec fn spec_from(m: SpecValtypeInner) -> SpecValtype {
+impl SpecFrom<SpecInstrMemoryInner> for SpecInstrMemory {
+    open spec fn spec_from(m: SpecInstrMemoryInner) -> SpecInstrMemory {
         match m {
-            Either::Left(m) => SpecValtype::NumTy(m),
-            Either::Right(Either::Left(m)) => SpecValtype::VecTy(m),
-            Either::Right(Either::Right(m)) => SpecValtype::RefTy(m),
+            Either::Left(m) => SpecInstrMemory::I32Store(m),
+            Either::Right(Either::Left(m)) => SpecInstrMemory::I32Load(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecInstrMemory::I64Store(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecInstrMemory::I64Load(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecInstrMemory::MemorySize(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecInstrMemory::MemoryGrow(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => SpecInstrMemory::Unrecognized(m),
         }
     }
 
@@ -5438,64 +5793,80 @@ impl SpecFrom<SpecValtypeInner> for SpecValtype {
 
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Valtype {
-    NumTy(Numtype),
-    VecTy(Vectype),
-    RefTy(Reftype),
+pub enum InstrMemory {
+    I32Store(Memarg),
+    I32Load(Memarg),
+    I64Store(Memarg),
+    I64Load(Memarg),
+    MemorySize(ByteZero),
+    MemoryGrow(ByteZero),
+    Unrecognized(Memarg),
 }
 
-pub type ValtypeInner = Either<Numtype, Either<Vectype, Reftype>>;
+pub type InstrMemoryInner = Either<Memarg, Either<Memarg, Either<Memarg, Either<Memarg, Either<ByteZero, Either<ByteZero, Memarg>>>>>>;
 
-pub type ValtypeInnerRef<'a> = Either<&'a Numtype, Either<&'a Vectype, &'a Reftype>>;
+pub type InstrMemoryInnerRef<'a> = Either<&'a Memarg, Either<&'a Memarg, Either<&'a Memarg, Either<&'a Memarg, Either<&'a ByteZero, Either<&'a ByteZero, &'a Memarg>>>>>>;
 
 
-impl View for Valtype {
-    type V = SpecValtype;
+impl View for InstrMemory {
+    type V = SpecInstrMemory;
     open spec fn view(&self) -> Self::V {
         match self {
-            Valtype::NumTy(m) => SpecValtype::NumTy(m@),
-            Valtype::VecTy(m) => SpecValtype::VecTy(m@),
-            Valtype::RefTy(m) => SpecValtype::RefTy(m@),
+            InstrMemory::I32Store(m) => SpecInstrMemory::I32Store(m@),
+            InstrMemory::I32Load(m) => SpecInstrMemory::I32Load(m@),
+            InstrMemory::I64Store(m) => SpecInstrMemory::I64Store(m@),
+            InstrMemory::I64Load(m) => SpecInstrMemory::I64Load(m@),
+            InstrMemory::MemorySize(m) => SpecInstrMemory::MemorySize(m@),
+            InstrMemory::MemoryGrow(m) => SpecInstrMemory::MemoryGrow(m@),
+            InstrMemory::Unrecognized(m) => SpecInstrMemory::Unrecognized(m@),
         }
     }
 }
 
 
-impl<'a> From<&'a Valtype> for ValtypeInnerRef<'a> {
-    fn ex_from(m: &'a Valtype) -> ValtypeInnerRef<'a> {
+impl<'a> From<&'a InstrMemory> for InstrMemoryInnerRef<'a> {
+    fn ex_from(m: &'a InstrMemory) -> InstrMemoryInnerRef<'a> {
         match m {
-            Valtype::NumTy(m) => Either::Left(m),
-            Valtype::VecTy(m) => Either::Right(Either::Left(m)),
-            Valtype::RefTy(m) => Either::Right(Either::Right(m)),
+            InstrMemory::I32Store(m) => Either::Left(m),
+            InstrMemory::I32Load(m) => Either::Right(Either::Left(m)),
+            InstrMemory::I64Store(m) => Either::Right(Either::Right(Either::Left(m))),
+            InstrMemory::I64Load(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            InstrMemory::MemorySize(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            InstrMemory::MemoryGrow(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            InstrMemory::Unrecognized(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))),
         }
     }
 
 }
 
-impl From<ValtypeInner> for Valtype {
-    fn ex_from(m: ValtypeInner) -> Valtype {
+impl From<InstrMemoryInner> for InstrMemory {
+    fn ex_from(m: InstrMemoryInner) -> InstrMemory {
         match m {
-            Either::Left(m) => Valtype::NumTy(m),
-            Either::Right(Either::Left(m)) => Valtype::VecTy(m),
-            Either::Right(Either::Right(m)) => Valtype::RefTy(m),
+            Either::Left(m) => InstrMemory::I32Store(m),
+            Either::Right(Either::Left(m)) => InstrMemory::I32Load(m),
+            Either::Right(Either::Right(Either::Left(m))) => InstrMemory::I64Store(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => InstrMemory::I64Load(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => InstrMemory::MemorySize(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => InstrMemory::MemoryGrow(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m)))))) => InstrMemory::Unrecognized(m),
         }
     }
     
 }
 
 
-pub struct ValtypeMapper;
-impl View for ValtypeMapper {
+pub struct InstrMemoryMapper;
+impl View for InstrMemoryMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ValtypeMapper {
-    type Src = SpecValtypeInner;
-    type Dst = SpecValtype;
+impl SpecIso for InstrMemoryMapper {
+    type Src = SpecInstrMemoryInner;
+    type Dst = SpecInstrMemory;
 }
-impl SpecIsoProof for ValtypeMapper {
+impl SpecIsoProof for InstrMemoryMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -5503,228 +5874,278 @@ impl SpecIsoProof for ValtypeMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ValtypeMapper {
-    type Src = ValtypeInner;
-    type Dst = Valtype;
-    type RefSrc = ValtypeInnerRef<'a>;
-}
-
-type SpecValtypeCombinatorAlias1 = Choice<SpecVectypeCombinator, SpecReftypeCombinator>;
-type SpecValtypeCombinatorAlias2 = Choice<SpecNumtypeCombinator, SpecValtypeCombinatorAlias1>;
-impl DisjointFrom<SpecNumtypeCombinator> for SpecVectypeCombinator {
-    open spec fn disjoint_from(&self, other: &SpecNumtypeCombinator) -> bool
-    { self.0.disjoint_from(&other.0) }
-    proof fn parse_disjoint_on(&self, other: &SpecNumtypeCombinator, buf: Seq<u8>) 
-    { self.0.parse_disjoint_on(&other.0, buf); }
-}
-
-impl DisjointFrom<SpecNumtypeCombinator> for SpecReftypeCombinator {
-    open spec fn disjoint_from(&self, other: &SpecNumtypeCombinator) -> bool
-    { self.0.disjoint_from(&other.0) }
-    proof fn parse_disjoint_on(&self, other: &SpecNumtypeCombinator, buf: Seq<u8>) 
-    { self.0.parse_disjoint_on(&other.0, buf); }
+impl<'a> Iso<'a> for InstrMemoryMapper {
+    type Src = InstrMemoryInner;
+    type Dst = InstrMemory;
+    type RefSrc = InstrMemoryInnerRef<'a>;
 }
 
-impl DisjointFrom<SpecVectypeCombinator> for SpecReftypeCombinator {
-    open spec fn disjoint_from(&self, other: &SpecVectypeCombinator) -> bool
-    { self.0.disjoint_from(&other.0) }
-    proof fn parse_disjoint_on(&self, other: &SpecVectypeCombinator, buf: Seq<u8>) 
-    { self.0.parse_disjoint_on(&other.0, buf); }
-}
-pub struct SpecValtypeCombinator(pub SpecValtypeCombinatorAlias);
+type SpecInstrMemoryCombinatorAlias1 = Choice<Cond<SpecByteZeroCombinator>, Cond<SpecMemargCombinator>>;
+type SpecInstrMemoryCombinatorAlias2 = Choice<Cond<SpecByteZeroCombinator>, SpecInstrMemoryCombinatorAlias1>;
+type SpecInstrMemoryCombinatorAlias3 = Choice<Cond<SpecMemargCombinator>, SpecInstrMemoryCombinatorAlias2>;
+type SpecInstrMemoryCombinatorAlias4 = Choice<Cond<SpecMemargCombinator>, SpecInstrMemoryCombinatorAlias3>;
+type SpecInstrMemoryCombinatorAlias5 = Choice<Cond<SpecMemargCombinator>, SpecInstrMemoryCombinatorAlias4>;
+type SpecInstrMemoryCombinatorAlias6 = Choice<Cond<SpecMemargCombinator>, SpecInstrMemoryCombinatorAlias5>;
+pub struct SpecInstrMemoryCombinator(pub SpecInstrMemoryCombinatorAlias);
 
-impl SpecCombinator for SpecValtypeCombinator {
-    type Type = SpecValtype;
+impl SpecCombinator for SpecInstrMemoryCombinator {
+    type Type = SpecInstrMemory;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecValtypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecValtypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecInstrMemoryCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecInstrMemoryCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecValtypeCombinatorAlias = Mapped<SpecValtypeCombinatorAlias2, ValtypeMapper>;
-type ValtypeCombinatorAlias1 = Choice<VectypeCombinator, ReftypeCombinator>;
-type ValtypeCombinatorAlias2 = Choice<NumtypeCombinator, ValtypeCombinator1>;
-pub struct ValtypeCombinator1(pub ValtypeCombinatorAlias1);
-impl View for ValtypeCombinator1 {
-    type V = SpecValtypeCombinatorAlias1;
+pub type SpecInstrMemoryCombinatorAlias = Mapped<SpecInstrMemoryCombinatorAlias6, InstrMemoryMapper>;
+type InstrMemoryCombinatorAlias1 = Choice<Cond<ByteZeroCombinator>, Cond<MemargCombinator>>;
+type InstrMemoryCombinatorAlias2 = Choice<Cond<ByteZeroCombinator>, InstrMemoryCombinator1>;
+type InstrMemoryCombinatorAlias3 = Choice<Cond<MemargCombinator>, InstrMemoryCombinator2>;
+type InstrMemoryCombinatorAlias4 = Choice<Cond<MemargCombinator>, InstrMemoryCombinator3>;
+type InstrMemoryCombinatorAlias5 = Choice<Cond<MemargCombinator>, InstrMemoryCombinator4>;
+type InstrMemoryCombinatorAlias6 = Choice<Cond<MemargCombinator>, InstrMemoryCombinator5>;
+pub struct InstrMemoryCombinator1(pub InstrMemoryCombinatorAlias1);
+impl View for InstrMemoryCombinator1 {
+    type V = SpecInstrMemoryCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ValtypeCombinator1, ValtypeCombinatorAlias1);
+impl_wrapper_combinator!(InstrMemoryCombinator1, InstrMemoryCombinatorAlias1);
 
-pub struct ValtypeCombinator2(pub ValtypeCombinatorAlias2);
-impl View for ValtypeCombinator2 {
-    type V = SpecValtypeCombinatorAlias2;
+pub struct InstrMemoryCombinator2(pub InstrMemoryCombinatorAlias2);
+impl View for InstrMemoryCombinator2 {
+    type V = SpecInstrMemoryCombinatorAlias2;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ValtypeCombinator2, ValtypeCombinatorAlias2);
+impl_wrapper_combinator!(InstrMemoryCombinator2, InstrMemoryCombinatorAlias2);
 
-pub struct ValtypeCombinator(pub ValtypeCombinatorAlias);
+pub struct InstrMemoryCombinator3(pub InstrMemoryCombinatorAlias3);
+impl View for InstrMemoryCombinator3 {
+    type V = SpecInstrMemoryCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(InstrMemoryCombinator3, InstrMemoryCombinatorAlias3);
 
-impl View for ValtypeCombinator {
-    type V = SpecValtypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecValtypeCombinator(self.0@) }
+pub struct InstrMemoryCombinator4(pub InstrMemoryCombinatorAlias4);
+impl View for InstrMemoryCombinator4 {
+    type V = SpecInstrMemoryCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ValtypeCombinator {
-    type Type = Valtype;
+impl_wrapper_combinator!(InstrMemoryCombinator4, InstrMemoryCombinatorAlias4);
+
+pub struct InstrMemoryCombinator5(pub InstrMemoryCombinatorAlias5);
+impl View for InstrMemoryCombinator5 {
+    type V = SpecInstrMemoryCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(InstrMemoryCombinator5, InstrMemoryCombinatorAlias5);
+
+pub struct InstrMemoryCombinator6(pub InstrMemoryCombinatorAlias6);
+impl View for InstrMemoryCombinator6 {
+    type V = SpecInstrMemoryCombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(InstrMemoryCombinator6, InstrMemoryCombinatorAlias6);
+
+pub struct InstrMemoryCombinator(pub InstrMemoryCombinatorAlias);
+
+impl View for InstrMemoryCombinator {
+    type V = SpecInstrMemoryCombinator;
+    open spec fn view(&self) -> Self::V { SpecInstrMemoryCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrMemoryCombinator {
+    type Type = InstrMemory;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ValtypeCombinatorAlias = Mapped<ValtypeCombinator2, ValtypeMapper>;
+}
+pub type InstrMemoryCombinatorAlias = Mapped<InstrMemoryCombinator6, InstrMemoryMapper>;
 
 
-pub open spec fn spec_valtype() -> SpecValtypeCombinator {
-    SpecValtypeCombinator(Mapped { inner: Choice(spec_numtype(), Choice(spec_vectype(), spec_reftype())), mapper: ValtypeMapper })
+pub open spec fn spec_instr_memory(opcode: u8) -> SpecInstrMemoryCombinator {
+    SpecInstrMemoryCombinator(Mapped { inner: Choice(Cond { cond: opcode == InstrBytecode::SPEC_I32Store, inner: spec_memarg() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_I32Load, inner: spec_memarg() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_I64Store, inner: spec_memarg() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_I64Load, inner: spec_memarg() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_MemorySize, inner: spec_byte_zero() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_MemoryGrow, inner: spec_byte_zero() }, Cond { cond: !(opcode == InstrBytecode::SPEC_I32Store || opcode == InstrBytecode::SPEC_I32Load || opcode == InstrBytecode::SPEC_I64Store || opcode == InstrBytecode::SPEC_I64Load || opcode == InstrBytecode::SPEC_MemorySize || opcode == InstrBytecode::SPEC_MemoryGrow), inner: spec_memarg() })))))), mapper: InstrMemoryMapper })
 }
 
-                
-pub fn valtype<'a>() -> (o: ValtypeCombinator)
-    ensures o@ == spec_valtype(),
+pub fn instr_memory<'a>(opcode: u8) -> (o: InstrMemoryCombinator)
+    requires
+        spec_instr_bytecode().wf(opcode@),
+
+    ensures o@ == spec_instr_memory(opcode@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ValtypeCombinator(Mapped { inner: ValtypeCombinator2(Choice::new(numtype(), ValtypeCombinator1(Choice::new(vectype(), reftype())))), mapper: ValtypeMapper });
-    assert({
-        &&& combinator@ == spec_valtype()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = InstrMemoryCombinator(Mapped { inner: InstrMemoryCombinator6(Choice::new(Cond { cond: opcode == InstrBytecode::I32Store, inner: memarg() }, InstrMemoryCombinator5(Choice::new(Cond { cond: opcode == InstrBytecode::I32Load, inner: memarg() }, InstrMemoryCombinator4(Choice::new(Cond { cond: opcode == InstrBytecode::I64Store, inner: memarg() }, InstrMemoryCombinator3(Choice::new(Cond { cond: opcode == InstrBytecode::I64Load, inner: memarg() }, InstrMemoryCombinator2(Choice::new(Cond { cond: opcode == InstrBytecode::MemorySize, inner: byte_zero() }, InstrMemoryCombinator1(Choice::new(Cond { cond: opcode == InstrBytecode::MemoryGrow, inner: byte_zero() }, Cond { cond: !(opcode == InstrBytecode::I32Store || opcode == InstrBytecode::I32Load || opcode == InstrBytecode::I64Store || opcode == InstrBytecode::I64Load || opcode == InstrBytecode::MemorySize || opcode == InstrBytecode::MemoryGrow), inner: memarg() })))))))))))), mapper: InstrMemoryMapper });
+    // assert({
+    //     &&& combinator@ == spec_instr_memory(opcode@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_valtype<'a>(input: &'a [u8]) -> (res: PResult<<ValtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_instr_memory<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrMemoryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_valtype().spec_parse(input@) == Some((n as int, v@)),
-        spec_valtype().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_instr_memory(opcode@).spec_parse(input@) == Some((n as int, v@)),
+        spec_instr_memory(opcode@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_valtype().spec_parse(input@) is None,
-        spec_valtype().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_instr_memory(opcode@).spec_parse(input@) is None,
+        spec_instr_memory(opcode@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = valtype();
+    let combinator = instr_memory( opcode );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_valtype<'a>(v: <ValtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_instr_memory<'a>(v: <InstrMemoryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, opcode: u8) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_valtype().wf(v@),
+        spec_instr_memory(opcode@).wf(v@),
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_valtype().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_valtype().spec_serialize(v@))
+            &&& n == spec_instr_memory(opcode@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_instr_memory(opcode@).spec_serialize(v@))
         },
 {
-    let combinator = valtype();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = instr_memory( opcode );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn valtype_len<'a>(v: <ValtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn instr_memory_len<'a>(v: <InstrMemoryCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, opcode: u8) -> (serialize_len: usize)
     requires
-        spec_valtype().wf(v@),
-        spec_valtype().spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_memory(opcode@).wf(v@),
+        spec_instr_memory(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
-        serialize_len == spec_valtype().spec_serialize(v@).len(),
+        serialize_len == spec_instr_memory(opcode@).spec_serialize(v@).len(),
 {
-    let combinator = valtype();
+    let combinator = instr_memory( opcode );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
 
-pub struct SpecSelectT {
-    pub l: u64,
-    pub v: Seq<SpecValtype>,
+pub enum SpecInstrReference {
+    RefNull(SpecReftype),
+    RefIsNull(SpecEmpty),
+    RefFunc(SpecFuncidx),
 }
 
-pub type SpecSelectTInner = (u64, Seq<SpecValtype>);
-
+pub type SpecInstrReferenceInner = Either<SpecReftype, Either<SpecEmpty, SpecFuncidx>>;
 
-impl SpecFrom<SpecSelectT> for SpecSelectTInner {
-    open spec fn spec_from(m: SpecSelectT) -> SpecSelectTInner {
-        (m.l, m.v)
+impl SpecFrom<SpecInstrReference> for SpecInstrReferenceInner {
+    open spec fn spec_from(m: SpecInstrReference) -> SpecInstrReferenceInner {
+        match m {
+            SpecInstrReference::RefNull(m) => Either::Left(m),
+            SpecInstrReference::RefIsNull(m) => Either::Right(Either::Left(m)),
+            SpecInstrReference::RefFunc(m) => Either::Right(Either::Right(m)),
+        }
     }
+
 }
 
-impl SpecFrom<SpecSelectTInner> for SpecSelectT {
-    open spec fn spec_from(m: SpecSelectTInner) -> SpecSelectT {
-        let (l, v) = m;
-        SpecSelectT { l, v }
+                
+impl SpecFrom<SpecInstrReferenceInner> for SpecInstrReference {
+    open spec fn spec_from(m: SpecInstrReferenceInner) -> SpecInstrReference {
+        match m {
+            Either::Left(m) => SpecInstrReference::RefNull(m),
+            Either::Right(Either::Left(m)) => SpecInstrReference::RefIsNull(m),
+            Either::Right(Either::Right(m)) => SpecInstrReference::RefFunc(m),
+        }
     }
+
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct SelectT {
-    pub l: u64,
-    pub v: RepeatResult<Valtype>,
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum InstrReference<'a> {
+    RefNull(Reftype),
+    RefIsNull(Empty<'a>),
+    RefFunc(Funcidx),
 }
 
-impl View for SelectT {
-    type V = SpecSelectT;
+pub type InstrReferenceInner<'a> = Either<Reftype, Either<Empty<'a>, Funcidx>>;
+
+pub type InstrReferenceInnerRef<'a> = Either<&'a Reftype, Either<&'a Empty<'a>, &'a Funcidx>>;
+
 
+impl<'a> View for InstrReference<'a> {
+    type V = SpecInstrReference;
     open spec fn view(&self) -> Self::V {
-        SpecSelectT {
-            l: self.l@,
-            v: self.v@,
+        match self {
+            InstrReference::RefNull(m) => SpecInstrReference::RefNull(m@),
+            InstrReference::RefIsNull(m) => SpecInstrReference::RefIsNull(m@),
+            InstrReference::RefFunc(m) => SpecInstrReference::RefFunc(m@),
         }
     }
 }
-pub type SelectTInner = (u64, RepeatResult<Valtype>);
 
-pub type SelectTInnerRef<'a> = (&'a u64, &'a RepeatResult<Valtype>);
-impl<'a> From<&'a SelectT> for SelectTInnerRef<'a> {
-    fn ex_from(m: &'a SelectT) -> SelectTInnerRef<'a> {
-        (&m.l, &m.v)
+
+impl<'a> From<&'a InstrReference<'a>> for InstrReferenceInnerRef<'a> {
+    fn ex_from(m: &'a InstrReference<'a>) -> InstrReferenceInnerRef<'a> {
+        match m {
+            InstrReference::RefNull(m) => Either::Left(m),
+            InstrReference::RefIsNull(m) => Either::Right(Either::Left(m)),
+            InstrReference::RefFunc(m) => Either::Right(Either::Right(m)),
+        }
     }
+
 }
 
-impl From<SelectTInner> for SelectT {
-    fn ex_from(m: SelectTInner) -> SelectT {
-        let (l, v) = m;
-        SelectT { l, v }
+impl<'a> From<InstrReferenceInner<'a>> for InstrReference<'a> {
+    fn ex_from(m: InstrReferenceInner<'a>) -> InstrReference<'a> {
+        match m {
+            Either::Left(m) => InstrReference::RefNull(m),
+            Either::Right(Either::Left(m)) => InstrReference::RefIsNull(m),
+            Either::Right(Either::Right(m)) => InstrReference::RefFunc(m),
+        }
     }
+    
 }
 
-pub struct SelectTMapper;
-impl View for SelectTMapper {
+
+pub struct InstrReferenceMapper;
+impl View for InstrReferenceMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for SelectTMapper {
-    type Src = SpecSelectTInner;
-    type Dst = SpecSelectT;
+impl SpecIso for InstrReferenceMapper {
+    type Src = SpecInstrReferenceInner;
+    type Dst = SpecInstrReference;
 }
-impl SpecIsoProof for SelectTMapper {
+impl SpecIsoProof for InstrReferenceMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -5732,175 +6153,149 @@ impl SpecIsoProof for SelectTMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for SelectTMapper {
-    type Src = SelectTInner;
-    type Dst = SelectT;
-    type RefSrc = SelectTInnerRef<'a>;
+impl<'a> Iso<'a> for InstrReferenceMapper {
+    type Src = InstrReferenceInner<'a>;
+    type Dst = InstrReference<'a>;
+    type RefSrc = InstrReferenceInnerRef<'a>;
 }
 
-pub struct SpecSelectTCombinator(pub SpecSelectTCombinatorAlias);
+type SpecInstrReferenceCombinatorAlias1 = Choice<Cond<SpecEmptyCombinator>, Cond<SpecFuncidxCombinator>>;
+type SpecInstrReferenceCombinatorAlias2 = Choice<Cond<SpecReftypeCombinator>, SpecInstrReferenceCombinatorAlias1>;
+pub struct SpecInstrReferenceCombinator(pub SpecInstrReferenceCombinatorAlias);
 
-impl SpecCombinator for SpecSelectTCombinator {
-    type Type = SpecSelectT;
+impl SpecCombinator for SpecInstrReferenceCombinator {
+    type Type = SpecInstrReference;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecSelectTCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSelectTCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecInstrReferenceCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecInstrReferenceCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecSelectTCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecValtypeCombinator>>, SelectTMapper>;
+pub type SpecInstrReferenceCombinatorAlias = Mapped<SpecInstrReferenceCombinatorAlias2, InstrReferenceMapper>;
+type InstrReferenceCombinatorAlias1 = Choice<Cond<EmptyCombinator>, Cond<FuncidxCombinator>>;
+type InstrReferenceCombinatorAlias2 = Choice<Cond<ReftypeCombinator>, InstrReferenceCombinator1>;
+pub struct InstrReferenceCombinator1(pub InstrReferenceCombinatorAlias1);
+impl View for InstrReferenceCombinator1 {
+    type V = SpecInstrReferenceCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(InstrReferenceCombinator1, InstrReferenceCombinatorAlias1);
+
+pub struct InstrReferenceCombinator2(pub InstrReferenceCombinatorAlias2);
+impl View for InstrReferenceCombinator2 {
+    type V = SpecInstrReferenceCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(InstrReferenceCombinator2, InstrReferenceCombinatorAlias2);
 
-pub struct SelectTCombinator(pub SelectTCombinatorAlias);
+pub struct InstrReferenceCombinator(pub InstrReferenceCombinatorAlias);
 
-impl View for SelectTCombinator {
-    type V = SpecSelectTCombinator;
-    open spec fn view(&self) -> Self::V { SpecSelectTCombinator(self.0@) }
+impl View for InstrReferenceCombinator {
+    type V = SpecInstrReferenceCombinator;
+    open spec fn view(&self) -> Self::V { SpecInstrReferenceCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for SelectTCombinator {
-    type Type = SelectT;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrReferenceCombinator {
+    type Type = InstrReference<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type SelectTCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ValtypeCombinator>, SelectTCont0>, SelectTMapper>;
-
-
-pub open spec fn spec_select_t() -> SpecSelectTCombinator {
-    SpecSelectTCombinator(
-    Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_select_t_cont0(deps)),
-        mapper: SelectTMapper,
-    })
-}
-
-pub open spec fn spec_select_t_cont0(deps: u64) -> RepeatN<SpecValtypeCombinator> {
-    let l = deps;
-    RepeatN(spec_valtype(), l.spec_into())
 }
+pub type InstrReferenceCombinatorAlias = Mapped<InstrReferenceCombinator2, InstrReferenceMapper>;
 
-impl View for SelectTCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecValtypeCombinator>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_select_t_cont0(deps)
-        }
-    }
+pub open spec fn spec_instr_reference(opcode: u8) -> SpecInstrReferenceCombinator {
+    SpecInstrReferenceCombinator(Mapped { inner: Choice(Cond { cond: opcode == InstrBytecode::SPEC_RefNull, inner: spec_reftype() }, Choice(Cond { cond: opcode == InstrBytecode::SPEC_RefIsNull, inner: spec_empty() }, Cond { cond: opcode == InstrBytecode::SPEC_RefFunc, inner: spec_funcidx() })), mapper: InstrReferenceMapper })
 }
 
-                
-pub fn select_t<'a>() -> (o: SelectTCombinator)
-    ensures o@ == spec_select_t(),
+pub fn instr_reference<'a>(opcode: u8) -> (o: InstrReferenceCombinator)
+    requires
+        spec_instr_bytecode().wf(opcode@),
+
+    ensures o@ == spec_instr_reference(opcode@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = SelectTCombinator(
-    Mapped {
-        inner: Pair::new(UnsignedLEB128, SelectTCont0),
-        mapper: SelectTMapper,
-    });
-    assert({
-        &&& combinator@ == spec_select_t()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = InstrReferenceCombinator(Mapped { inner: InstrReferenceCombinator2(Choice::new(Cond { cond: opcode == InstrBytecode::RefNull, inner: reftype() }, InstrReferenceCombinator1(Choice::new(Cond { cond: opcode == InstrBytecode::RefIsNull, inner: empty() }, Cond { cond: opcode == InstrBytecode::RefFunc, inner: funcidx() })))), mapper: InstrReferenceMapper });
+    // assert({
+    //     &&& combinator@ == spec_instr_reference(opcode@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_select_t<'a>(input: &'a [u8]) -> (res: PResult<<SelectTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_instr_reference<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrReferenceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
-        res matches Ok((n, v)) ==> spec_select_t().spec_parse(input@) == Some((n as int, v@)),
-        spec_select_t().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_instr_reference(opcode@).spec_parse(input@) == Some((n as int, v@)),
+        spec_instr_reference(opcode@).spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_select_t().spec_parse(input@) is None,
-        spec_select_t().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_instr_reference(opcode@).spec_parse(input@) is None,
+        spec_instr_reference(opcode@).spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = select_t();
+    let combinator = instr_reference( opcode );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_select_t<'a>(v: <SelectTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_instr_reference<'a>(v: <InstrReferenceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize, opcode: u8) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_select_t().wf(v@),
+        spec_instr_reference(opcode@).wf(v@),
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_select_t().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_select_t().spec_serialize(v@))
+            &&& n == spec_instr_reference(opcode@).spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_instr_reference(opcode@).spec_serialize(v@))
         },
 {
-    let combinator = select_t();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+    let combinator = instr_reference( opcode );
+    combinator.serialize(v, data, pos)
 }
 
-pub fn select_t_len<'a>(v: <SelectTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn instr_reference_len<'a>(v: <InstrReferenceCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, opcode: u8) -> (serialize_len: usize)
     requires
-        spec_select_t().wf(v@),
-        spec_select_t().spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_reference(opcode@).wf(v@),
+        spec_instr_reference(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
-        serialize_len == spec_select_t().spec_serialize(v@).len(),
+        serialize_len == spec_instr_reference(opcode@).spec_serialize(v@).len(),
 {
-    let combinator = select_t();
+    let combinator = instr_reference( opcode );
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct SelectTCont0;
-type SelectTCont0Type<'a, 'b> = &'b u64;
-type SelectTCont0SType<'a, 'x> = &'x u64;
-type SelectTCont0Input<'a, 'b, 'x> = POrSType<SelectTCont0Type<'a, 'b>, SelectTCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<SelectTCont0Input<'a, 'b, 'x>> for SelectTCont0 {
-    type Output = RepeatN<ValtypeCombinator>;
-
-    open spec fn requires(&self, deps: SelectTCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: SelectTCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_select_t_cont0(deps@)
-    }
-
-    fn apply(&self, deps: SelectTCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(valtype(), l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(valtype(), l.ex_into())
-            }
-        }
-    }
-}
-                
 
 pub enum SpecInstrParametric {
     Drop(SpecEmpty),
@@ -6017,13 +6412,13 @@ impl SpecCombinator for SpecInstrParametricCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecInstrParametricCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecInstrParametricCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -6031,11 +6426,11 @@ impl SecureSpecCombinator for SpecInstrParametricCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecInstrParametricCombinatorAlias = Mapped<SpecInstrParametricCombinatorAlias2, InstrParametricMapper>;
@@ -6066,13 +6461,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrParametricCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type InstrParametricCombinatorAlias = Mapped<InstrParametricCombinator2, InstrParametricMapper>;
 
 
@@ -6081,22 +6476,27 @@ pub open spec fn spec_instr_parametric(opcode: u8) -> SpecInstrParametricCombina
 }
 
 pub fn instr_parametric<'a>(opcode: u8) -> (o: InstrParametricCombinator)
+    requires
+        spec_instr_bytecode().wf(opcode@),
+
     ensures o@ == spec_instr_parametric(opcode@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = InstrParametricCombinator(Mapped { inner: InstrParametricCombinator2(Choice::new(Cond { cond: opcode == InstrBytecode::Drop, inner: empty() }, InstrParametricCombinator1(Choice::new(Cond { cond: opcode == InstrBytecode::Select, inner: empty() }, Cond { cond: opcode == InstrBytecode::SelectT, inner: select_t() })))), mapper: InstrParametricMapper });
-    assert({
-        &&& combinator@ == spec_instr_parametric(opcode@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_instr_parametric(opcode@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
 pub fn parse_instr_parametric<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrParametricCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         res matches Ok((n, v)) ==> spec_instr_parametric(opcode@).spec_parse(input@) == Some((n as int, v@)),
         spec_instr_parametric(opcode@).spec_parse(input@) matches Some((n, v))
@@ -6112,6 +6512,8 @@ pub fn serialize_instr_parametric<'a>(v: <InstrParametricCombinator as Combinato
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_instr_parametric(opcode@).wf(v@),
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -6128,6 +6530,8 @@ pub fn instr_parametric_len<'a>(v: <InstrParametricCombinator as Combinator<'a,
     requires
         spec_instr_parametric(opcode@).wf(v@),
         spec_instr_parametric(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         serialize_len == spec_instr_parametric(opcode@).spec_serialize(v@).len(),
 {
@@ -6243,13 +6647,13 @@ impl SpecCombinator for SpecInstrTableCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecInstrTableCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecInstrTableCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -6257,11 +6661,11 @@ impl SecureSpecCombinator for SpecInstrTableCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecInstrTableCombinatorAlias = Mapped<SpecInstrTableCombinatorAlias1, InstrTableMapper>;
@@ -6284,13 +6688,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrTableCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type InstrTableCombinatorAlias = Mapped<InstrTableCombinator1, InstrTableMapper>;
 
 
@@ -6299,22 +6703,27 @@ pub open spec fn spec_instr_table(opcode: u8) -> SpecInstrTableCombinator {
 }
 
 pub fn instr_table<'a>(opcode: u8) -> (o: InstrTableCombinator)
+    requires
+        spec_instr_bytecode().wf(opcode@),
+
     ensures o@ == spec_instr_table(opcode@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = InstrTableCombinator(Mapped { inner: InstrTableCombinator1(Choice::new(Cond { cond: opcode == InstrBytecode::TableGet, inner: tableidx() }, Cond { cond: opcode == InstrBytecode::TableSet, inner: tableidx() })), mapper: InstrTableMapper });
-    assert({
-        &&& combinator@ == spec_instr_table(opcode@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_instr_table(opcode@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
 pub fn parse_instr_table<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrTableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         res matches Ok((n, v)) ==> spec_instr_table(opcode@).spec_parse(input@) == Some((n as int, v@)),
         spec_instr_table(opcode@).spec_parse(input@) matches Some((n, v))
@@ -6330,6 +6739,8 @@ pub fn serialize_instr_table<'a>(v: <InstrTableCombinator as Combinator<'a, &'a
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_instr_table(opcode@).wf(v@),
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -6346,6 +6757,8 @@ pub fn instr_table_len<'a>(v: <InstrTableCombinator as Combinator<'a, &'a [u8],
     requires
         spec_instr_table(opcode@).wf(v@),
         spec_instr_table(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         serialize_len == spec_instr_table(opcode@).spec_serialize(v@).len(),
 {
@@ -6366,13 +6779,13 @@ impl SpecCombinator for SpecF32Combinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecF32Combinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecF32CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -6380,11 +6793,11 @@ impl SecureSpecCombinator for SpecF32Combinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecF32CombinatorAlias = bytes::Fixed<4>;
@@ -6400,13 +6813,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for F32Combinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type F32CombinatorAlias = bytes::Fixed<4>;
 
 
@@ -6421,11 +6834,11 @@ pub fn f32<'a>() -> (o: F32Combinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = F32Combinator(bytes::Fixed::<4>);
-    assert({
-        &&& combinator@ == spec_f32()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_f32()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -6484,13 +6897,13 @@ impl SpecCombinator for SpecF64Combinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecF64Combinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecF64CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -6498,11 +6911,11 @@ impl SecureSpecCombinator for SpecF64Combinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecF64CombinatorAlias = bytes::Fixed<8>;
@@ -6518,13 +6931,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for F64Combinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type F64CombinatorAlias = bytes::Fixed<8>;
 
 
@@ -6539,11 +6952,11 @@ pub fn f64<'a>() -> (o: F64Combinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = F64Combinator(bytes::Fixed::<8>);
-    assert({
-        &&& combinator@ == spec_f64()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_f64()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -6721,13 +7134,13 @@ impl SpecCombinator for SpecInstrNumericCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecInstrNumericCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecInstrNumericCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -6735,11 +7148,11 @@ impl SecureSpecCombinator for SpecInstrNumericCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecInstrNumericCombinatorAlias = Mapped<SpecInstrNumericCombinatorAlias4, InstrNumericMapper>;
@@ -6786,13 +7199,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrNumericCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type InstrNumericCombinatorAlias = Mapped<InstrNumericCombinator4, InstrNumericMapper>;
 
 
@@ -6801,22 +7214,27 @@ pub open spec fn spec_instr_numeric(opcode: u8) -> SpecInstrNumericCombinator {
 }
 
 pub fn instr_numeric<'a>(opcode: u8) -> (o: InstrNumericCombinator)
+    requires
+        spec_instr_bytecode().wf(opcode@),
+
     ensures o@ == spec_instr_numeric(opcode@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = InstrNumericCombinator(Mapped { inner: InstrNumericCombinator4(Choice::new(Cond { cond: opcode == InstrBytecode::I32Const, inner: UnsignedLEB128 }, InstrNumericCombinator3(Choice::new(Cond { cond: opcode == InstrBytecode::I64Const, inner: UnsignedLEB128 }, InstrNumericCombinator2(Choice::new(Cond { cond: opcode == InstrBytecode::F32Const, inner: f32() }, InstrNumericCombinator1(Choice::new(Cond { cond: opcode == InstrBytecode::F64Const, inner: f64() }, Cond { cond: !(opcode == InstrBytecode::I32Const || opcode == InstrBytecode::I64Const || opcode == InstrBytecode::F32Const || opcode == InstrBytecode::F64Const), inner: empty() })))))))), mapper: InstrNumericMapper });
-    assert({
-        &&& combinator@ == spec_instr_numeric(opcode@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_instr_numeric(opcode@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
 pub fn parse_instr_numeric<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrNumericCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         res matches Ok((n, v)) ==> spec_instr_numeric(opcode@).spec_parse(input@) == Some((n as int, v@)),
         spec_instr_numeric(opcode@).spec_parse(input@) matches Some((n, v))
@@ -6832,6 +7250,8 @@ pub fn serialize_instr_numeric<'a>(v: <InstrNumericCombinator as Combinator<'a,
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_instr_numeric(opcode@).wf(v@),
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -6848,6 +7268,8 @@ pub fn instr_numeric_len<'a>(v: <InstrNumericCombinator as Combinator<'a, &'a [u
     requires
         spec_instr_numeric(opcode@).wf(v@),
         spec_instr_numeric(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         serialize_len == spec_instr_numeric(opcode@).spec_serialize(v@).len(),
 {
@@ -6868,13 +7290,13 @@ impl SpecCombinator for SpecElemidxCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecElemidxCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecElemidxCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -6882,11 +7304,11 @@ impl SecureSpecCombinator for SpecElemidxCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecElemidxCombinatorAlias = UnsignedLEB128;
@@ -6902,13 +7324,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ElemidxCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type ElemidxCombinatorAlias = UnsignedLEB128;
 
 
@@ -6923,11 +7345,11 @@ pub fn elemidx<'a>() -> (o: ElemidxCombinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = ElemidxCombinator(UnsignedLEB128);
-    assert({
-        &&& combinator@ == spec_elemidx()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_elemidx()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -7060,13 +7482,13 @@ impl SpecCombinator for SpecTableInitCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecTableInitCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecTableInitCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -7074,11 +7496,11 @@ impl SecureSpecCombinator for SpecTableInitCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecTableInitCombinatorAlias = Mapped<SpecTableInitCombinatorAlias1, TableInitMapper>;
@@ -7101,13 +7523,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TableInitCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type TableInitCombinatorAlias = Mapped<TableInitCombinator1, TableInitMapper>;
 
 
@@ -7130,11 +7552,11 @@ pub fn table_init<'a>() -> (o: TableInitCombinator)
         inner: TableInitCombinator1((elemidx(), tableidx())),
         mapper: TableInitMapper,
     });
-    assert({
-        &&& combinator@ == spec_table_init()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_table_init()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -7193,13 +7615,13 @@ impl SpecCombinator for SpecElemDropCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecElemDropCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecElemDropCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -7207,11 +7629,11 @@ impl SecureSpecCombinator for SpecElemDropCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecElemDropCombinatorAlias = SpecElemidxCombinator;
@@ -7227,13 +7649,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ElemDropCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type ElemDropCombinatorAlias = ElemidxCombinator;
 
 
@@ -7248,11 +7670,11 @@ pub fn elem_drop<'a>() -> (o: ElemDropCombinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = ElemDropCombinator(elemidx());
-    assert({
-        &&& combinator@ == spec_elem_drop()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_elem_drop()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -7385,13 +7807,13 @@ impl SpecCombinator for SpecTableCopyCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecTableCopyCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecTableCopyCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -7399,11 +7821,11 @@ impl SecureSpecCombinator for SpecTableCopyCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecTableCopyCombinatorAlias = Mapped<SpecTableCopyCombinatorAlias1, TableCopyMapper>;
@@ -7426,13 +7848,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TableCopyCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type TableCopyCombinatorAlias = Mapped<TableCopyCombinator1, TableCopyMapper>;
 
 
@@ -7455,11 +7877,11 @@ pub fn table_copy<'a>() -> (o: TableCopyCombinator)
         inner: TableCopyCombinator1((tableidx(), tableidx())),
         mapper: TableCopyMapper,
     });
-    assert({
-        &&& combinator@ == spec_table_copy()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_table_copy()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -7518,13 +7940,13 @@ impl SpecCombinator for SpecTableGrowCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecTableGrowCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecTableGrowCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -7532,11 +7954,11 @@ impl SecureSpecCombinator for SpecTableGrowCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecTableGrowCombinatorAlias = SpecTableidxCombinator;
@@ -7552,13 +7974,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TableGrowCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type TableGrowCombinatorAlias = TableidxCombinator;
 
 
@@ -7573,11 +7995,11 @@ pub fn table_grow<'a>() -> (o: TableGrowCombinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = TableGrowCombinator(tableidx());
-    assert({
-        &&& combinator@ == spec_table_grow()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_table_grow()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -7636,13 +8058,13 @@ impl SpecCombinator for SpecTableSizeCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecTableSizeCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecTableSizeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -7650,11 +8072,11 @@ impl SecureSpecCombinator for SpecTableSizeCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecTableSizeCombinatorAlias = SpecTableidxCombinator;
@@ -7670,13 +8092,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TableSizeCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type TableSizeCombinatorAlias = TableidxCombinator;
 
 
@@ -7691,11 +8113,11 @@ pub fn table_size<'a>() -> (o: TableSizeCombinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = TableSizeCombinator(tableidx());
-    assert({
-        &&& combinator@ == spec_table_size()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_table_size()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -7721,140 +8143,22 @@ pub fn serialize_table_size<'a>(v: <TableSizeCombinator as Combinator<'a, &'a [u
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_table_size().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_table_size().spec_serialize(v@))
-        },
-{
-    let combinator = table_size();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
-}
-
-pub fn table_size_len<'a>(v: <TableSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_table_size().wf(v@),
-        spec_table_size().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_table_size().spec_serialize(v@).len(),
-{
-    let combinator = table_size();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
-}
-
-                
-pub type SpecTableFill = SpecTableidx;
-pub type TableFill = Tableidx;
-pub type TableFillRef<'a> = &'a Tableidx;
-
-
-pub struct SpecTableFillCombinator(pub SpecTableFillCombinatorAlias);
-
-impl SpecCombinator for SpecTableFillCombinator {
-    type Type = SpecTableFill;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecTableFillCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTableFillCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
-}
-pub type SpecTableFillCombinatorAlias = SpecTableidxCombinator;
-
-pub struct TableFillCombinator(pub TableFillCombinatorAlias);
-
-impl View for TableFillCombinator {
-    type V = SpecTableFillCombinator;
-    open spec fn view(&self) -> Self::V { SpecTableFillCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TableFillCombinator {
-    type Type = TableFill;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TableFillCombinatorAlias = TableidxCombinator;
-
-
-pub open spec fn spec_table_fill() -> SpecTableFillCombinator {
-    SpecTableFillCombinator(spec_tableidx())
-}
-
-                
-pub fn table_fill<'a>() -> (o: TableFillCombinator)
-    ensures o@ == spec_table_fill(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = TableFillCombinator(tableidx());
-    assert({
-        &&& combinator@ == spec_table_fill()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
-
-pub fn parse_table_fill<'a>(input: &'a [u8]) -> (res: PResult<<TableFillCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_table_fill().spec_parse(input@) == Some((n as int, v@)),
-        spec_table_fill().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_table_fill().spec_parse(input@) is None,
-        spec_table_fill().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = table_fill();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
-}
-
-pub fn serialize_table_fill<'a>(v: <TableFillCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_table_fill().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_table_fill().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_table_fill().spec_serialize(v@))
+            &&& n == spec_table_size().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_table_size().spec_serialize(v@))
         },
 {
-    let combinator = table_fill();
+    let combinator = table_size();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn table_fill_len<'a>(v: <TableFillCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn table_size_len<'a>(v: <TableSizeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_table_fill().wf(v@),
-        spec_table_fill().spec_serialize(v@).len() <= usize::MAX,
+        spec_table_size().wf(v@),
+        spec_table_size().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_table_fill().spec_serialize(v@).len(),
+        serialize_len == spec_table_size().spec_serialize(v@).len(),
 {
-    let combinator = table_fill();
+    let combinator = table_size();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
@@ -7872,13 +8176,13 @@ impl SpecCombinator for SpecDataidxCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecDataidxCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecDataidxCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -7886,11 +8190,11 @@ impl SecureSpecCombinator for SpecDataidxCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecDataidxCombinatorAlias = UnsignedLEB128;
@@ -7906,13 +8210,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DataidxCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type DataidxCombinatorAlias = UnsignedLEB128;
 
 
@@ -7927,11 +8231,11 @@ pub fn dataidx<'a>() -> (o: DataidxCombinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = DataidxCombinator(UnsignedLEB128);
-    assert({
-        &&& combinator@ == spec_dataidx()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_dataidx()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -7992,13 +8296,13 @@ impl SpecCombinator for SpecMemoryInitCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecMemoryInitCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecMemoryInitCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -8006,11 +8310,11 @@ impl SecureSpecCombinator for SpecMemoryInitCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecMemoryInitCombinatorAlias = Terminated<SpecDataidxCombinator, Tag<U8, u8>>;
@@ -8027,13 +8331,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemoryInitCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type MemoryInitCombinatorAlias = Terminated<DataidxCombinator, Tag<U8, u8>>;
 
 
@@ -8048,11 +8352,11 @@ pub fn memory_init<'a>() -> (o: MemoryInitCombinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = MemoryInitCombinator(Terminated(dataidx(), Tag::new(U8, MemoryInit_0_BACK_CONST)));
-    assert({
-        &&& combinator@ == spec_memory_init()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_memory_init()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -8111,13 +8415,13 @@ impl SpecCombinator for SpecDataDropCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecDataDropCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecDataDropCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -8125,11 +8429,11 @@ impl SecureSpecCombinator for SpecDataDropCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecDataDropCombinatorAlias = SpecDataidxCombinator;
@@ -8145,13 +8449,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DataDropCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type DataDropCombinatorAlias = DataidxCombinator;
 
 
@@ -8166,11 +8470,11 @@ pub fn data_drop<'a>() -> (o: DataDropCombinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = DataDropCombinator(dataidx());
-    assert({
-        &&& combinator@ == spec_data_drop()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_data_drop()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -8300,13 +8604,13 @@ impl SpecCombinator for SpecMemoryCopyCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecMemoryCopyCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecMemoryCopyCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -8314,11 +8618,11 @@ impl SecureSpecCombinator for SpecMemoryCopyCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecMemoryCopyCombinatorAlias = Mapped<Refined<bytes::Fixed<2>, TagPred<Seq<u8>>>, MemoryCopyMapper>;
@@ -8341,13 +8645,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemoryCopyCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type MemoryCopyCombinatorAlias = Mapped<Refined<bytes::Fixed<2>, TagPred<[u8; 2]>>, MemoryCopyMapper>;
 
 
@@ -8370,11 +8674,11 @@ pub fn memory_copy<'a>() -> (o: MemoryCopyCombinator)
         inner: Refined { inner: bytes::Fixed::<2>, predicate: TagPred(MEMORYCOPYRESERVED_CONST) },
         mapper: MemoryCopyMapper,
     });
-    assert({
-        &&& combinator@ == spec_memory_copy()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_memory_copy()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -8505,13 +8809,13 @@ impl SpecCombinator for SpecMemoryFillCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecMemoryFillCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecMemoryFillCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -8519,11 +8823,11 @@ impl SecureSpecCombinator for SpecMemoryFillCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecMemoryFillCombinatorAlias = Mapped<Refined<U8, TagPred<u8>>, MemoryFillMapper>;
@@ -8539,13 +8843,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemoryFillCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type MemoryFillCombinatorAlias = Mapped<Refined<U8, TagPred<u8>>, MemoryFillMapper>;
 
 
@@ -8568,11 +8872,11 @@ pub fn memory_fill<'a>() -> (o: MemoryFillCombinator)
         inner: Refined { inner: U8, predicate: TagPred(MEMORYFILLRESERVED_CONST) },
         mapper: MemoryFillMapper,
     });
-    assert({
-        &&& combinator@ == spec_memory_fill()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_memory_fill()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -8798,13 +9102,13 @@ impl SpecCombinator for SpecInstrWithFcRestCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecInstrWithFcRestCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecInstrWithFcRestCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -8812,11 +9116,11 @@ impl SecureSpecCombinator for SpecInstrWithFcRestCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecInstrWithFcRestCombinatorAlias = Mapped<SpecInstrWithFcRestCombinatorAlias10, InstrWithFcRestMapper>;
@@ -8911,13 +9215,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrWithFcRestCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type InstrWithFcRestCombinatorAlias = Mapped<InstrWithFcRestCombinator10, InstrWithFcRestMapper>;
 
 
@@ -8926,22 +9230,24 @@ pub open spec fn spec_instr_with_fc_rest(tag: u64) -> SpecInstrWithFcRestCombina
 }
 
 pub fn instr_with_fc_rest<'a>(tag: u64) -> (o: InstrWithFcRestCombinator)
+
     ensures o@ == spec_instr_with_fc_rest(tag@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = InstrWithFcRestCombinator(Mapped { inner: InstrWithFcRestCombinator10(Choice::new(Cond { cond: tag == 12, inner: table_init() }, InstrWithFcRestCombinator9(Choice::new(Cond { cond: tag == 13, inner: elem_drop() }, InstrWithFcRestCombinator8(Choice::new(Cond { cond: tag == 14, inner: table_copy() }, InstrWithFcRestCombinator7(Choice::new(Cond { cond: tag == 15, inner: table_grow() }, InstrWithFcRestCombinator6(Choice::new(Cond { cond: tag == 16, inner: table_size() }, InstrWithFcRestCombinator5(Choice::new(Cond { cond: tag == 17, inner: table_fill() }, InstrWithFcRestCombinator4(Choice::new(Cond { cond: tag == 8, inner: memory_init() }, InstrWithFcRestCombinator3(Choice::new(Cond { cond: tag == 9, inner: data_drop() }, InstrWithFcRestCombinator2(Choice::new(Cond { cond: tag == 10, inner: memory_copy() }, InstrWithFcRestCombinator1(Choice::new(Cond { cond: tag == 11, inner: memory_fill() }, Cond { cond: !(tag == 12 || tag == 13 || tag == 14 || tag == 15 || tag == 16 || tag == 17 || tag == 8 || tag == 9 || tag == 10 || tag == 11), inner: empty() })))))))))))))))))))), mapper: InstrWithFcRestMapper });
-    assert({
-        &&& combinator@ == spec_instr_with_fc_rest(tag@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_instr_with_fc_rest(tag@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
 pub fn parse_instr_with_fc_rest<'a>(input: &'a [u8], tag: u64) -> (res: PResult<<InstrWithFcRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
         res matches Ok((n, v)) ==> spec_instr_with_fc_rest(tag@).spec_parse(input@) == Some((n as int, v@)),
         spec_instr_with_fc_rest(tag@).spec_parse(input@) matches Some((n, v))
@@ -8957,6 +9263,7 @@ pub fn serialize_instr_with_fc_rest<'a>(v: <InstrWithFcRestCombinator as Combina
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_instr_with_fc_rest(tag@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -8973,6 +9280,7 @@ pub fn instr_with_fc_rest_len<'a>(v: <InstrWithFcRestCombinator as Combinator<'a
     requires
         spec_instr_with_fc_rest(tag@).wf(v@),
         spec_instr_with_fc_rest(tag@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
         serialize_len == spec_instr_with_fc_rest(tag@).spec_serialize(v@).len(),
 {
@@ -9067,13 +9375,13 @@ impl SpecCombinator for SpecInstrWithFcCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecInstrWithFcCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecInstrWithFcCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -9081,11 +9389,11 @@ impl SecureSpecCombinator for SpecInstrWithFcCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecInstrWithFcCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, SpecInstrWithFcRestCombinator>, InstrWithFcMapper>;
@@ -9101,13 +9409,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrWithFcCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type InstrWithFcCombinatorAlias = Mapped<Pair<UnsignedLEB128, InstrWithFcRestCombinator, InstrWithFcCont0>, InstrWithFcMapper>;
 
 
@@ -9145,11 +9453,11 @@ pub fn instr_with_fc<'a>() -> (o: InstrWithFcCombinator)
         inner: Pair::new(UnsignedLEB128, InstrWithFcCont0),
         mapper: InstrWithFcMapper,
     });
-    assert({
-        &&& combinator@ == spec_instr_with_fc()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_instr_with_fc()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -9201,16 +9509,20 @@ type InstrWithFcCont0Input<'a, 'b, 'x> = POrSType<InstrWithFcCont0Type<'a, 'b>,
 impl<'a, 'b, 'x> Continuation<InstrWithFcCont0Input<'a, 'b, 'x>> for InstrWithFcCont0 {
     type Output = InstrWithFcRestCombinator;
 
-    open spec fn requires(&self, deps: InstrWithFcCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: InstrWithFcCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: InstrWithFcCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_instr_with_fc_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_instr_with_fc_cont0(deps@)
     }
 
     fn apply(&self, deps: InstrWithFcCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let tag = *deps;
+                let tag = deps;
+                let tag = *tag;
                 instr_with_fc_rest(tag)
             }
             POrSType::S(deps) => {
@@ -9235,13 +9547,13 @@ impl SpecCombinator for SpecLaneidxCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecLaneidxCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecLaneidxCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -9249,11 +9561,11 @@ impl SecureSpecCombinator for SpecLaneidxCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecLaneidxCombinatorAlias = U8;
@@ -9269,13 +9581,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LaneidxCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type LaneidxCombinatorAlias = U8;
 
 
@@ -9290,11 +9602,11 @@ pub fn laneidx<'a>() -> (o: LaneidxCombinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = LaneidxCombinator(U8);
-    assert({
-        &&& combinator@ == spec_laneidx()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_laneidx()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -9427,13 +9739,13 @@ impl SpecCombinator for SpecV128LaneCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecV128LaneCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecV128LaneCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -9441,11 +9753,11 @@ impl SecureSpecCombinator for SpecV128LaneCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecV128LaneCombinatorAlias = Mapped<SpecV128LaneCombinatorAlias1, V128LaneMapper>;
@@ -9468,13 +9780,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for V128LaneCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type V128LaneCombinatorAlias = Mapped<V128LaneCombinator1, V128LaneMapper>;
 
 
@@ -9497,11 +9809,11 @@ pub fn v128_lane<'a>() -> (o: V128LaneCombinator)
         inner: V128LaneCombinator1((memarg(), laneidx())),
         mapper: V128LaneMapper,
     });
-    assert({
-        &&& combinator@ == spec_v128_lane()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_v128_lane()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -9560,13 +9872,13 @@ impl SpecCombinator for SpecV128ConstCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecV128ConstCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecV128ConstCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -9574,11 +9886,11 @@ impl SecureSpecCombinator for SpecV128ConstCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecV128ConstCombinatorAlias = bytes::Fixed<16>;
@@ -9594,13 +9906,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for V128ConstCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type V128ConstCombinatorAlias = bytes::Fixed<16>;
 
 
@@ -9615,11 +9927,11 @@ pub fn v128_const<'a>() -> (o: V128ConstCombinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = V128ConstCombinator(bytes::Fixed::<16>);
-    assert({
-        &&& combinator@ == spec_v128_const()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_v128_const()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -9678,13 +9990,13 @@ impl SpecCombinator for SpecShuffleCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecShuffleCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecShuffleCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -9692,11 +10004,11 @@ impl SecureSpecCombinator for SpecShuffleCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecShuffleCombinatorAlias = RepeatN<SpecLaneidxCombinator>;
@@ -9712,18 +10024,18 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ShuffleCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type ShuffleCombinatorAlias = RepeatN<LaneidxCombinator>;
 
 
 pub open spec fn spec_shuffle() -> SpecShuffleCombinator {
-    SpecShuffleCombinator(RepeatN(spec_laneidx(), 16))
+    SpecShuffleCombinator(RepeatN(spec_laneidx(), (16) as usize))
 }
 
                 
@@ -9732,12 +10044,12 @@ pub fn shuffle<'a>() -> (o: ShuffleCombinator)
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ShuffleCombinator(RepeatN(laneidx(), 16));
-    assert({
-        &&& combinator@ == spec_shuffle()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ShuffleCombinator(RepeatN(laneidx(), (16) as usize));
+    // assert({
+    //     &&& combinator@ == spec_shuffle()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -9939,13 +10251,13 @@ impl SpecCombinator for SpecInstrWithFdRestCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecInstrWithFdRestCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecInstrWithFdRestCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -9953,11 +10265,11 @@ impl SecureSpecCombinator for SpecInstrWithFdRestCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecInstrWithFdRestCombinatorAlias = Mapped<SpecInstrWithFdRestCombinatorAlias7, InstrWithFdRestMapper>;
@@ -10028,13 +10340,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrWithFdRestCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type InstrWithFdRestCombinatorAlias = Mapped<InstrWithFdRestCombinator7, InstrWithFdRestMapper>;
 
 
@@ -10043,22 +10355,24 @@ pub open spec fn spec_instr_with_fd_rest(tag: u64) -> SpecInstrWithFdRestCombina
 }
 
 pub fn instr_with_fd_rest<'a>(tag: u64) -> (o: InstrWithFdRestCombinator)
+
     ensures o@ == spec_instr_with_fd_rest(tag@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = InstrWithFdRestCombinator(Mapped { inner: InstrWithFdRestCombinator7(Choice::new(Cond { cond: tag >= 0 && tag <= 11, inner: memarg() }, InstrWithFdRestCombinator6(Choice::new(Cond { cond: tag == 92, inner: memarg() }, InstrWithFdRestCombinator5(Choice::new(Cond { cond: tag == 93, inner: memarg() }, InstrWithFdRestCombinator4(Choice::new(Cond { cond: tag >= 84 && tag <= 91, inner: v128_lane() }, InstrWithFdRestCombinator3(Choice::new(Cond { cond: tag == 12, inner: v128_const() }, InstrWithFdRestCombinator2(Choice::new(Cond { cond: tag == 13, inner: shuffle() }, InstrWithFdRestCombinator1(Choice::new(Cond { cond: tag >= 21 && tag <= 34, inner: laneidx() }, Cond { cond: !(tag >= 0 && tag <= 11 || tag == 92 || tag == 93 || tag >= 84 && tag <= 91 || tag == 12 || tag == 13 || tag >= 21 && tag <= 34), inner: empty() })))))))))))))), mapper: InstrWithFdRestMapper });
-    assert({
-        &&& combinator@ == spec_instr_with_fd_rest(tag@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_instr_with_fd_rest(tag@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
 pub fn parse_instr_with_fd_rest<'a>(input: &'a [u8], tag: u64) -> (res: PResult<<InstrWithFdRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+
     ensures
         res matches Ok((n, v)) ==> spec_instr_with_fd_rest(tag@).spec_parse(input@) == Some((n as int, v@)),
         spec_instr_with_fd_rest(tag@).spec_parse(input@) matches Some((n, v))
@@ -10074,6 +10388,7 @@ pub fn serialize_instr_with_fd_rest<'a>(v: <InstrWithFdRestCombinator as Combina
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_instr_with_fd_rest(tag@).wf(v@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -10090,6 +10405,7 @@ pub fn instr_with_fd_rest_len<'a>(v: <InstrWithFdRestCombinator as Combinator<'a
     requires
         spec_instr_with_fd_rest(tag@).wf(v@),
         spec_instr_with_fd_rest(tag@).spec_serialize(v@).len() <= usize::MAX,
+
     ensures
         serialize_len == spec_instr_with_fd_rest(tag@).spec_serialize(v@).len(),
 {
@@ -10184,13 +10500,13 @@ impl SpecCombinator for SpecInstrWithFdCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecInstrWithFdCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecInstrWithFdCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -10198,11 +10514,11 @@ impl SecureSpecCombinator for SpecInstrWithFdCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecInstrWithFdCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, SpecInstrWithFdRestCombinator>, InstrWithFdMapper>;
@@ -10218,13 +10534,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrWithFdCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type InstrWithFdCombinatorAlias = Mapped<Pair<UnsignedLEB128, InstrWithFdRestCombinator, InstrWithFdCont0>, InstrWithFdMapper>;
 
 
@@ -10262,11 +10578,11 @@ pub fn instr_with_fd<'a>() -> (o: InstrWithFdCombinator)
         inner: Pair::new(UnsignedLEB128, InstrWithFdCont0),
         mapper: InstrWithFdMapper,
     });
-    assert({
-        &&& combinator@ == spec_instr_with_fd()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_instr_with_fd()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -10318,16 +10634,20 @@ type InstrWithFdCont0Input<'a, 'b, 'x> = POrSType<InstrWithFdCont0Type<'a, 'b>,
 impl<'a, 'b, 'x> Continuation<InstrWithFdCont0Input<'a, 'b, 'x>> for InstrWithFdCont0 {
     type Output = InstrWithFdRestCombinator;
 
-    open spec fn requires(&self, deps: InstrWithFdCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: InstrWithFdCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: InstrWithFdCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_instr_with_fd_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_instr_with_fd_cont0(deps@)
     }
 
     fn apply(&self, deps: InstrWithFdCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let tag = *deps;
+                let tag = deps;
+                let tag = *tag;
                 instr_with_fd_rest(tag)
             }
             POrSType::S(deps) => {
@@ -10519,13 +10839,13 @@ impl SpecCombinator for SpecInstrRestCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecInstrRestCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecInstrRestCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -10533,11 +10853,11 @@ impl SecureSpecCombinator for SpecInstrRestCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecInstrRestCombinatorAlias = Mapped<SpecInstrRestCombinatorAlias10, InstrRestMapper>;
@@ -10632,13 +10952,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrRestCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type InstrRestCombinatorAlias = Mapped<InstrRestCombinator10, InstrRestMapper>;
 
 
@@ -10647,22 +10967,27 @@ pub open spec fn spec_instr_rest(opcode: u8) -> SpecInstrRestCombinator {
 }
 
 pub fn instr_rest<'a>(opcode: u8) -> (o: InstrRestCombinator)
+    requires
+        spec_instr_bytecode().wf(opcode@),
+
     ensures o@ == spec_instr_rest(opcode@),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = InstrRestCombinator(Mapped { inner: InstrRestCombinator10(Choice::new(Cond { cond: opcode >= 32 && opcode <= 36, inner: instr_variable(opcode) }, InstrRestCombinator9(Choice::new(Cond { cond: opcode >= 11 && opcode <= 17, inner: instr_control2(opcode) }, InstrRestCombinator8(Choice::new(Cond { cond: opcode >= 0 && opcode <= 5, inner: instr_control1(opcode) }, InstrRestCombinator7(Choice::new(Cond { cond: opcode >= 40 && opcode <= 64, inner: instr_memory(opcode) }, InstrRestCombinator6(Choice::new(Cond { cond: opcode >= 208 && opcode <= 210, inner: instr_reference(opcode) }, InstrRestCombinator5(Choice::new(Cond { cond: opcode >= 26 && opcode <= 28, inner: instr_parametric(opcode) }, InstrRestCombinator4(Choice::new(Cond { cond: opcode >= 37 && opcode <= 38, inner: instr_table(opcode) }, InstrRestCombinator3(Choice::new(Cond { cond: opcode >= 65 && opcode <= 68, inner: instr_numeric(opcode) }, InstrRestCombinator2(Choice::new(Cond { cond: opcode == 252, inner: instr_with_fc() }, InstrRestCombinator1(Choice::new(Cond { cond: opcode == 253, inner: instr_with_fd() }, Cond { cond: !(opcode >= 32 && opcode <= 36 || opcode >= 11 && opcode <= 17 || opcode >= 0 && opcode <= 5 || opcode >= 40 && opcode <= 64 || opcode >= 208 && opcode <= 210 || opcode >= 26 && opcode <= 28 || opcode >= 37 && opcode <= 38 || opcode >= 65 && opcode <= 68 || opcode == 252 || opcode == 253), inner: empty() })))))))))))))))))))), mapper: InstrRestMapper });
-    assert({
-        &&& combinator@ == spec_instr_rest(opcode@)
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_instr_rest(opcode@)
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
 pub fn parse_instr_rest<'a>(input: &'a [u8], opcode: u8) -> (res: PResult<<InstrRestCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         res matches Ok((n, v)) ==> spec_instr_rest(opcode@).spec_parse(input@) == Some((n as int, v@)),
         spec_instr_rest(opcode@).spec_parse(input@) matches Some((n, v))
@@ -10678,6 +11003,8 @@ pub fn serialize_instr_rest<'a>(v: <InstrRestCombinator as Combinator<'a, &'a [u
     requires
         pos <= old(data)@.len() <= usize::MAX,
         spec_instr_rest(opcode@).wf(v@),
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
@@ -10694,6 +11021,8 @@ pub fn instr_rest_len<'a>(v: <InstrRestCombinator as Combinator<'a, &'a [u8], Ve
     requires
         spec_instr_rest(opcode@).wf(v@),
         spec_instr_rest(opcode@).spec_serialize(v@).len() <= usize::MAX,
+        spec_instr_bytecode().wf(opcode@),
+
     ensures
         serialize_len == spec_instr_rest(opcode@).spec_serialize(v@).len(),
 {
@@ -10788,13 +11117,13 @@ impl SpecCombinator for SpecInstrCombinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecInstrCombinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecInstrCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -10802,11 +11131,11 @@ impl SecureSpecCombinator for SpecInstrCombinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecInstrCombinatorAlias = Mapped<SpecPair<SpecInstrBytecodeCombinator, SpecInstrRestCombinator>, InstrMapper>;
@@ -10822,13 +11151,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for InstrCombinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type InstrCombinatorAlias = Mapped<Pair<InstrBytecodeCombinator, InstrRestCombinator, InstrCont0>, InstrMapper>;
 
 
@@ -10866,11 +11195,11 @@ pub fn instr<'a>() -> (o: InstrCombinator)
         inner: Pair::new(instr_bytecode(), InstrCont0),
         mapper: InstrMapper,
     });
-    assert({
-        &&& combinator@ == spec_instr()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_instr()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -10922,16 +11251,20 @@ type InstrCont0Input<'a, 'b, 'x> = POrSType<InstrCont0Type<'a, 'b>, InstrCont0ST
 impl<'a, 'b, 'x> Continuation<InstrCont0Input<'a, 'b, 'x>> for InstrCont0 {
     type Output = InstrRestCombinator;
 
-    open spec fn requires(&self, deps: InstrCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: InstrCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (spec_instr_bytecode()).wf(deps@)
+        }
 
     open spec fn ensures(&self, deps: InstrCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_instr_cont0(deps@)
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_instr_cont0(deps@)
     }
 
     fn apply(&self, deps: InstrCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let opcode = *deps;
+                let opcode = deps;
+                let opcode = *opcode;
                 instr_rest(opcode)
             }
             POrSType::S(deps) => {
@@ -10944,434 +11277,268 @@ impl<'a, 'b, 'x> Continuation<InstrCont0Input<'a, 'b, 'x>> for InstrCont0 {
 }
                 
 
-pub struct SpecExprInner {
-    pub l: u64,
-    pub v: Seq<SpecInstr>,
-}
-
-pub type SpecExprInnerInner = (u64, Seq<SpecInstr>);
-
-
-impl SpecFrom<SpecExprInner> for SpecExprInnerInner {
-    open spec fn spec_from(m: SpecExprInner) -> SpecExprInnerInner {
-        (m.l, m.v)
-    }
-}
-
-impl SpecFrom<SpecExprInnerInner> for SpecExprInner {
-    open spec fn spec_from(m: SpecExprInnerInner) -> SpecExprInner {
-        let (l, v) = m;
-        SpecExprInner { l, v }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct ExprInner<'a> {
-    pub l: u64,
-    pub v: RepeatResult<Instr<'a>>,
-}
-
-impl View for ExprInner<'_> {
-    type V = SpecExprInner;
-
-    open spec fn view(&self) -> Self::V {
-        SpecExprInner {
-            l: self.l@,
-            v: self.v@,
-        }
-    }
+pub struct SpecLimitMin {
+    pub min: u64,
 }
-pub type ExprInnerInner<'a> = (u64, RepeatResult<Instr<'a>>);
 
-pub type ExprInnerInnerRef<'a> = (&'a u64, &'a RepeatResult<Instr<'a>>);
-impl<'a> From<&'a ExprInner<'a>> for ExprInnerInnerRef<'a> {
-    fn ex_from(m: &'a ExprInner) -> ExprInnerInnerRef<'a> {
-        (&m.l, &m.v)
-    }
-}
+pub type SpecLimitMinInner = u64;
 
-impl<'a> From<ExprInnerInner<'a>> for ExprInner<'a> {
-    fn ex_from(m: ExprInnerInner) -> ExprInner {
-        let (l, v) = m;
-        ExprInner { l, v }
-    }
-}
 
-pub struct ExprInnerMapper;
-impl View for ExprInnerMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ExprInnerMapper {
-    type Src = SpecExprInnerInner;
-    type Dst = SpecExprInner;
-}
-impl SpecIsoProof for ExprInnerMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+impl SpecFrom<SpecLimitMin> for SpecLimitMinInner {
+    open spec fn spec_from(m: SpecLimitMin) -> SpecLimitMinInner {
+        m.min
     }
 }
-impl<'a> Iso<'a> for ExprInnerMapper {
-    type Src = ExprInnerInner<'a>;
-    type Dst = ExprInner<'a>;
-    type RefSrc = ExprInnerInnerRef<'a>;
-}
-
-pub struct SpecExprInnerCombinator(pub SpecExprInnerCombinatorAlias);
-
-impl SpecCombinator for SpecExprInnerCombinator {
-    type Type = SpecExprInner;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecExprInnerCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecExprInnerCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
-}
-pub type SpecExprInnerCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecInstrCombinator>>, ExprInnerMapper>;
-
-pub struct ExprInnerCombinator(pub ExprInnerCombinatorAlias);
-
-impl View for ExprInnerCombinator {
-    type V = SpecExprInnerCombinator;
-    open spec fn view(&self) -> Self::V { SpecExprInnerCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExprInnerCombinator {
-    type Type = ExprInner<'a>;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ExprInnerCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<InstrCombinator>, ExprInnerCont0>, ExprInnerMapper>;
-
-
-pub open spec fn spec_expr_inner() -> SpecExprInnerCombinator {
-    SpecExprInnerCombinator(
-    Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_expr_inner_cont0(deps)),
-        mapper: ExprInnerMapper,
-    })
-}
-
-pub open spec fn spec_expr_inner_cont0(deps: u64) -> RepeatN<SpecInstrCombinator> {
-    let l = deps;
-    RepeatN(spec_instr(), l.spec_into())
-}
 
-impl View for ExprInnerCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecInstrCombinator>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_expr_inner_cont0(deps)
-        }
+impl SpecFrom<SpecLimitMinInner> for SpecLimitMin {
+    open spec fn spec_from(m: SpecLimitMinInner) -> SpecLimitMin {
+        let min = m;
+        SpecLimitMin { min }
     }
 }
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-                
-pub fn expr_inner<'a>() -> (o: ExprInnerCombinator)
-    ensures o@ == spec_expr_inner(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = ExprInnerCombinator(
-    Mapped {
-        inner: Pair::new(UnsignedLEB128, ExprInnerCont0),
-        mapper: ExprInnerMapper,
-    });
-    assert({
-        &&& combinator@ == spec_expr_inner()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
-
-pub fn parse_expr_inner<'a>(input: &'a [u8]) -> (res: PResult<<ExprInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_expr_inner().spec_parse(input@) == Some((n as int, v@)),
-        spec_expr_inner().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_expr_inner().spec_parse(input@) is None,
-        spec_expr_inner().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = expr_inner();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
-}
-
-pub fn serialize_expr_inner<'a>(v: <ExprInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_expr_inner().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_expr_inner().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_expr_inner().spec_serialize(v@))
-        },
-{
-    let combinator = expr_inner();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
-}
-
-pub fn expr_inner_len<'a>(v: <ExprInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_expr_inner().wf(v@),
-        spec_expr_inner().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_expr_inner().spec_serialize(v@).len(),
-{
-    let combinator = expr_inner();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+pub struct LimitMin {
+    pub min: u64,
 }
 
-pub struct ExprInnerCont0;
-type ExprInnerCont0Type<'a, 'b> = &'b u64;
-type ExprInnerCont0SType<'a, 'x> = &'x u64;
-type ExprInnerCont0Input<'a, 'b, 'x> = POrSType<ExprInnerCont0Type<'a, 'b>, ExprInnerCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ExprInnerCont0Input<'a, 'b, 'x>> for ExprInnerCont0 {
-    type Output = RepeatN<InstrCombinator>;
-
-    open spec fn requires(&self, deps: ExprInnerCont0Input<'a, 'b, 'x>) -> bool { true }
+impl View for LimitMin {
+    type V = SpecLimitMin;
 
-    open spec fn ensures(&self, deps: ExprInnerCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_expr_inner_cont0(deps@)
+    open spec fn view(&self) -> Self::V {
+        SpecLimitMin {
+            min: self.min@,
+        }
     }
+}
+pub type LimitMinInner = u64;
 
-    fn apply(&self, deps: ExprInnerCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(instr(), l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(instr(), l.ex_into())
-            }
-        }
+pub type LimitMinInnerRef<'a> = &'a u64;
+impl<'a> From<&'a LimitMin> for LimitMinInnerRef<'a> {
+    fn ex_from(m: &'a LimitMin) -> LimitMinInnerRef<'a> {
+        &m.min
     }
 }
-                
-pub type SpecExpr = SpecExprInner;
-pub type Expr<'a> = ExprInner<'a>;
-pub type ExprRef<'a> = &'a ExprInner<'a>;
 
+impl From<LimitMinInner> for LimitMin {
+    fn ex_from(m: LimitMinInner) -> LimitMin {
+        let min = m;
+        LimitMin { min }
+    }
+}
 
-pub const Expr_0_BACK_CONST: u8 = 11;
+pub struct LimitMinMapper;
+impl View for LimitMinMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for LimitMinMapper {
+    type Src = SpecLimitMinInner;
+    type Dst = SpecLimitMin;
+}
+impl SpecIsoProof for LimitMinMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for LimitMinMapper {
+    type Src = LimitMinInner;
+    type Dst = LimitMin;
+    type RefSrc = LimitMinInnerRef<'a>;
+}
 
-pub struct SpecExprCombinator(pub SpecExprCombinatorAlias);
+pub struct SpecLimitMinCombinator(pub SpecLimitMinCombinatorAlias);
 
-impl SpecCombinator for SpecExprCombinator {
-    type Type = SpecExpr;
+impl SpecCombinator for SpecLimitMinCombinator {
+    type Type = SpecLimitMin;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecExprCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecExprCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecLimitMinCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecLimitMinCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecExprCombinatorAlias = Terminated<SpecExprInnerCombinator, Tag<U8, u8>>;
-
+pub type SpecLimitMinCombinatorAlias = Mapped<UnsignedLEB128, LimitMinMapper>;
 
-pub struct ExprCombinator(pub ExprCombinatorAlias);
+pub struct LimitMinCombinator(pub LimitMinCombinatorAlias);
 
-impl View for ExprCombinator {
-    type V = SpecExprCombinator;
-    open spec fn view(&self) -> Self::V { SpecExprCombinator(self.0@) }
+impl View for LimitMinCombinator {
+    type V = SpecLimitMinCombinator;
+    open spec fn view(&self) -> Self::V { SpecLimitMinCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExprCombinator {
-    type Type = Expr<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LimitMinCombinator {
+    type Type = LimitMin;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ExprCombinatorAlias = Terminated<ExprInnerCombinator, Tag<U8, u8>>;
+}
+pub type LimitMinCombinatorAlias = Mapped<UnsignedLEB128, LimitMinMapper>;
 
 
-pub open spec fn spec_expr() -> SpecExprCombinator {
-    SpecExprCombinator(Terminated(spec_expr_inner(), Tag::spec_new(U8, Expr_0_BACK_CONST)))
+pub open spec fn spec_limit_min() -> SpecLimitMinCombinator {
+    SpecLimitMinCombinator(
+    Mapped {
+        inner: UnsignedLEB128,
+        mapper: LimitMinMapper,
+    })
 }
 
                 
-pub fn expr<'a>() -> (o: ExprCombinator)
-    ensures o@ == spec_expr(),
+pub fn limit_min<'a>() -> (o: LimitMinCombinator)
+    ensures o@ == spec_limit_min(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ExprCombinator(Terminated(expr_inner(), Tag::new(U8, Expr_0_BACK_CONST)));
-    assert({
-        &&& combinator@ == spec_expr()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = LimitMinCombinator(
+    Mapped {
+        inner: UnsignedLEB128,
+        mapper: LimitMinMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_limit_min()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_expr<'a>(input: &'a [u8]) -> (res: PResult<<ExprCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_limit_min<'a>(input: &'a [u8]) -> (res: PResult<<LimitMinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_expr().spec_parse(input@) == Some((n as int, v@)),
-        spec_expr().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_limit_min().spec_parse(input@) == Some((n as int, v@)),
+        spec_limit_min().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_expr().spec_parse(input@) is None,
-        spec_expr().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_limit_min().spec_parse(input@) is None,
+        spec_limit_min().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = expr();
+    let combinator = limit_min();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_expr<'a>(v: <ExprCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_limit_min<'a>(v: <LimitMinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_expr().wf(v@),
+        spec_limit_min().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_expr().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_expr().spec_serialize(v@))
+            &&& n == spec_limit_min().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_limit_min().spec_serialize(v@))
         },
 {
-    let combinator = expr();
+    let combinator = limit_min();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn expr_len<'a>(v: <ExprCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn limit_min_len<'a>(v: <LimitMinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_expr().wf(v@),
-        spec_expr().spec_serialize(v@).len() <= usize::MAX,
+        spec_limit_min().wf(v@),
+        spec_limit_min().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_expr().spec_serialize(v@).len(),
+        serialize_len == spec_limit_min().spec_serialize(v@).len(),
 {
-    let combinator = expr();
+    let combinator = limit_min();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecFuncidxs {
-    pub l: u64,
-    pub v: Seq<SpecFuncidx>,
+pub struct SpecLimitMinMax {
+    pub min: u64,
+    pub max: u64,
 }
 
-pub type SpecFuncidxsInner = (u64, Seq<SpecFuncidx>);
+pub type SpecLimitMinMaxInner = (u64, u64);
 
 
-impl SpecFrom<SpecFuncidxs> for SpecFuncidxsInner {
-    open spec fn spec_from(m: SpecFuncidxs) -> SpecFuncidxsInner {
-        (m.l, m.v)
+impl SpecFrom<SpecLimitMinMax> for SpecLimitMinMaxInner {
+    open spec fn spec_from(m: SpecLimitMinMax) -> SpecLimitMinMaxInner {
+        (m.min, m.max)
     }
 }
 
-impl SpecFrom<SpecFuncidxsInner> for SpecFuncidxs {
-    open spec fn spec_from(m: SpecFuncidxsInner) -> SpecFuncidxs {
-        let (l, v) = m;
-        SpecFuncidxs { l, v }
+impl SpecFrom<SpecLimitMinMaxInner> for SpecLimitMinMax {
+    open spec fn spec_from(m: SpecLimitMinMaxInner) -> SpecLimitMinMax {
+        let (min, max) = m;
+        SpecLimitMinMax { min, max }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Funcidxs {
-    pub l: u64,
-    pub v: RepeatResult<Funcidx>,
+pub struct LimitMinMax {
+    pub min: u64,
+    pub max: u64,
 }
 
-impl View for Funcidxs {
-    type V = SpecFuncidxs;
+impl View for LimitMinMax {
+    type V = SpecLimitMinMax;
 
     open spec fn view(&self) -> Self::V {
-        SpecFuncidxs {
-            l: self.l@,
-            v: self.v@,
+        SpecLimitMinMax {
+            min: self.min@,
+            max: self.max@,
         }
     }
 }
-pub type FuncidxsInner = (u64, RepeatResult<Funcidx>);
+pub type LimitMinMaxInner = (u64, u64);
 
-pub type FuncidxsInnerRef<'a> = (&'a u64, &'a RepeatResult<Funcidx>);
-impl<'a> From<&'a Funcidxs> for FuncidxsInnerRef<'a> {
-    fn ex_from(m: &'a Funcidxs) -> FuncidxsInnerRef<'a> {
-        (&m.l, &m.v)
+pub type LimitMinMaxInnerRef<'a> = (&'a u64, &'a u64);
+impl<'a> From<&'a LimitMinMax> for LimitMinMaxInnerRef<'a> {
+    fn ex_from(m: &'a LimitMinMax) -> LimitMinMaxInnerRef<'a> {
+        (&m.min, &m.max)
     }
 }
 
-impl From<FuncidxsInner> for Funcidxs {
-    fn ex_from(m: FuncidxsInner) -> Funcidxs {
-        let (l, v) = m;
-        Funcidxs { l, v }
+impl From<LimitMinMaxInner> for LimitMinMax {
+    fn ex_from(m: LimitMinMaxInner) -> LimitMinMax {
+        let (min, max) = m;
+        LimitMinMax { min, max }
     }
 }
 
-pub struct FuncidxsMapper;
-impl View for FuncidxsMapper {
+pub struct LimitMinMaxMapper;
+impl View for LimitMinMaxMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for FuncidxsMapper {
-    type Src = SpecFuncidxsInner;
-    type Dst = SpecFuncidxs;
+impl SpecIso for LimitMinMaxMapper {
+    type Src = SpecLimitMinMaxInner;
+    type Dst = SpecLimitMinMax;
 }
-impl SpecIsoProof for FuncidxsMapper {
+impl SpecIsoProof for LimitMinMaxMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -11379,241 +11546,226 @@ impl SpecIsoProof for FuncidxsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for FuncidxsMapper {
-    type Src = FuncidxsInner;
-    type Dst = Funcidxs;
-    type RefSrc = FuncidxsInnerRef<'a>;
+impl<'a> Iso<'a> for LimitMinMaxMapper {
+    type Src = LimitMinMaxInner;
+    type Dst = LimitMinMax;
+    type RefSrc = LimitMinMaxInnerRef<'a>;
 }
+type SpecLimitMinMaxCombinatorAlias1 = (UnsignedLEB128, UnsignedLEB128);
+pub struct SpecLimitMinMaxCombinator(pub SpecLimitMinMaxCombinatorAlias);
 
-pub struct SpecFuncidxsCombinator(pub SpecFuncidxsCombinatorAlias);
-
-impl SpecCombinator for SpecFuncidxsCombinator {
-    type Type = SpecFuncidxs;
+impl SpecCombinator for SpecLimitMinMaxCombinator {
+    type Type = SpecLimitMinMax;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecFuncidxsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecFuncidxsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecLimitMinMaxCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecLimitMinMaxCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecFuncidxsCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecFuncidxCombinator>>, FuncidxsMapper>;
-
-pub struct FuncidxsCombinator(pub FuncidxsCombinatorAlias);
+pub type SpecLimitMinMaxCombinatorAlias = Mapped<SpecLimitMinMaxCombinatorAlias1, LimitMinMaxMapper>;
+type LimitMinMaxCombinatorAlias1 = (UnsignedLEB128, UnsignedLEB128);
+pub struct LimitMinMaxCombinator1(pub LimitMinMaxCombinatorAlias1);
+impl View for LimitMinMaxCombinator1 {
+    type V = SpecLimitMinMaxCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(LimitMinMaxCombinator1, LimitMinMaxCombinatorAlias1);
 
-impl View for FuncidxsCombinator {
-    type V = SpecFuncidxsCombinator;
-    open spec fn view(&self) -> Self::V { SpecFuncidxsCombinator(self.0@) }
+pub struct LimitMinMaxCombinator(pub LimitMinMaxCombinatorAlias);
+
+impl View for LimitMinMaxCombinator {
+    type V = SpecLimitMinMaxCombinator;
+    open spec fn view(&self) -> Self::V { SpecLimitMinMaxCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FuncidxsCombinator {
-    type Type = Funcidxs;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LimitMinMaxCombinator {
+    type Type = LimitMinMax;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type FuncidxsCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<FuncidxCombinator>, FuncidxsCont0>, FuncidxsMapper>;
+}
+pub type LimitMinMaxCombinatorAlias = Mapped<LimitMinMaxCombinator1, LimitMinMaxMapper>;
 
 
-pub open spec fn spec_funcidxs() -> SpecFuncidxsCombinator {
-    SpecFuncidxsCombinator(
+pub open spec fn spec_limit_min_max() -> SpecLimitMinMaxCombinator {
+    SpecLimitMinMaxCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_funcidxs_cont0(deps)),
-        mapper: FuncidxsMapper,
+        inner: (UnsignedLEB128, UnsignedLEB128),
+        mapper: LimitMinMaxMapper,
     })
 }
 
-pub open spec fn spec_funcidxs_cont0(deps: u64) -> RepeatN<SpecFuncidxCombinator> {
-    let l = deps;
-    RepeatN(spec_funcidx(), l.spec_into())
-}
-
-impl View for FuncidxsCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecFuncidxCombinator>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_funcidxs_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn funcidxs<'a>() -> (o: FuncidxsCombinator)
-    ensures o@ == spec_funcidxs(),
+pub fn limit_min_max<'a>() -> (o: LimitMinMaxCombinator)
+    ensures o@ == spec_limit_min_max(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = FuncidxsCombinator(
+    let combinator = LimitMinMaxCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, FuncidxsCont0),
-        mapper: FuncidxsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_funcidxs()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: LimitMinMaxCombinator1((UnsignedLEB128, UnsignedLEB128)),
+        mapper: LimitMinMaxMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_limit_min_max()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_funcidxs<'a>(input: &'a [u8]) -> (res: PResult<<FuncidxsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_limit_min_max<'a>(input: &'a [u8]) -> (res: PResult<<LimitMinMaxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_funcidxs().spec_parse(input@) == Some((n as int, v@)),
-        spec_funcidxs().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_limit_min_max().spec_parse(input@) == Some((n as int, v@)),
+        spec_limit_min_max().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_funcidxs().spec_parse(input@) is None,
-        spec_funcidxs().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_limit_min_max().spec_parse(input@) is None,
+        spec_limit_min_max().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = funcidxs();
+    let combinator = limit_min_max();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_funcidxs<'a>(v: <FuncidxsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_limit_min_max<'a>(v: <LimitMinMaxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_funcidxs().wf(v@),
+        spec_limit_min_max().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_funcidxs().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_funcidxs().spec_serialize(v@))
+            &&& n == spec_limit_min_max().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_limit_min_max().spec_serialize(v@))
         },
 {
-    let combinator = funcidxs();
+    let combinator = limit_min_max();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn funcidxs_len<'a>(v: <FuncidxsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn limit_min_max_len<'a>(v: <LimitMinMaxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_funcidxs().wf(v@),
-        spec_funcidxs().spec_serialize(v@).len() <= usize::MAX,
+        spec_limit_min_max().wf(v@),
+        spec_limit_min_max().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_funcidxs().spec_serialize(v@).len(),
+        serialize_len == spec_limit_min_max().spec_serialize(v@).len(),
 {
-    let combinator = funcidxs();
+    let combinator = limit_min_max();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct FuncidxsCont0;
-type FuncidxsCont0Type<'a, 'b> = &'b u64;
-type FuncidxsCont0SType<'a, 'x> = &'x u64;
-type FuncidxsCont0Input<'a, 'b, 'x> = POrSType<FuncidxsCont0Type<'a, 'b>, FuncidxsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<FuncidxsCont0Input<'a, 'b, 'x>> for FuncidxsCont0 {
-    type Output = RepeatN<FuncidxCombinator>;
+                
 
-    open spec fn requires(&self, deps: FuncidxsCont0Input<'a, 'b, 'x>) -> bool { true }
+pub enum SpecLimits {
+    NoMax(SpecLimitMin),
+    Max(SpecLimitMinMax),
+}
 
-    open spec fn ensures(&self, deps: FuncidxsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_funcidxs_cont0(deps@)
-    }
+pub type SpecLimitsInner = Either<SpecLimitMin, SpecLimitMinMax>;
 
-    fn apply(&self, deps: FuncidxsCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(funcidx(), l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(funcidx(), l.ex_into())
-            }
+impl SpecFrom<SpecLimits> for SpecLimitsInner {
+    open spec fn spec_from(m: SpecLimits) -> SpecLimitsInner {
+        match m {
+            SpecLimits::NoMax(m) => Either::Left(m),
+            SpecLimits::Max(m) => Either::Right(m),
         }
     }
+
 }
+
                 
+impl SpecFrom<SpecLimitsInner> for SpecLimits {
+    open spec fn spec_from(m: SpecLimitsInner) -> SpecLimits {
+        match m {
+            Either::Left(m) => SpecLimits::NoMax(m),
+            Either::Right(m) => SpecLimits::Max(m),
+        }
+    }
 
-pub struct SpecParsedElem0 {
-    pub e: SpecExpr,
-    pub init: SpecFuncidxs,
 }
 
-pub type SpecParsedElem0Inner = (SpecExpr, SpecFuncidxs);
 
 
-impl SpecFrom<SpecParsedElem0> for SpecParsedElem0Inner {
-    open spec fn spec_from(m: SpecParsedElem0) -> SpecParsedElem0Inner {
-        (m.e, m.init)
-    }
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Limits {
+    NoMax(LimitMin),
+    Max(LimitMinMax),
 }
 
-impl SpecFrom<SpecParsedElem0Inner> for SpecParsedElem0 {
-    open spec fn spec_from(m: SpecParsedElem0Inner) -> SpecParsedElem0 {
-        let (e, init) = m;
-        SpecParsedElem0 { e, init }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
+pub type LimitsInner = Either<LimitMin, LimitMinMax>;
 
-pub struct ParsedElem0<'a> {
-    pub e: Expr<'a>,
-    pub init: Funcidxs,
-}
+pub type LimitsInnerRef<'a> = Either<&'a LimitMin, &'a LimitMinMax>;
 
-impl View for ParsedElem0<'_> {
-    type V = SpecParsedElem0;
 
+impl View for Limits {
+    type V = SpecLimits;
     open spec fn view(&self) -> Self::V {
-        SpecParsedElem0 {
-            e: self.e@,
-            init: self.init@,
+        match self {
+            Limits::NoMax(m) => SpecLimits::NoMax(m@),
+            Limits::Max(m) => SpecLimits::Max(m@),
         }
     }
 }
-pub type ParsedElem0Inner<'a> = (Expr<'a>, Funcidxs);
 
-pub type ParsedElem0InnerRef<'a> = (&'a Expr<'a>, &'a Funcidxs);
-impl<'a> From<&'a ParsedElem0<'a>> for ParsedElem0InnerRef<'a> {
-    fn ex_from(m: &'a ParsedElem0) -> ParsedElem0InnerRef<'a> {
-        (&m.e, &m.init)
+
+impl<'a> From<&'a Limits> for LimitsInnerRef<'a> {
+    fn ex_from(m: &'a Limits) -> LimitsInnerRef<'a> {
+        match m {
+            Limits::NoMax(m) => Either::Left(m),
+            Limits::Max(m) => Either::Right(m),
+        }
     }
+
 }
 
-impl<'a> From<ParsedElem0Inner<'a>> for ParsedElem0<'a> {
-    fn ex_from(m: ParsedElem0Inner) -> ParsedElem0 {
-        let (e, init) = m;
-        ParsedElem0 { e, init }
+impl From<LimitsInner> for Limits {
+    fn ex_from(m: LimitsInner) -> Limits {
+        match m {
+            Either::Left(m) => Limits::NoMax(m),
+            Either::Right(m) => Limits::Max(m),
+        }
     }
+    
 }
 
-pub struct ParsedElem0Mapper;
-impl View for ParsedElem0Mapper {
+
+pub struct LimitsMapper;
+impl View for LimitsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ParsedElem0Mapper {
-    type Src = SpecParsedElem0Inner;
-    type Dst = SpecParsedElem0;
+impl SpecIso for LimitsMapper {
+    type Src = SpecLimitsInner;
+    type Dst = SpecLimits;
 }
-impl SpecIsoProof for ParsedElem0Mapper {
+impl SpecIsoProof for LimitsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -11621,419 +11773,320 @@ impl SpecIsoProof for ParsedElem0Mapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ParsedElem0Mapper {
-    type Src = ParsedElem0Inner<'a>;
-    type Dst = ParsedElem0<'a>;
-    type RefSrc = ParsedElem0InnerRef<'a>;
+impl<'a> Iso<'a> for LimitsMapper {
+    type Src = LimitsInner;
+    type Dst = Limits;
+    type RefSrc = LimitsInnerRef<'a>;
 }
-type SpecParsedElem0CombinatorAlias1 = (SpecExprCombinator, SpecFuncidxsCombinator);
-pub struct SpecParsedElem0Combinator(pub SpecParsedElem0CombinatorAlias);
 
-impl SpecCombinator for SpecParsedElem0Combinator {
-    type Type = SpecParsedElem0;
+pub const LIMITSNOMAX_0_FRONT_CONST: u8 = 0;
+
+pub const LIMITSMAX_0_FRONT_CONST: u8 = 1;
+
+type SpecLimitsCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, SpecLimitMinCombinator>, Preceded<Tag<U8, u8>, SpecLimitMinMaxCombinator>>;
+pub struct SpecLimitsCombinator(pub SpecLimitsCombinatorAlias);
+
+impl SpecCombinator for SpecLimitsCombinator {
+    type Type = SpecLimits;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecParsedElem0Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecParsedElem0CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecLimitsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecLimitsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecParsedElem0CombinatorAlias = Mapped<SpecParsedElem0CombinatorAlias1, ParsedElem0Mapper>;
-type ParsedElem0CombinatorAlias1 = (ExprCombinator, FuncidxsCombinator);
-pub struct ParsedElem0Combinator1(pub ParsedElem0CombinatorAlias1);
-impl View for ParsedElem0Combinator1 {
-    type V = SpecParsedElem0CombinatorAlias1;
+pub type SpecLimitsCombinatorAlias = Mapped<SpecLimitsCombinatorAlias1, LimitsMapper>;
+
+
+type LimitsCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, LimitMinCombinator>, Preceded<Tag<U8, u8>, LimitMinMaxCombinator>>;
+pub struct LimitsCombinator1(pub LimitsCombinatorAlias1);
+impl View for LimitsCombinator1 {
+    type V = SpecLimitsCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ParsedElem0Combinator1, ParsedElem0CombinatorAlias1);
+impl_wrapper_combinator!(LimitsCombinator1, LimitsCombinatorAlias1);
 
-pub struct ParsedElem0Combinator(pub ParsedElem0CombinatorAlias);
+pub struct LimitsCombinator(pub LimitsCombinatorAlias);
 
-impl View for ParsedElem0Combinator {
-    type V = SpecParsedElem0Combinator;
-    open spec fn view(&self) -> Self::V { SpecParsedElem0Combinator(self.0@) }
+impl View for LimitsCombinator {
+    type V = SpecLimitsCombinator;
+    open spec fn view(&self) -> Self::V { SpecLimitsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem0Combinator {
-    type Type = ParsedElem0<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LimitsCombinator {
+    type Type = Limits;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ParsedElem0CombinatorAlias = Mapped<ParsedElem0Combinator1, ParsedElem0Mapper>;
+}
+pub type LimitsCombinatorAlias = Mapped<LimitsCombinator1, LimitsMapper>;
 
 
-pub open spec fn spec_parsed_elem0() -> SpecParsedElem0Combinator {
-    SpecParsedElem0Combinator(
-    Mapped {
-        inner: (spec_expr(), spec_funcidxs()),
-        mapper: ParsedElem0Mapper,
-    })
+pub open spec fn spec_limits() -> SpecLimitsCombinator {
+    SpecLimitsCombinator(Mapped { inner: Choice(Preceded(Tag::spec_new(U8, LIMITSNOMAX_0_FRONT_CONST), spec_limit_min()), Preceded(Tag::spec_new(U8, LIMITSMAX_0_FRONT_CONST), spec_limit_min_max())), mapper: LimitsMapper })
 }
 
                 
-pub fn parsed_elem0<'a>() -> (o: ParsedElem0Combinator)
-    ensures o@ == spec_parsed_elem0(),
+pub fn limits<'a>() -> (o: LimitsCombinator)
+    ensures o@ == spec_limits(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ParsedElem0Combinator(
-    Mapped {
-        inner: ParsedElem0Combinator1((expr(), funcidxs())),
-        mapper: ParsedElem0Mapper,
-    });
-    assert({
-        &&& combinator@ == spec_parsed_elem0()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = LimitsCombinator(Mapped { inner: LimitsCombinator1(Choice::new(Preceded(Tag::new(U8, LIMITSNOMAX_0_FRONT_CONST), limit_min()), Preceded(Tag::new(U8, LIMITSMAX_0_FRONT_CONST), limit_min_max()))), mapper: LimitsMapper });
+    // assert({
+    //     &&& combinator@ == spec_limits()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_parsed_elem0<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_limits<'a>(input: &'a [u8]) -> (res: PResult<<LimitsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_parsed_elem0().spec_parse(input@) == Some((n as int, v@)),
-        spec_parsed_elem0().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_limits().spec_parse(input@) == Some((n as int, v@)),
+        spec_limits().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_parsed_elem0().spec_parse(input@) is None,
-        spec_parsed_elem0().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_limits().spec_parse(input@) is None,
+        spec_limits().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = parsed_elem0();
+    let combinator = limits();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_parsed_elem0<'a>(v: <ParsedElem0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_limits<'a>(v: <LimitsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_parsed_elem0().wf(v@),
+        spec_limits().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_parsed_elem0().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem0().spec_serialize(v@))
+            &&& n == spec_limits().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_limits().spec_serialize(v@))
         },
 {
-    let combinator = parsed_elem0();
+    let combinator = limits();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn parsed_elem0_len<'a>(v: <ParsedElem0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn limits_len<'a>(v: <LimitsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_parsed_elem0().wf(v@),
-        spec_parsed_elem0().spec_serialize(v@).len() <= usize::MAX,
+        spec_limits().wf(v@),
+        spec_limits().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_parsed_elem0().spec_serialize(v@).len(),
+        serialize_len == spec_limits().spec_serialize(v@).len(),
 {
-    let combinator = parsed_elem0();
+    let combinator = limits();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
+pub type SpecMemtype = SpecLimits;
+pub type Memtype = Limits;
+pub type MemtypeRef<'a> = &'a Limits;
 
-pub struct SpecParsedElem1 {
-    pub et: SpecELEMKIND,
-    pub init: SpecFuncidxs,
-}
-
-pub type SpecParsedElem1Inner = (SpecELEMKIND, SpecFuncidxs);
-
-
-impl SpecFrom<SpecParsedElem1> for SpecParsedElem1Inner {
-    open spec fn spec_from(m: SpecParsedElem1) -> SpecParsedElem1Inner {
-        (m.et, m.init)
-    }
-}
-
-impl SpecFrom<SpecParsedElem1Inner> for SpecParsedElem1 {
-    open spec fn spec_from(m: SpecParsedElem1Inner) -> SpecParsedElem1 {
-        let (et, init) = m;
-        SpecParsedElem1 { et, init }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct ParsedElem1 {
-    pub et: ELEMKIND,
-    pub init: Funcidxs,
-}
-
-impl View for ParsedElem1 {
-    type V = SpecParsedElem1;
-
-    open spec fn view(&self) -> Self::V {
-        SpecParsedElem1 {
-            et: self.et@,
-            init: self.init@,
-        }
-    }
-}
-pub type ParsedElem1Inner = (ELEMKIND, Funcidxs);
-
-pub type ParsedElem1InnerRef<'a> = (&'a ELEMKIND, &'a Funcidxs);
-impl<'a> From<&'a ParsedElem1> for ParsedElem1InnerRef<'a> {
-    fn ex_from(m: &'a ParsedElem1) -> ParsedElem1InnerRef<'a> {
-        (&m.et, &m.init)
-    }
-}
-
-impl From<ParsedElem1Inner> for ParsedElem1 {
-    fn ex_from(m: ParsedElem1Inner) -> ParsedElem1 {
-        let (et, init) = m;
-        ParsedElem1 { et, init }
-    }
-}
 
-pub struct ParsedElem1Mapper;
-impl View for ParsedElem1Mapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ParsedElem1Mapper {
-    type Src = SpecParsedElem1Inner;
-    type Dst = SpecParsedElem1;
-}
-impl SpecIsoProof for ParsedElem1Mapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for ParsedElem1Mapper {
-    type Src = ParsedElem1Inner;
-    type Dst = ParsedElem1;
-    type RefSrc = ParsedElem1InnerRef<'a>;
-}
-type SpecParsedElem1CombinatorAlias1 = (SpecELEMKINDCombinator, SpecFuncidxsCombinator);
-pub struct SpecParsedElem1Combinator(pub SpecParsedElem1CombinatorAlias);
+pub struct SpecMemtypeCombinator(pub SpecMemtypeCombinatorAlias);
 
-impl SpecCombinator for SpecParsedElem1Combinator {
-    type Type = SpecParsedElem1;
+impl SpecCombinator for SpecMemtypeCombinator {
+    type Type = SpecMemtype;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecParsedElem1Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecParsedElem1CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecMemtypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMemtypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecParsedElem1CombinatorAlias = Mapped<SpecParsedElem1CombinatorAlias1, ParsedElem1Mapper>;
-type ParsedElem1CombinatorAlias1 = (ELEMKINDCombinator, FuncidxsCombinator);
-pub struct ParsedElem1Combinator1(pub ParsedElem1CombinatorAlias1);
-impl View for ParsedElem1Combinator1 {
-    type V = SpecParsedElem1CombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ParsedElem1Combinator1, ParsedElem1CombinatorAlias1);
+pub type SpecMemtypeCombinatorAlias = SpecLimitsCombinator;
 
-pub struct ParsedElem1Combinator(pub ParsedElem1CombinatorAlias);
+pub struct MemtypeCombinator(pub MemtypeCombinatorAlias);
 
-impl View for ParsedElem1Combinator {
-    type V = SpecParsedElem1Combinator;
-    open spec fn view(&self) -> Self::V { SpecParsedElem1Combinator(self.0@) }
+impl View for MemtypeCombinator {
+    type V = SpecMemtypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecMemtypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem1Combinator {
-    type Type = ParsedElem1;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemtypeCombinator {
+    type Type = Memtype;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ParsedElem1CombinatorAlias = Mapped<ParsedElem1Combinator1, ParsedElem1Mapper>;
+}
+pub type MemtypeCombinatorAlias = LimitsCombinator;
 
 
-pub open spec fn spec_parsed_elem1() -> SpecParsedElem1Combinator {
-    SpecParsedElem1Combinator(
-    Mapped {
-        inner: (spec_ELEMKIND(), spec_funcidxs()),
-        mapper: ParsedElem1Mapper,
-    })
+pub open spec fn spec_memtype() -> SpecMemtypeCombinator {
+    SpecMemtypeCombinator(spec_limits())
 }
 
                 
-pub fn parsed_elem1<'a>() -> (o: ParsedElem1Combinator)
-    ensures o@ == spec_parsed_elem1(),
+pub fn memtype<'a>() -> (o: MemtypeCombinator)
+    ensures o@ == spec_memtype(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ParsedElem1Combinator(
-    Mapped {
-        inner: ParsedElem1Combinator1((ELEMKIND(), funcidxs())),
-        mapper: ParsedElem1Mapper,
-    });
-    assert({
-        &&& combinator@ == spec_parsed_elem1()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = MemtypeCombinator(limits());
+    // assert({
+    //     &&& combinator@ == spec_memtype()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_parsed_elem1<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_memtype<'a>(input: &'a [u8]) -> (res: PResult<<MemtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_parsed_elem1().spec_parse(input@) == Some((n as int, v@)),
-        spec_parsed_elem1().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_memtype().spec_parse(input@) == Some((n as int, v@)),
+        spec_memtype().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_parsed_elem1().spec_parse(input@) is None,
-        spec_parsed_elem1().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_memtype().spec_parse(input@) is None,
+        spec_memtype().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = parsed_elem1();
+    let combinator = memtype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_parsed_elem1<'a>(v: <ParsedElem1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_memtype<'a>(v: <MemtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_parsed_elem1().wf(v@),
+        spec_memtype().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_parsed_elem1().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem1().spec_serialize(v@))
+            &&& n == spec_memtype().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_memtype().spec_serialize(v@))
         },
 {
-    let combinator = parsed_elem1();
+    let combinator = memtype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn parsed_elem1_len<'a>(v: <ParsedElem1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn memtype_len<'a>(v: <MemtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_parsed_elem1().wf(v@),
-        spec_parsed_elem1().spec_serialize(v@).len() <= usize::MAX,
+        spec_memtype().wf(v@),
+        spec_memtype().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_parsed_elem1().spec_serialize(v@).len(),
+        serialize_len == spec_memtype().spec_serialize(v@).len(),
 {
-    let combinator = parsed_elem1();
+    let combinator = memtype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecParsedElem2 {
-    pub table: SpecTableidx,
-    pub offset: SpecExpr,
-    pub et: SpecELEMKIND,
-    pub init: SpecFuncidxs,
+pub struct SpecMem {
+    pub ty: SpecMemtype,
 }
 
-pub type SpecParsedElem2Inner = (SpecTableidx, (SpecExpr, (SpecELEMKIND, SpecFuncidxs)));
+pub type SpecMemInner = SpecMemtype;
 
 
-impl SpecFrom<SpecParsedElem2> for SpecParsedElem2Inner {
-    open spec fn spec_from(m: SpecParsedElem2) -> SpecParsedElem2Inner {
-        (m.table, (m.offset, (m.et, m.init)))
+impl SpecFrom<SpecMem> for SpecMemInner {
+    open spec fn spec_from(m: SpecMem) -> SpecMemInner {
+        m.ty
     }
 }
 
-impl SpecFrom<SpecParsedElem2Inner> for SpecParsedElem2 {
-    open spec fn spec_from(m: SpecParsedElem2Inner) -> SpecParsedElem2 {
-        let (table, (offset, (et, init))) = m;
-        SpecParsedElem2 { table, offset, et, init }
+impl SpecFrom<SpecMemInner> for SpecMem {
+    open spec fn spec_from(m: SpecMemInner) -> SpecMem {
+        let ty = m;
+        SpecMem { ty }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ParsedElem2<'a> {
-    pub table: Tableidx,
-    pub offset: Expr<'a>,
-    pub et: ELEMKIND,
-    pub init: Funcidxs,
+pub struct Mem {
+    pub ty: Memtype,
 }
 
-impl View for ParsedElem2<'_> {
-    type V = SpecParsedElem2;
+impl View for Mem {
+    type V = SpecMem;
 
     open spec fn view(&self) -> Self::V {
-        SpecParsedElem2 {
-            table: self.table@,
-            offset: self.offset@,
-            et: self.et@,
-            init: self.init@,
+        SpecMem {
+            ty: self.ty@,
         }
     }
 }
-pub type ParsedElem2Inner<'a> = (Tableidx, (Expr<'a>, (ELEMKIND, Funcidxs)));
-
-pub type ParsedElem2InnerRef<'a> = (&'a Tableidx, (&'a Expr<'a>, (&'a ELEMKIND, &'a Funcidxs)));
-impl<'a> From<&'a ParsedElem2<'a>> for ParsedElem2InnerRef<'a> {
-    fn ex_from(m: &'a ParsedElem2) -> ParsedElem2InnerRef<'a> {
-        (&m.table, (&m.offset, (&m.et, &m.init)))
-    }
-}
+pub type MemInner = Memtype;
 
-impl<'a> From<ParsedElem2Inner<'a>> for ParsedElem2<'a> {
-    fn ex_from(m: ParsedElem2Inner) -> ParsedElem2 {
-        let (table, (offset, (et, init))) = m;
-        ParsedElem2 { table, offset, et, init }
+pub type MemInnerRef<'a> = &'a Memtype;
+impl<'a> From<&'a Mem> for MemInnerRef<'a> {
+    fn ex_from(m: &'a Mem) -> MemInnerRef<'a> {
+        &m.ty
     }
 }
 
-pub struct ParsedElem2Mapper;
-impl View for ParsedElem2Mapper {
+impl From<MemInner> for Mem {
+    fn ex_from(m: MemInner) -> Mem {
+        let ty = m;
+        Mem { ty }
+    }
+}
+
+pub struct MemMapper;
+impl View for MemMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ParsedElem2Mapper {
-    type Src = SpecParsedElem2Inner;
-    type Dst = SpecParsedElem2;
+impl SpecIso for MemMapper {
+    type Src = SpecMemInner;
+    type Dst = SpecMem;
 }
-impl SpecIsoProof for ParsedElem2Mapper {
+impl SpecIsoProof for MemMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -12041,342 +12094,445 @@ impl SpecIsoProof for ParsedElem2Mapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ParsedElem2Mapper {
-    type Src = ParsedElem2Inner<'a>;
-    type Dst = ParsedElem2<'a>;
-    type RefSrc = ParsedElem2InnerRef<'a>;
+impl<'a> Iso<'a> for MemMapper {
+    type Src = MemInner;
+    type Dst = Mem;
+    type RefSrc = MemInnerRef<'a>;
 }
-type SpecParsedElem2CombinatorAlias1 = (SpecELEMKINDCombinator, SpecFuncidxsCombinator);
-type SpecParsedElem2CombinatorAlias2 = (SpecExprCombinator, SpecParsedElem2CombinatorAlias1);
-type SpecParsedElem2CombinatorAlias3 = (SpecTableidxCombinator, SpecParsedElem2CombinatorAlias2);
-pub struct SpecParsedElem2Combinator(pub SpecParsedElem2CombinatorAlias);
 
-impl SpecCombinator for SpecParsedElem2Combinator {
-    type Type = SpecParsedElem2;
+pub struct SpecMemCombinator(pub SpecMemCombinatorAlias);
+
+impl SpecCombinator for SpecMemCombinator {
+    type Type = SpecMem;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecParsedElem2Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecParsedElem2CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecMemCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMemCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecParsedElem2CombinatorAlias = Mapped<SpecParsedElem2CombinatorAlias3, ParsedElem2Mapper>;
-type ParsedElem2CombinatorAlias1 = (ELEMKINDCombinator, FuncidxsCombinator);
-type ParsedElem2CombinatorAlias2 = (ExprCombinator, ParsedElem2Combinator1);
-type ParsedElem2CombinatorAlias3 = (TableidxCombinator, ParsedElem2Combinator2);
-pub struct ParsedElem2Combinator1(pub ParsedElem2CombinatorAlias1);
-impl View for ParsedElem2Combinator1 {
-    type V = SpecParsedElem2CombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ParsedElem2Combinator1, ParsedElem2CombinatorAlias1);
-
-pub struct ParsedElem2Combinator2(pub ParsedElem2CombinatorAlias2);
-impl View for ParsedElem2Combinator2 {
-    type V = SpecParsedElem2CombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ParsedElem2Combinator2, ParsedElem2CombinatorAlias2);
-
-pub struct ParsedElem2Combinator3(pub ParsedElem2CombinatorAlias3);
-impl View for ParsedElem2Combinator3 {
-    type V = SpecParsedElem2CombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ParsedElem2Combinator3, ParsedElem2CombinatorAlias3);
+pub type SpecMemCombinatorAlias = Mapped<SpecMemtypeCombinator, MemMapper>;
 
-pub struct ParsedElem2Combinator(pub ParsedElem2CombinatorAlias);
+pub struct MemCombinator(pub MemCombinatorAlias);
 
-impl View for ParsedElem2Combinator {
-    type V = SpecParsedElem2Combinator;
-    open spec fn view(&self) -> Self::V { SpecParsedElem2Combinator(self.0@) }
+impl View for MemCombinator {
+    type V = SpecMemCombinator;
+    open spec fn view(&self) -> Self::V { SpecMemCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem2Combinator {
-    type Type = ParsedElem2<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemCombinator {
+    type Type = Mem;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ParsedElem2CombinatorAlias = Mapped<ParsedElem2Combinator3, ParsedElem2Mapper>;
+}
+pub type MemCombinatorAlias = Mapped<MemtypeCombinator, MemMapper>;
 
 
-pub open spec fn spec_parsed_elem2() -> SpecParsedElem2Combinator {
-    SpecParsedElem2Combinator(
+pub open spec fn spec_mem() -> SpecMemCombinator {
+    SpecMemCombinator(
     Mapped {
-        inner: (spec_tableidx(), (spec_expr(), (spec_ELEMKIND(), spec_funcidxs()))),
-        mapper: ParsedElem2Mapper,
+        inner: spec_memtype(),
+        mapper: MemMapper,
     })
 }
 
                 
-pub fn parsed_elem2<'a>() -> (o: ParsedElem2Combinator)
-    ensures o@ == spec_parsed_elem2(),
+pub fn mem<'a>() -> (o: MemCombinator)
+    ensures o@ == spec_mem(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ParsedElem2Combinator(
+    let combinator = MemCombinator(
     Mapped {
-        inner: ParsedElem2Combinator3((tableidx(), ParsedElem2Combinator2((expr(), ParsedElem2Combinator1((ELEMKIND(), funcidxs())))))),
-        mapper: ParsedElem2Mapper,
-    });
-    assert({
-        &&& combinator@ == spec_parsed_elem2()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: memtype(),
+        mapper: MemMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_mem()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_parsed_elem2<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_mem<'a>(input: &'a [u8]) -> (res: PResult<<MemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_parsed_elem2().spec_parse(input@) == Some((n as int, v@)),
-        spec_parsed_elem2().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_mem().spec_parse(input@) == Some((n as int, v@)),
+        spec_mem().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_parsed_elem2().spec_parse(input@) is None,
-        spec_parsed_elem2().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_mem().spec_parse(input@) is None,
+        spec_mem().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = parsed_elem2();
+    let combinator = mem();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_parsed_elem2<'a>(v: <ParsedElem2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_mem<'a>(v: <MemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_parsed_elem2().wf(v@),
+        spec_mem().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_parsed_elem2().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem2().spec_serialize(v@))
+            &&& n == spec_mem().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_mem().spec_serialize(v@))
         },
 {
-    let combinator = parsed_elem2();
+    let combinator = mem();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn parsed_elem2_len<'a>(v: <ParsedElem2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn mem_len<'a>(v: <MemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_parsed_elem2().wf(v@),
-        spec_parsed_elem2().spec_serialize(v@).len() <= usize::MAX,
+        spec_mem().wf(v@),
+        spec_mem().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_parsed_elem2().spec_serialize(v@).len(),
+        serialize_len == spec_mem().spec_serialize(v@).len(),
 {
-    let combinator = parsed_elem2();
+    let combinator = mem();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
-pub type SpecParsedElem3 = SpecParsedElem1;
-pub type ParsedElem3 = ParsedElem1;
-pub type ParsedElem3Ref<'a> = &'a ParsedElem1;
 
+pub struct SpecMemsecContent {
+    pub l: u64,
+    pub v: Seq<SpecMem>,
+}
+
+pub type SpecMemsecContentInner = (u64, Seq<SpecMem>);
 
-pub struct SpecParsedElem3Combinator(pub SpecParsedElem3CombinatorAlias);
 
-impl SpecCombinator for SpecParsedElem3Combinator {
-    type Type = SpecParsedElem3;
+impl SpecFrom<SpecMemsecContent> for SpecMemsecContentInner {
+    open spec fn spec_from(m: SpecMemsecContent) -> SpecMemsecContentInner {
+        (m.l, m.v)
+    }
+}
+
+impl SpecFrom<SpecMemsecContentInner> for SpecMemsecContent {
+    open spec fn spec_from(m: SpecMemsecContentInner) -> SpecMemsecContent {
+        let (l, v) = m;
+        SpecMemsecContent { l, v }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct MemsecContent {
+    pub l: u64,
+    pub v: RepeatResult<Mem>,
+}
+
+impl View for MemsecContent {
+    type V = SpecMemsecContent;
+
+    open spec fn view(&self) -> Self::V {
+        SpecMemsecContent {
+            l: self.l@,
+            v: self.v@,
+        }
+    }
+}
+pub type MemsecContentInner = (u64, RepeatResult<Mem>);
+
+pub type MemsecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Mem>);
+impl<'a> From<&'a MemsecContent> for MemsecContentInnerRef<'a> {
+    fn ex_from(m: &'a MemsecContent) -> MemsecContentInnerRef<'a> {
+        (&m.l, &m.v)
+    }
+}
+
+impl From<MemsecContentInner> for MemsecContent {
+    fn ex_from(m: MemsecContentInner) -> MemsecContent {
+        let (l, v) = m;
+        MemsecContent { l, v }
+    }
+}
+
+pub struct MemsecContentMapper;
+impl View for MemsecContentMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for MemsecContentMapper {
+    type Src = SpecMemsecContentInner;
+    type Dst = SpecMemsecContent;
+}
+impl SpecIsoProof for MemsecContentMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for MemsecContentMapper {
+    type Src = MemsecContentInner;
+    type Dst = MemsecContent;
+    type RefSrc = MemsecContentInnerRef<'a>;
+}
+
+pub struct SpecMemsecContentCombinator(pub SpecMemsecContentCombinatorAlias);
+
+impl SpecCombinator for SpecMemsecContentCombinator {
+    type Type = SpecMemsecContent;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecParsedElem3Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecParsedElem3CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecMemsecContentCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMemsecContentCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecParsedElem3CombinatorAlias = SpecParsedElem1Combinator;
+pub type SpecMemsecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecMemCombinator>>, MemsecContentMapper>;
 
-pub struct ParsedElem3Combinator(pub ParsedElem3CombinatorAlias);
+pub struct MemsecContentCombinator(pub MemsecContentCombinatorAlias);
 
-impl View for ParsedElem3Combinator {
-    type V = SpecParsedElem3Combinator;
-    open spec fn view(&self) -> Self::V { SpecParsedElem3Combinator(self.0@) }
+impl View for MemsecContentCombinator {
+    type V = SpecMemsecContentCombinator;
+    open spec fn view(&self) -> Self::V { SpecMemsecContentCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemsecContentCombinator {
+    type Type = MemsecContent;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type MemsecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<MemCombinator>, MemsecContentCont0>, MemsecContentMapper>;
+
+
+pub open spec fn spec_memsec_content() -> SpecMemsecContentCombinator {
+    SpecMemsecContentCombinator(
+    Mapped {
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_memsec_content_cont0(deps)),
+        mapper: MemsecContentMapper,
+    })
+}
+
+pub open spec fn spec_memsec_content_cont0(deps: u64) -> RepeatN<SpecMemCombinator> {
+    let l = deps;
+    RepeatN(spec_mem(), (usize::spec_from(l)) as usize)
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem3Combinator {
-    type Type = ParsedElem3;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ParsedElem3CombinatorAlias = ParsedElem1Combinator;
 
+impl View for MemsecContentCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecMemCombinator>;
 
-pub open spec fn spec_parsed_elem3() -> SpecParsedElem3Combinator {
-    SpecParsedElem3Combinator(spec_parsed_elem1())
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_memsec_content_cont0(deps)
+        }
+    }
 }
 
                 
-pub fn parsed_elem3<'a>() -> (o: ParsedElem3Combinator)
-    ensures o@ == spec_parsed_elem3(),
+pub fn memsec_content<'a>() -> (o: MemsecContentCombinator)
+    ensures o@ == spec_memsec_content(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ParsedElem3Combinator(parsed_elem1());
-    assert({
-        &&& combinator@ == spec_parsed_elem3()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = MemsecContentCombinator(
+    Mapped {
+        inner: Pair::new(UnsignedLEB128, MemsecContentCont0),
+        mapper: MemsecContentMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_memsec_content()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_parsed_elem3<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem3Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_memsec_content<'a>(input: &'a [u8]) -> (res: PResult<<MemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_parsed_elem3().spec_parse(input@) == Some((n as int, v@)),
-        spec_parsed_elem3().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_memsec_content().spec_parse(input@) == Some((n as int, v@)),
+        spec_memsec_content().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_parsed_elem3().spec_parse(input@) is None,
-        spec_parsed_elem3().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_memsec_content().spec_parse(input@) is None,
+        spec_memsec_content().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = parsed_elem3();
+    let combinator = memsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_parsed_elem3<'a>(v: <ParsedElem3Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_memsec_content<'a>(v: <MemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_parsed_elem3().wf(v@),
+        spec_memsec_content().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_parsed_elem3().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem3().spec_serialize(v@))
+            &&& n == spec_memsec_content().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_memsec_content().spec_serialize(v@))
         },
 {
-    let combinator = parsed_elem3();
+    let combinator = memsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn parsed_elem3_len<'a>(v: <ParsedElem3Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn memsec_content_len<'a>(v: <MemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_parsed_elem3().wf(v@),
-        spec_parsed_elem3().spec_serialize(v@).len() <= usize::MAX,
+        spec_memsec_content().wf(v@),
+        spec_memsec_content().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_parsed_elem3().spec_serialize(v@).len(),
+        serialize_len == spec_memsec_content().spec_serialize(v@).len(),
 {
-    let combinator = parsed_elem3();
+    let combinator = memsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct MemsecContentCont0;
+type MemsecContentCont0Type<'a, 'b> = &'b u64;
+type MemsecContentCont0SType<'a, 'x> = &'x u64;
+type MemsecContentCont0Input<'a, 'b, 'x> = POrSType<MemsecContentCont0Type<'a, 'b>, MemsecContentCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<MemsecContentCont0Input<'a, 'b, 'x>> for MemsecContentCont0 {
+    type Output = RepeatN<MemCombinator>;
+
+    open spec fn requires(&self, deps: MemsecContentCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: MemsecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_memsec_content_cont0(deps@)
+    }
+
+    fn apply(&self, deps: MemsecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(mem(), (usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(mem(), (usize::ex_from(l)) as usize)
+            }
+        }
+    }
+}
                 
 
-pub struct SpecExprs {
-    pub l: u64,
-    pub v: Seq<SpecExpr>,
+pub struct SpecMemsec {
+    pub size: u64,
+    pub cont: SpecMemsecContent,
 }
 
-pub type SpecExprsInner = (u64, Seq<SpecExpr>);
+pub type SpecMemsecInner = (u64, SpecMemsecContent);
 
 
-impl SpecFrom<SpecExprs> for SpecExprsInner {
-    open spec fn spec_from(m: SpecExprs) -> SpecExprsInner {
-        (m.l, m.v)
+impl SpecFrom<SpecMemsec> for SpecMemsecInner {
+    open spec fn spec_from(m: SpecMemsec) -> SpecMemsecInner {
+        (m.size, m.cont)
     }
 }
 
-impl SpecFrom<SpecExprsInner> for SpecExprs {
-    open spec fn spec_from(m: SpecExprsInner) -> SpecExprs {
-        let (l, v) = m;
-        SpecExprs { l, v }
+impl SpecFrom<SpecMemsecInner> for SpecMemsec {
+    open spec fn spec_from(m: SpecMemsecInner) -> SpecMemsec {
+        let (size, cont) = m;
+        SpecMemsec { size, cont }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Exprs<'a> {
-    pub l: u64,
-    pub v: RepeatResult<Expr<'a>>,
+pub struct Memsec {
+    pub size: u64,
+    pub cont: MemsecContent,
 }
 
-impl View for Exprs<'_> {
-    type V = SpecExprs;
+impl View for Memsec {
+    type V = SpecMemsec;
 
     open spec fn view(&self) -> Self::V {
-        SpecExprs {
-            l: self.l@,
-            v: self.v@,
+        SpecMemsec {
+            size: self.size@,
+            cont: self.cont@,
         }
     }
 }
-pub type ExprsInner<'a> = (u64, RepeatResult<Expr<'a>>);
+pub type MemsecInner = (u64, MemsecContent);
 
-pub type ExprsInnerRef<'a> = (&'a u64, &'a RepeatResult<Expr<'a>>);
-impl<'a> From<&'a Exprs<'a>> for ExprsInnerRef<'a> {
-    fn ex_from(m: &'a Exprs) -> ExprsInnerRef<'a> {
-        (&m.l, &m.v)
+pub type MemsecInnerRef<'a> = (&'a u64, &'a MemsecContent);
+impl<'a> From<&'a Memsec> for MemsecInnerRef<'a> {
+    fn ex_from(m: &'a Memsec) -> MemsecInnerRef<'a> {
+        (&m.size, &m.cont)
     }
 }
 
-impl<'a> From<ExprsInner<'a>> for Exprs<'a> {
-    fn ex_from(m: ExprsInner) -> Exprs {
-        let (l, v) = m;
-        Exprs { l, v }
+impl From<MemsecInner> for Memsec {
+    fn ex_from(m: MemsecInner) -> Memsec {
+        let (size, cont) = m;
+        Memsec { size, cont }
     }
 }
 
-pub struct ExprsMapper;
-impl View for ExprsMapper {
+pub struct MemsecMapper;
+impl View for MemsecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ExprsMapper {
-    type Src = SpecExprsInner;
-    type Dst = SpecExprs;
+impl SpecIso for MemsecMapper {
+    type Src = SpecMemsecInner;
+    type Dst = SpecMemsec;
 }
-impl SpecIsoProof for ExprsMapper {
+impl SpecIsoProof for MemsecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -12384,448 +12540,363 @@ impl SpecIsoProof for ExprsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ExprsMapper {
-    type Src = ExprsInner<'a>;
-    type Dst = Exprs<'a>;
-    type RefSrc = ExprsInnerRef<'a>;
+impl<'a> Iso<'a> for MemsecMapper {
+    type Src = MemsecInner;
+    type Dst = Memsec;
+    type RefSrc = MemsecInnerRef<'a>;
 }
 
-pub struct SpecExprsCombinator(pub SpecExprsCombinatorAlias);
+pub struct SpecMemsecCombinator(pub SpecMemsecCombinatorAlias);
 
-impl SpecCombinator for SpecExprsCombinator {
-    type Type = SpecExprs;
+impl SpecCombinator for SpecMemsecCombinator {
+    type Type = SpecMemsec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecExprsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecExprsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecMemsecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMemsecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecExprsCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecExprCombinator>>, ExprsMapper>;
+pub type SpecMemsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecMemsecContentCombinator>>, MemsecMapper>;
 
-pub struct ExprsCombinator(pub ExprsCombinatorAlias);
+pub struct MemsecCombinator(pub MemsecCombinatorAlias);
 
-impl View for ExprsCombinator {
-    type V = SpecExprsCombinator;
-    open spec fn view(&self) -> Self::V { SpecExprsCombinator(self.0@) }
+impl View for MemsecCombinator {
+    type V = SpecMemsecCombinator;
+    open spec fn view(&self) -> Self::V { SpecMemsecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExprsCombinator {
-    type Type = Exprs<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemsecCombinator {
+    type Type = Memsec;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ExprsCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ExprCombinator>, ExprsCont0>, ExprsMapper>;
+}
+pub type MemsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, MemsecContentCombinator>, MemsecCont0>, MemsecMapper>;
 
 
-pub open spec fn spec_exprs() -> SpecExprsCombinator {
-    SpecExprsCombinator(
+pub open spec fn spec_memsec() -> SpecMemsecCombinator {
+    SpecMemsecCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_exprs_cont0(deps)),
-        mapper: ExprsMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_memsec_cont0(deps)),
+        mapper: MemsecMapper,
     })
 }
 
-pub open spec fn spec_exprs_cont0(deps: u64) -> RepeatN<SpecExprCombinator> {
-    let l = deps;
-    RepeatN(spec_expr(), l.spec_into())
+pub open spec fn spec_memsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecMemsecContentCombinator> {
+    let size = deps;
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_memsec_content())
 }
 
-impl View for ExprsCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecExprCombinator>;
+impl View for MemsecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecMemsecContentCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_exprs_cont0(deps)
+            spec_memsec_cont0(deps)
         }
     }
 }
 
                 
-pub fn exprs<'a>() -> (o: ExprsCombinator)
-    ensures o@ == spec_exprs(),
+pub fn memsec<'a>() -> (o: MemsecCombinator)
+    ensures o@ == spec_memsec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ExprsCombinator(
+    let combinator = MemsecCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, ExprsCont0),
-        mapper: ExprsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_exprs()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, MemsecCont0),
+        mapper: MemsecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_memsec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_exprs<'a>(input: &'a [u8]) -> (res: PResult<<ExprsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_memsec<'a>(input: &'a [u8]) -> (res: PResult<<MemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_exprs().spec_parse(input@) == Some((n as int, v@)),
-        spec_exprs().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_memsec().spec_parse(input@) == Some((n as int, v@)),
+        spec_memsec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_exprs().spec_parse(input@) is None,
-        spec_exprs().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_memsec().spec_parse(input@) is None,
+        spec_memsec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = exprs();
+    let combinator = memsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_exprs<'a>(v: <ExprsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_memsec<'a>(v: <MemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_exprs().wf(v@),
+        spec_memsec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_exprs().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_exprs().spec_serialize(v@))
+            &&& n == spec_memsec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_memsec().spec_serialize(v@))
         },
 {
-    let combinator = exprs();
+    let combinator = memsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn exprs_len<'a>(v: <ExprsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn memsec_len<'a>(v: <MemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_exprs().wf(v@),
-        spec_exprs().spec_serialize(v@).len() <= usize::MAX,
+        spec_memsec().wf(v@),
+        spec_memsec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_exprs().spec_serialize(v@).len(),
+        serialize_len == spec_memsec().spec_serialize(v@).len(),
 {
-    let combinator = exprs();
+    let combinator = memsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ExprsCont0;
-type ExprsCont0Type<'a, 'b> = &'b u64;
-type ExprsCont0SType<'a, 'x> = &'x u64;
-type ExprsCont0Input<'a, 'b, 'x> = POrSType<ExprsCont0Type<'a, 'b>, ExprsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ExprsCont0Input<'a, 'b, 'x>> for ExprsCont0 {
-    type Output = RepeatN<ExprCombinator>;
-
-    open spec fn requires(&self, deps: ExprsCont0Input<'a, 'b, 'x>) -> bool { true }
+pub struct MemsecCont0;
+type MemsecCont0Type<'a, 'b> = &'b u64;
+type MemsecCont0SType<'a, 'x> = &'x u64;
+type MemsecCont0Input<'a, 'b, 'x> = POrSType<MemsecCont0Type<'a, 'b>, MemsecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<MemsecCont0Input<'a, 'b, 'x>> for MemsecCont0 {
+    type Output = AndThen<bytes::Variable, MemsecContentCombinator>;
 
-    open spec fn ensures(&self, deps: ExprsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_exprs_cont0(deps@)
+    open spec fn requires(&self, deps: MemsecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: MemsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_memsec_cont0(deps@)
     }
 
-    fn apply(&self, deps: ExprsCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: MemsecCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(expr(), l.ex_into())
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), memsec_content())
             }
             POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(expr(), l.ex_into())
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), memsec_content())
             }
         }
     }
 }
                 
+pub type SpecMemidx = u64;
+pub type Memidx = u64;
+pub type MemidxRef<'a> = &'a u64;
 
-pub struct SpecParsedElem4 {
-    pub offset: SpecExpr,
-    pub init: SpecExprs,
-}
-
-pub type SpecParsedElem4Inner = (SpecExpr, SpecExprs);
-
-
-impl SpecFrom<SpecParsedElem4> for SpecParsedElem4Inner {
-    open spec fn spec_from(m: SpecParsedElem4) -> SpecParsedElem4Inner {
-        (m.offset, m.init)
-    }
-}
-
-impl SpecFrom<SpecParsedElem4Inner> for SpecParsedElem4 {
-    open spec fn spec_from(m: SpecParsedElem4Inner) -> SpecParsedElem4 {
-        let (offset, init) = m;
-        SpecParsedElem4 { offset, init }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct ParsedElem4<'a> {
-    pub offset: Expr<'a>,
-    pub init: Exprs<'a>,
-}
-
-impl View for ParsedElem4<'_> {
-    type V = SpecParsedElem4;
-
-    open spec fn view(&self) -> Self::V {
-        SpecParsedElem4 {
-            offset: self.offset@,
-            init: self.init@,
-        }
-    }
-}
-pub type ParsedElem4Inner<'a> = (Expr<'a>, Exprs<'a>);
-
-pub type ParsedElem4InnerRef<'a> = (&'a Expr<'a>, &'a Exprs<'a>);
-impl<'a> From<&'a ParsedElem4<'a>> for ParsedElem4InnerRef<'a> {
-    fn ex_from(m: &'a ParsedElem4) -> ParsedElem4InnerRef<'a> {
-        (&m.offset, &m.init)
-    }
-}
-
-impl<'a> From<ParsedElem4Inner<'a>> for ParsedElem4<'a> {
-    fn ex_from(m: ParsedElem4Inner) -> ParsedElem4 {
-        let (offset, init) = m;
-        ParsedElem4 { offset, init }
-    }
-}
 
-pub struct ParsedElem4Mapper;
-impl View for ParsedElem4Mapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ParsedElem4Mapper {
-    type Src = SpecParsedElem4Inner;
-    type Dst = SpecParsedElem4;
-}
-impl SpecIsoProof for ParsedElem4Mapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for ParsedElem4Mapper {
-    type Src = ParsedElem4Inner<'a>;
-    type Dst = ParsedElem4<'a>;
-    type RefSrc = ParsedElem4InnerRef<'a>;
-}
-type SpecParsedElem4CombinatorAlias1 = (SpecExprCombinator, SpecExprsCombinator);
-pub struct SpecParsedElem4Combinator(pub SpecParsedElem4CombinatorAlias);
+pub struct SpecMemidxCombinator(pub SpecMemidxCombinatorAlias);
 
-impl SpecCombinator for SpecParsedElem4Combinator {
-    type Type = SpecParsedElem4;
+impl SpecCombinator for SpecMemidxCombinator {
+    type Type = SpecMemidx;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecParsedElem4Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecParsedElem4CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecMemidxCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMemidxCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecParsedElem4CombinatorAlias = Mapped<SpecParsedElem4CombinatorAlias1, ParsedElem4Mapper>;
-type ParsedElem4CombinatorAlias1 = (ExprCombinator, ExprsCombinator);
-pub struct ParsedElem4Combinator1(pub ParsedElem4CombinatorAlias1);
-impl View for ParsedElem4Combinator1 {
-    type V = SpecParsedElem4CombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ParsedElem4Combinator1, ParsedElem4CombinatorAlias1);
+pub type SpecMemidxCombinatorAlias = UnsignedLEB128;
 
-pub struct ParsedElem4Combinator(pub ParsedElem4CombinatorAlias);
+pub struct MemidxCombinator(pub MemidxCombinatorAlias);
 
-impl View for ParsedElem4Combinator {
-    type V = SpecParsedElem4Combinator;
-    open spec fn view(&self) -> Self::V { SpecParsedElem4Combinator(self.0@) }
+impl View for MemidxCombinator {
+    type V = SpecMemidxCombinator;
+    open spec fn view(&self) -> Self::V { SpecMemidxCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem4Combinator {
-    type Type = ParsedElem4<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemidxCombinator {
+    type Type = Memidx;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ParsedElem4CombinatorAlias = Mapped<ParsedElem4Combinator1, ParsedElem4Mapper>;
+}
+pub type MemidxCombinatorAlias = UnsignedLEB128;
 
 
-pub open spec fn spec_parsed_elem4() -> SpecParsedElem4Combinator {
-    SpecParsedElem4Combinator(
-    Mapped {
-        inner: (spec_expr(), spec_exprs()),
-        mapper: ParsedElem4Mapper,
-    })
+pub open spec fn spec_memidx() -> SpecMemidxCombinator {
+    SpecMemidxCombinator(UnsignedLEB128)
 }
 
                 
-pub fn parsed_elem4<'a>() -> (o: ParsedElem4Combinator)
-    ensures o@ == spec_parsed_elem4(),
+pub fn memidx<'a>() -> (o: MemidxCombinator)
+    ensures o@ == spec_memidx(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ParsedElem4Combinator(
-    Mapped {
-        inner: ParsedElem4Combinator1((expr(), exprs())),
-        mapper: ParsedElem4Mapper,
-    });
-    assert({
-        &&& combinator@ == spec_parsed_elem4()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = MemidxCombinator(UnsignedLEB128);
+    // assert({
+    //     &&& combinator@ == spec_memidx()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_parsed_elem4<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_memidx<'a>(input: &'a [u8]) -> (res: PResult<<MemidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_parsed_elem4().spec_parse(input@) == Some((n as int, v@)),
-        spec_parsed_elem4().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_memidx().spec_parse(input@) == Some((n as int, v@)),
+        spec_memidx().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_parsed_elem4().spec_parse(input@) is None,
-        spec_parsed_elem4().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_memidx().spec_parse(input@) is None,
+        spec_memidx().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = parsed_elem4();
+    let combinator = memidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_parsed_elem4<'a>(v: <ParsedElem4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_memidx<'a>(v: <MemidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_parsed_elem4().wf(v@),
+        spec_memidx().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_parsed_elem4().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem4().spec_serialize(v@))
+            &&& n == spec_memidx().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_memidx().spec_serialize(v@))
         },
 {
-    let combinator = parsed_elem4();
+    let combinator = memidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn parsed_elem4_len<'a>(v: <ParsedElem4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn memidx_len<'a>(v: <MemidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_parsed_elem4().wf(v@),
-        spec_parsed_elem4().spec_serialize(v@).len() <= usize::MAX,
+        spec_memidx().wf(v@),
+        spec_memidx().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_parsed_elem4().spec_serialize(v@).len(),
+        serialize_len == spec_memidx().spec_serialize(v@).len(),
 {
-    let combinator = parsed_elem4();
+    let combinator = memidx();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecParsedElem5 {
-    pub et: SpecReftype,
-    pub init: SpecExprs,
+pub struct SpecExprInner {
+    pub l: u64,
+    pub v: Seq<SpecInstr>,
 }
 
-pub type SpecParsedElem5Inner = (SpecReftype, SpecExprs);
+pub type SpecExprInnerInner = (u64, Seq<SpecInstr>);
 
 
-impl SpecFrom<SpecParsedElem5> for SpecParsedElem5Inner {
-    open spec fn spec_from(m: SpecParsedElem5) -> SpecParsedElem5Inner {
-        (m.et, m.init)
+impl SpecFrom<SpecExprInner> for SpecExprInnerInner {
+    open spec fn spec_from(m: SpecExprInner) -> SpecExprInnerInner {
+        (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecParsedElem5Inner> for SpecParsedElem5 {
-    open spec fn spec_from(m: SpecParsedElem5Inner) -> SpecParsedElem5 {
-        let (et, init) = m;
-        SpecParsedElem5 { et, init }
+impl SpecFrom<SpecExprInnerInner> for SpecExprInner {
+    open spec fn spec_from(m: SpecExprInnerInner) -> SpecExprInner {
+        let (l, v) = m;
+        SpecExprInner { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ParsedElem5<'a> {
-    pub et: Reftype,
-    pub init: Exprs<'a>,
+pub struct ExprInner<'a> {
+    pub l: u64,
+    pub v: RepeatResult<Instr<'a>>,
 }
 
-impl View for ParsedElem5<'_> {
-    type V = SpecParsedElem5;
+impl View for ExprInner<'_> {
+    type V = SpecExprInner;
 
     open spec fn view(&self) -> Self::V {
-        SpecParsedElem5 {
-            et: self.et@,
-            init: self.init@,
+        SpecExprInner {
+            l: self.l@,
+            v: self.v@,
         }
     }
 }
-pub type ParsedElem5Inner<'a> = (Reftype, Exprs<'a>);
+pub type ExprInnerInner<'a> = (u64, RepeatResult<Instr<'a>>);
 
-pub type ParsedElem5InnerRef<'a> = (&'a Reftype, &'a Exprs<'a>);
-impl<'a> From<&'a ParsedElem5<'a>> for ParsedElem5InnerRef<'a> {
-    fn ex_from(m: &'a ParsedElem5) -> ParsedElem5InnerRef<'a> {
-        (&m.et, &m.init)
+pub type ExprInnerInnerRef<'a> = (&'a u64, &'a RepeatResult<Instr<'a>>);
+impl<'a> From<&'a ExprInner<'a>> for ExprInnerInnerRef<'a> {
+    fn ex_from(m: &'a ExprInner) -> ExprInnerInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-impl<'a> From<ParsedElem5Inner<'a>> for ParsedElem5<'a> {
-    fn ex_from(m: ParsedElem5Inner) -> ParsedElem5 {
-        let (et, init) = m;
-        ParsedElem5 { et, init }
+impl<'a> From<ExprInnerInner<'a>> for ExprInner<'a> {
+    fn ex_from(m: ExprInnerInner) -> ExprInner {
+        let (l, v) = m;
+        ExprInner { l, v }
     }
 }
 
-pub struct ParsedElem5Mapper;
-impl View for ParsedElem5Mapper {
+pub struct ExprInnerMapper;
+impl View for ExprInnerMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ParsedElem5Mapper {
-    type Src = SpecParsedElem5Inner;
-    type Dst = SpecParsedElem5;
+impl SpecIso for ExprInnerMapper {
+    type Src = SpecExprInnerInner;
+    type Dst = SpecExprInner;
 }
-impl SpecIsoProof for ParsedElem5Mapper {
+impl SpecIsoProof for ExprInnerMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -12833,437 +12904,366 @@ impl SpecIsoProof for ParsedElem5Mapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ParsedElem5Mapper {
-    type Src = ParsedElem5Inner<'a>;
-    type Dst = ParsedElem5<'a>;
-    type RefSrc = ParsedElem5InnerRef<'a>;
-}
-type SpecParsedElem5CombinatorAlias1 = (SpecReftypeCombinator, SpecExprsCombinator);
-pub struct SpecParsedElem5Combinator(pub SpecParsedElem5CombinatorAlias);
+impl<'a> Iso<'a> for ExprInnerMapper {
+    type Src = ExprInnerInner<'a>;
+    type Dst = ExprInner<'a>;
+    type RefSrc = ExprInnerInnerRef<'a>;
+}
 
-impl SpecCombinator for SpecParsedElem5Combinator {
-    type Type = SpecParsedElem5;
+pub struct SpecExprInnerCombinator(pub SpecExprInnerCombinatorAlias);
+
+impl SpecCombinator for SpecExprInnerCombinator {
+    type Type = SpecExprInner;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecParsedElem5Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecParsedElem5CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecExprInnerCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecExprInnerCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecParsedElem5CombinatorAlias = Mapped<SpecParsedElem5CombinatorAlias1, ParsedElem5Mapper>;
-type ParsedElem5CombinatorAlias1 = (ReftypeCombinator, ExprsCombinator);
-pub struct ParsedElem5Combinator1(pub ParsedElem5CombinatorAlias1);
-impl View for ParsedElem5Combinator1 {
-    type V = SpecParsedElem5CombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ParsedElem5Combinator1, ParsedElem5CombinatorAlias1);
+pub type SpecExprInnerCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecInstrCombinator>>, ExprInnerMapper>;
 
-pub struct ParsedElem5Combinator(pub ParsedElem5CombinatorAlias);
+pub struct ExprInnerCombinator(pub ExprInnerCombinatorAlias);
 
-impl View for ParsedElem5Combinator {
-    type V = SpecParsedElem5Combinator;
-    open spec fn view(&self) -> Self::V { SpecParsedElem5Combinator(self.0@) }
+impl View for ExprInnerCombinator {
+    type V = SpecExprInnerCombinator;
+    open spec fn view(&self) -> Self::V { SpecExprInnerCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem5Combinator {
-    type Type = ParsedElem5<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExprInnerCombinator {
+    type Type = ExprInner<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ParsedElem5CombinatorAlias = Mapped<ParsedElem5Combinator1, ParsedElem5Mapper>;
+}
+pub type ExprInnerCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<InstrCombinator>, ExprInnerCont0>, ExprInnerMapper>;
 
 
-pub open spec fn spec_parsed_elem5() -> SpecParsedElem5Combinator {
-    SpecParsedElem5Combinator(
+pub open spec fn spec_expr_inner() -> SpecExprInnerCombinator {
+    SpecExprInnerCombinator(
     Mapped {
-        inner: (spec_reftype(), spec_exprs()),
-        mapper: ParsedElem5Mapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_expr_inner_cont0(deps)),
+        mapper: ExprInnerMapper,
     })
 }
 
+pub open spec fn spec_expr_inner_cont0(deps: u64) -> RepeatN<SpecInstrCombinator> {
+    let l = deps;
+    RepeatN(spec_instr(), (usize::spec_from(l)) as usize)
+}
+
+impl View for ExprInnerCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecInstrCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_expr_inner_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn parsed_elem5<'a>() -> (o: ParsedElem5Combinator)
-    ensures o@ == spec_parsed_elem5(),
+pub fn expr_inner<'a>() -> (o: ExprInnerCombinator)
+    ensures o@ == spec_expr_inner(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ParsedElem5Combinator(
+    let combinator = ExprInnerCombinator(
     Mapped {
-        inner: ParsedElem5Combinator1((reftype(), exprs())),
-        mapper: ParsedElem5Mapper,
-    });
-    assert({
-        &&& combinator@ == spec_parsed_elem5()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, ExprInnerCont0),
+        mapper: ExprInnerMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_expr_inner()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_parsed_elem5<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem5Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_expr_inner<'a>(input: &'a [u8]) -> (res: PResult<<ExprInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_parsed_elem5().spec_parse(input@) == Some((n as int, v@)),
-        spec_parsed_elem5().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_expr_inner().spec_parse(input@) == Some((n as int, v@)),
+        spec_expr_inner().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_parsed_elem5().spec_parse(input@) is None,
-        spec_parsed_elem5().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_expr_inner().spec_parse(input@) is None,
+        spec_expr_inner().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = parsed_elem5();
+    let combinator = expr_inner();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_parsed_elem5<'a>(v: <ParsedElem5Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_expr_inner<'a>(v: <ExprInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_parsed_elem5().wf(v@),
+        spec_expr_inner().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_parsed_elem5().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem5().spec_serialize(v@))
+            &&& n == spec_expr_inner().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_expr_inner().spec_serialize(v@))
         },
 {
-    let combinator = parsed_elem5();
+    let combinator = expr_inner();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn parsed_elem5_len<'a>(v: <ParsedElem5Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn expr_inner_len<'a>(v: <ExprInnerCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_parsed_elem5().wf(v@),
-        spec_parsed_elem5().spec_serialize(v@).len() <= usize::MAX,
+        spec_expr_inner().wf(v@),
+        spec_expr_inner().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_parsed_elem5().spec_serialize(v@).len(),
+        serialize_len == spec_expr_inner().spec_serialize(v@).len(),
 {
-    let combinator = parsed_elem5();
+    let combinator = expr_inner();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
-
-pub struct SpecParsedElem6 {
-    pub table: SpecTableidx,
-    pub offset: SpecExpr,
-    pub et: SpecReftype,
-    pub init: SpecExprs,
-}
-
-pub type SpecParsedElem6Inner = (SpecTableidx, (SpecExpr, (SpecReftype, SpecExprs)));
-
+pub struct ExprInnerCont0;
+type ExprInnerCont0Type<'a, 'b> = &'b u64;
+type ExprInnerCont0SType<'a, 'x> = &'x u64;
+type ExprInnerCont0Input<'a, 'b, 'x> = POrSType<ExprInnerCont0Type<'a, 'b>, ExprInnerCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ExprInnerCont0Input<'a, 'b, 'x>> for ExprInnerCont0 {
+    type Output = RepeatN<InstrCombinator>;
 
-impl SpecFrom<SpecParsedElem6> for SpecParsedElem6Inner {
-    open spec fn spec_from(m: SpecParsedElem6) -> SpecParsedElem6Inner {
-        (m.table, (m.offset, (m.et, m.init)))
-    }
-}
+    open spec fn requires(&self, deps: ExprInnerCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-impl SpecFrom<SpecParsedElem6Inner> for SpecParsedElem6 {
-    open spec fn spec_from(m: SpecParsedElem6Inner) -> SpecParsedElem6 {
-        let (table, (offset, (et, init))) = m;
-        SpecParsedElem6 { table, offset, et, init }
+    open spec fn ensures(&self, deps: ExprInnerCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_expr_inner_cont0(deps@)
     }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct ParsedElem6<'a> {
-    pub table: Tableidx,
-    pub offset: Expr<'a>,
-    pub et: Reftype,
-    pub init: Exprs<'a>,
-}
-
-impl View for ParsedElem6<'_> {
-    type V = SpecParsedElem6;
 
-    open spec fn view(&self) -> Self::V {
-        SpecParsedElem6 {
-            table: self.table@,
-            offset: self.offset@,
-            et: self.et@,
-            init: self.init@,
+    fn apply(&self, deps: ExprInnerCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(instr(), (usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(instr(), (usize::ex_from(l)) as usize)
+            }
         }
     }
 }
-pub type ParsedElem6Inner<'a> = (Tableidx, (Expr<'a>, (Reftype, Exprs<'a>)));
+                
+pub type SpecExpr = SpecExprInner;
+pub type Expr<'a> = ExprInner<'a>;
+pub type ExprRef<'a> = &'a ExprInner<'a>;
 
-pub type ParsedElem6InnerRef<'a> = (&'a Tableidx, (&'a Expr<'a>, (&'a Reftype, &'a Exprs<'a>)));
-impl<'a> From<&'a ParsedElem6<'a>> for ParsedElem6InnerRef<'a> {
-    fn ex_from(m: &'a ParsedElem6) -> ParsedElem6InnerRef<'a> {
-        (&m.table, (&m.offset, (&m.et, &m.init)))
-    }
-}
 
-impl<'a> From<ParsedElem6Inner<'a>> for ParsedElem6<'a> {
-    fn ex_from(m: ParsedElem6Inner) -> ParsedElem6 {
-        let (table, (offset, (et, init))) = m;
-        ParsedElem6 { table, offset, et, init }
-    }
-}
+pub const Expr_0_BACK_CONST: u8 = 11;
 
-pub struct ParsedElem6Mapper;
-impl View for ParsedElem6Mapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ParsedElem6Mapper {
-    type Src = SpecParsedElem6Inner;
-    type Dst = SpecParsedElem6;
-}
-impl SpecIsoProof for ParsedElem6Mapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for ParsedElem6Mapper {
-    type Src = ParsedElem6Inner<'a>;
-    type Dst = ParsedElem6<'a>;
-    type RefSrc = ParsedElem6InnerRef<'a>;
-}
-type SpecParsedElem6CombinatorAlias1 = (SpecReftypeCombinator, SpecExprsCombinator);
-type SpecParsedElem6CombinatorAlias2 = (SpecExprCombinator, SpecParsedElem6CombinatorAlias1);
-type SpecParsedElem6CombinatorAlias3 = (SpecTableidxCombinator, SpecParsedElem6CombinatorAlias2);
-pub struct SpecParsedElem6Combinator(pub SpecParsedElem6CombinatorAlias);
+pub struct SpecExprCombinator(pub SpecExprCombinatorAlias);
 
-impl SpecCombinator for SpecParsedElem6Combinator {
-    type Type = SpecParsedElem6;
+impl SpecCombinator for SpecExprCombinator {
+    type Type = SpecExpr;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecParsedElem6Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecParsedElem6CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecExprCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecExprCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecParsedElem6CombinatorAlias = Mapped<SpecParsedElem6CombinatorAlias3, ParsedElem6Mapper>;
-type ParsedElem6CombinatorAlias1 = (ReftypeCombinator, ExprsCombinator);
-type ParsedElem6CombinatorAlias2 = (ExprCombinator, ParsedElem6Combinator1);
-type ParsedElem6CombinatorAlias3 = (TableidxCombinator, ParsedElem6Combinator2);
-pub struct ParsedElem6Combinator1(pub ParsedElem6CombinatorAlias1);
-impl View for ParsedElem6Combinator1 {
-    type V = SpecParsedElem6CombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ParsedElem6Combinator1, ParsedElem6CombinatorAlias1);
-
-pub struct ParsedElem6Combinator2(pub ParsedElem6CombinatorAlias2);
-impl View for ParsedElem6Combinator2 {
-    type V = SpecParsedElem6CombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ParsedElem6Combinator2, ParsedElem6CombinatorAlias2);
+pub type SpecExprCombinatorAlias = Terminated<SpecExprInnerCombinator, Tag<U8, u8>>;
 
-pub struct ParsedElem6Combinator3(pub ParsedElem6CombinatorAlias3);
-impl View for ParsedElem6Combinator3 {
-    type V = SpecParsedElem6CombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ParsedElem6Combinator3, ParsedElem6CombinatorAlias3);
 
-pub struct ParsedElem6Combinator(pub ParsedElem6CombinatorAlias);
+pub struct ExprCombinator(pub ExprCombinatorAlias);
 
-impl View for ParsedElem6Combinator {
-    type V = SpecParsedElem6Combinator;
-    open spec fn view(&self) -> Self::V { SpecParsedElem6Combinator(self.0@) }
+impl View for ExprCombinator {
+    type V = SpecExprCombinator;
+    open spec fn view(&self) -> Self::V { SpecExprCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem6Combinator {
-    type Type = ParsedElem6<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExprCombinator {
+    type Type = Expr<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ParsedElem6CombinatorAlias = Mapped<ParsedElem6Combinator3, ParsedElem6Mapper>;
+}
+pub type ExprCombinatorAlias = Terminated<ExprInnerCombinator, Tag<U8, u8>>;
 
 
-pub open spec fn spec_parsed_elem6() -> SpecParsedElem6Combinator {
-    SpecParsedElem6Combinator(
-    Mapped {
-        inner: (spec_tableidx(), (spec_expr(), (spec_reftype(), spec_exprs()))),
-        mapper: ParsedElem6Mapper,
-    })
+pub open spec fn spec_expr() -> SpecExprCombinator {
+    SpecExprCombinator(Terminated(spec_expr_inner(), Tag::spec_new(U8, Expr_0_BACK_CONST)))
 }
 
                 
-pub fn parsed_elem6<'a>() -> (o: ParsedElem6Combinator)
-    ensures o@ == spec_parsed_elem6(),
+pub fn expr<'a>() -> (o: ExprCombinator)
+    ensures o@ == spec_expr(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ParsedElem6Combinator(
-    Mapped {
-        inner: ParsedElem6Combinator3((tableidx(), ParsedElem6Combinator2((expr(), ParsedElem6Combinator1((reftype(), exprs())))))),
-        mapper: ParsedElem6Mapper,
-    });
-    assert({
-        &&& combinator@ == spec_parsed_elem6()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ExprCombinator(Terminated(expr_inner(), Tag::new(U8, Expr_0_BACK_CONST)));
+    // assert({
+    //     &&& combinator@ == spec_expr()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_parsed_elem6<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem6Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_expr<'a>(input: &'a [u8]) -> (res: PResult<<ExprCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_parsed_elem6().spec_parse(input@) == Some((n as int, v@)),
-        spec_parsed_elem6().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_expr().spec_parse(input@) == Some((n as int, v@)),
+        spec_expr().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_parsed_elem6().spec_parse(input@) is None,
-        spec_parsed_elem6().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_expr().spec_parse(input@) is None,
+        spec_expr().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = parsed_elem6();
+    let combinator = expr();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_parsed_elem6<'a>(v: <ParsedElem6Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_expr<'a>(v: <ExprCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_parsed_elem6().wf(v@),
+        spec_expr().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_parsed_elem6().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem6().spec_serialize(v@))
+            &&& n == spec_expr().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_expr().spec_serialize(v@))
         },
 {
-    let combinator = parsed_elem6();
+    let combinator = expr();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn parsed_elem6_len<'a>(v: <ParsedElem6Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn expr_len<'a>(v: <ExprCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_parsed_elem6().wf(v@),
-        spec_parsed_elem6().spec_serialize(v@).len() <= usize::MAX,
+        spec_expr().wf(v@),
+        spec_expr().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_parsed_elem6().spec_serialize(v@).len(),
+        serialize_len == spec_expr().spec_serialize(v@).len(),
 {
-    let combinator = parsed_elem6();
+    let combinator = expr();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecParsedElem7 {
-    pub et: SpecReftype,
-    pub init: SpecExprs,
+pub struct SpecByteVec {
+    pub l: u64,
+    pub v: Seq<u8>,
 }
 
-pub type SpecParsedElem7Inner = (SpecReftype, SpecExprs);
+pub type SpecByteVecInner = (u64, Seq<u8>);
 
 
-impl SpecFrom<SpecParsedElem7> for SpecParsedElem7Inner {
-    open spec fn spec_from(m: SpecParsedElem7) -> SpecParsedElem7Inner {
-        (m.et, m.init)
+impl SpecFrom<SpecByteVec> for SpecByteVecInner {
+    open spec fn spec_from(m: SpecByteVec) -> SpecByteVecInner {
+        (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecParsedElem7Inner> for SpecParsedElem7 {
-    open spec fn spec_from(m: SpecParsedElem7Inner) -> SpecParsedElem7 {
-        let (et, init) = m;
-        SpecParsedElem7 { et, init }
+impl SpecFrom<SpecByteVecInner> for SpecByteVec {
+    open spec fn spec_from(m: SpecByteVecInner) -> SpecByteVec {
+        let (l, v) = m;
+        SpecByteVec { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ParsedElem7<'a> {
-    pub et: Reftype,
-    pub init: Exprs<'a>,
+pub struct ByteVec {
+    pub l: u64,
+    pub v: RepeatResult<u8>,
 }
 
-impl View for ParsedElem7<'_> {
-    type V = SpecParsedElem7;
+impl View for ByteVec {
+    type V = SpecByteVec;
 
     open spec fn view(&self) -> Self::V {
-        SpecParsedElem7 {
-            et: self.et@,
-            init: self.init@,
+        SpecByteVec {
+            l: self.l@,
+            v: self.v@,
         }
     }
 }
-pub type ParsedElem7Inner<'a> = (Reftype, Exprs<'a>);
+pub type ByteVecInner = (u64, RepeatResult<u8>);
 
-pub type ParsedElem7InnerRef<'a> = (&'a Reftype, &'a Exprs<'a>);
-impl<'a> From<&'a ParsedElem7<'a>> for ParsedElem7InnerRef<'a> {
-    fn ex_from(m: &'a ParsedElem7) -> ParsedElem7InnerRef<'a> {
-        (&m.et, &m.init)
+pub type ByteVecInnerRef<'a> = (&'a u64, &'a RepeatResult<u8>);
+impl<'a> From<&'a ByteVec> for ByteVecInnerRef<'a> {
+    fn ex_from(m: &'a ByteVec) -> ByteVecInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-impl<'a> From<ParsedElem7Inner<'a>> for ParsedElem7<'a> {
-    fn ex_from(m: ParsedElem7Inner) -> ParsedElem7 {
-        let (et, init) = m;
-        ParsedElem7 { et, init }
+impl From<ByteVecInner> for ByteVec {
+    fn ex_from(m: ByteVecInner) -> ByteVec {
+        let (l, v) = m;
+        ByteVec { l, v }
     }
 }
 
-pub struct ParsedElem7Mapper;
-impl View for ParsedElem7Mapper {
+pub struct ByteVecMapper;
+impl View for ByteVecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ParsedElem7Mapper {
-    type Src = SpecParsedElem7Inner;
-    type Dst = SpecParsedElem7;
+impl SpecIso for ByteVecMapper {
+    type Src = SpecByteVecInner;
+    type Dst = SpecByteVec;
 }
-impl SpecIsoProof for ParsedElem7Mapper {
+impl SpecIsoProof for ByteVecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -13271,268 +13271,248 @@ impl SpecIsoProof for ParsedElem7Mapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ParsedElem7Mapper {
-    type Src = ParsedElem7Inner<'a>;
-    type Dst = ParsedElem7<'a>;
-    type RefSrc = ParsedElem7InnerRef<'a>;
+impl<'a> Iso<'a> for ByteVecMapper {
+    type Src = ByteVecInner;
+    type Dst = ByteVec;
+    type RefSrc = ByteVecInnerRef<'a>;
 }
-type SpecParsedElem7CombinatorAlias1 = (SpecReftypeCombinator, SpecExprsCombinator);
-pub struct SpecParsedElem7Combinator(pub SpecParsedElem7CombinatorAlias);
 
-impl SpecCombinator for SpecParsedElem7Combinator {
-    type Type = SpecParsedElem7;
+pub struct SpecByteVecCombinator(pub SpecByteVecCombinatorAlias);
+
+impl SpecCombinator for SpecByteVecCombinator {
+    type Type = SpecByteVec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecParsedElem7Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecParsedElem7CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecByteVecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecByteVecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecParsedElem7CombinatorAlias = Mapped<SpecParsedElem7CombinatorAlias1, ParsedElem7Mapper>;
-type ParsedElem7CombinatorAlias1 = (ReftypeCombinator, ExprsCombinator);
-pub struct ParsedElem7Combinator1(pub ParsedElem7CombinatorAlias1);
-impl View for ParsedElem7Combinator1 {
-    type V = SpecParsedElem7CombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ParsedElem7Combinator1, ParsedElem7CombinatorAlias1);
+pub type SpecByteVecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<U8>>, ByteVecMapper>;
 
-pub struct ParsedElem7Combinator(pub ParsedElem7CombinatorAlias);
+pub struct ByteVecCombinator(pub ByteVecCombinatorAlias);
 
-impl View for ParsedElem7Combinator {
-    type V = SpecParsedElem7Combinator;
-    open spec fn view(&self) -> Self::V { SpecParsedElem7Combinator(self.0@) }
+impl View for ByteVecCombinator {
+    type V = SpecByteVecCombinator;
+    open spec fn view(&self) -> Self::V { SpecByteVecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem7Combinator {
-    type Type = ParsedElem7<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ByteVecCombinator {
+    type Type = ByteVec;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ParsedElem7CombinatorAlias = Mapped<ParsedElem7Combinator1, ParsedElem7Mapper>;
+}
+pub type ByteVecCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<U8>, ByteVecCont0>, ByteVecMapper>;
 
 
-pub open spec fn spec_parsed_elem7() -> SpecParsedElem7Combinator {
-    SpecParsedElem7Combinator(
+pub open spec fn spec_byte_vec() -> SpecByteVecCombinator {
+    SpecByteVecCombinator(
     Mapped {
-        inner: (spec_reftype(), spec_exprs()),
-        mapper: ParsedElem7Mapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_byte_vec_cont0(deps)),
+        mapper: ByteVecMapper,
     })
 }
 
+pub open spec fn spec_byte_vec_cont0(deps: u64) -> RepeatN<U8> {
+    let l = deps;
+    RepeatN(U8, (usize::spec_from(l)) as usize)
+}
+
+impl View for ByteVecCont0 {
+    type V = spec_fn(u64) -> RepeatN<U8>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_byte_vec_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn parsed_elem7<'a>() -> (o: ParsedElem7Combinator)
-    ensures o@ == spec_parsed_elem7(),
+pub fn byte_vec<'a>() -> (o: ByteVecCombinator)
+    ensures o@ == spec_byte_vec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ParsedElem7Combinator(
+    let combinator = ByteVecCombinator(
     Mapped {
-        inner: ParsedElem7Combinator1((reftype(), exprs())),
-        mapper: ParsedElem7Mapper,
-    });
-    assert({
-        &&& combinator@ == spec_parsed_elem7()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, ByteVecCont0),
+        mapper: ByteVecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_byte_vec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_parsed_elem7<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem7Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_byte_vec<'a>(input: &'a [u8]) -> (res: PResult<<ByteVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_parsed_elem7().spec_parse(input@) == Some((n as int, v@)),
-        spec_parsed_elem7().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_byte_vec().spec_parse(input@) == Some((n as int, v@)),
+        spec_byte_vec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_parsed_elem7().spec_parse(input@) is None,
-        spec_parsed_elem7().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_byte_vec().spec_parse(input@) is None,
+        spec_byte_vec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = parsed_elem7();
+    let combinator = byte_vec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_parsed_elem7<'a>(v: <ParsedElem7Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_byte_vec<'a>(v: <ByteVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_parsed_elem7().wf(v@),
+        spec_byte_vec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_parsed_elem7().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem7().spec_serialize(v@))
+            &&& n == spec_byte_vec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_byte_vec().spec_serialize(v@))
         },
 {
-    let combinator = parsed_elem7();
+    let combinator = byte_vec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn parsed_elem7_len<'a>(v: <ParsedElem7Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn byte_vec_len<'a>(v: <ByteVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_parsed_elem7().wf(v@),
-        spec_parsed_elem7().spec_serialize(v@).len() <= usize::MAX,
+        spec_byte_vec().wf(v@),
+        spec_byte_vec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_parsed_elem7().spec_serialize(v@).len(),
+        serialize_len == spec_byte_vec().spec_serialize(v@).len(),
 {
-    let combinator = parsed_elem7();
+    let combinator = byte_vec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
-}
-
-                
-
-pub enum SpecElem {
-    Elem0(SpecParsedElem0),
-    Elem1(SpecParsedElem1),
-    Elem2(SpecParsedElem2),
-    Elem3(SpecParsedElem3),
-    Elem4(SpecParsedElem4),
-    Elem5(SpecParsedElem5),
-    Elem6(SpecParsedElem6),
-    Elem7(SpecParsedElem7),
-}
-
-pub type SpecElemInner = Either<SpecParsedElem0, Either<SpecParsedElem1, Either<SpecParsedElem2, Either<SpecParsedElem3, Either<SpecParsedElem4, Either<SpecParsedElem5, Either<SpecParsedElem6, SpecParsedElem7>>>>>>>;
-
-impl SpecFrom<SpecElem> for SpecElemInner {
-    open spec fn spec_from(m: SpecElem) -> SpecElemInner {
-        match m {
-            SpecElem::Elem0(m) => Either::Left(m),
-            SpecElem::Elem1(m) => Either::Right(Either::Left(m)),
-            SpecElem::Elem2(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecElem::Elem3(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            SpecElem::Elem4(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            SpecElem::Elem5(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            SpecElem::Elem6(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
-            SpecElem::Elem7(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))),
+}
+
+pub struct ByteVecCont0;
+type ByteVecCont0Type<'a, 'b> = &'b u64;
+type ByteVecCont0SType<'a, 'x> = &'x u64;
+type ByteVecCont0Input<'a, 'b, 'x> = POrSType<ByteVecCont0Type<'a, 'b>, ByteVecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ByteVecCont0Input<'a, 'b, 'x>> for ByteVecCont0 {
+    type Output = RepeatN<U8>;
+
+    open spec fn requires(&self, deps: ByteVecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
         }
-    }
 
-}
+    open spec fn ensures(&self, deps: ByteVecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_byte_vec_cont0(deps@)
+    }
 
-                
-impl SpecFrom<SpecElemInner> for SpecElem {
-    open spec fn spec_from(m: SpecElemInner) -> SpecElem {
-        match m {
-            Either::Left(m) => SpecElem::Elem0(m),
-            Either::Right(Either::Left(m)) => SpecElem::Elem1(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecElem::Elem2(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecElem::Elem3(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecElem::Elem4(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecElem::Elem5(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => SpecElem::Elem6(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))) => SpecElem::Elem7(m),
+    fn apply(&self, deps: ByteVecCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(U8, (usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(U8, (usize::ex_from(l)) as usize)
+            }
         }
     }
+}
+                
 
+pub struct SpecActiveDatax {
+    pub memory: SpecMemidx,
+    pub offset: SpecExpr,
+    pub init: SpecByteVec,
 }
 
+pub type SpecActiveDataxInner = (SpecMemidx, (SpecExpr, SpecByteVec));
 
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Elem<'a> {
-    Elem0(ParsedElem0<'a>),
-    Elem1(ParsedElem1),
-    Elem2(ParsedElem2<'a>),
-    Elem3(ParsedElem3),
-    Elem4(ParsedElem4<'a>),
-    Elem5(ParsedElem5<'a>),
-    Elem6(ParsedElem6<'a>),
-    Elem7(ParsedElem7<'a>),
+impl SpecFrom<SpecActiveDatax> for SpecActiveDataxInner {
+    open spec fn spec_from(m: SpecActiveDatax) -> SpecActiveDataxInner {
+        (m.memory, (m.offset, m.init))
+    }
 }
 
-pub type ElemInner<'a> = Either<ParsedElem0<'a>, Either<ParsedElem1, Either<ParsedElem2<'a>, Either<ParsedElem3, Either<ParsedElem4<'a>, Either<ParsedElem5<'a>, Either<ParsedElem6<'a>, ParsedElem7<'a>>>>>>>>;
+impl SpecFrom<SpecActiveDataxInner> for SpecActiveDatax {
+    open spec fn spec_from(m: SpecActiveDataxInner) -> SpecActiveDatax {
+        let (memory, (offset, init)) = m;
+        SpecActiveDatax { memory, offset, init }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub type ElemInnerRef<'a> = Either<&'a ParsedElem0<'a>, Either<&'a ParsedElem1, Either<&'a ParsedElem2<'a>, Either<&'a ParsedElem3, Either<&'a ParsedElem4<'a>, Either<&'a ParsedElem5<'a>, Either<&'a ParsedElem6<'a>, &'a ParsedElem7<'a>>>>>>>>;
+pub struct ActiveDatax<'a> {
+    pub memory: Memidx,
+    pub offset: Expr<'a>,
+    pub init: ByteVec,
+}
 
+impl View for ActiveDatax<'_> {
+    type V = SpecActiveDatax;
 
-impl<'a> View for Elem<'a> {
-    type V = SpecElem;
     open spec fn view(&self) -> Self::V {
-        match self {
-            Elem::Elem0(m) => SpecElem::Elem0(m@),
-            Elem::Elem1(m) => SpecElem::Elem1(m@),
-            Elem::Elem2(m) => SpecElem::Elem2(m@),
-            Elem::Elem3(m) => SpecElem::Elem3(m@),
-            Elem::Elem4(m) => SpecElem::Elem4(m@),
-            Elem::Elem5(m) => SpecElem::Elem5(m@),
-            Elem::Elem6(m) => SpecElem::Elem6(m@),
-            Elem::Elem7(m) => SpecElem::Elem7(m@),
+        SpecActiveDatax {
+            memory: self.memory@,
+            offset: self.offset@,
+            init: self.init@,
         }
     }
 }
+pub type ActiveDataxInner<'a> = (Memidx, (Expr<'a>, ByteVec));
 
-
-impl<'a> From<&'a Elem<'a>> for ElemInnerRef<'a> {
-    fn ex_from(m: &'a Elem<'a>) -> ElemInnerRef<'a> {
-        match m {
-            Elem::Elem0(m) => Either::Left(m),
-            Elem::Elem1(m) => Either::Right(Either::Left(m)),
-            Elem::Elem2(m) => Either::Right(Either::Right(Either::Left(m))),
-            Elem::Elem3(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
-            Elem::Elem4(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
-            Elem::Elem5(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
-            Elem::Elem6(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
-            Elem::Elem7(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))),
-        }
+pub type ActiveDataxInnerRef<'a> = (&'a Memidx, (&'a Expr<'a>, &'a ByteVec));
+impl<'a> From<&'a ActiveDatax<'a>> for ActiveDataxInnerRef<'a> {
+    fn ex_from(m: &'a ActiveDatax) -> ActiveDataxInnerRef<'a> {
+        (&m.memory, (&m.offset, &m.init))
     }
-
 }
 
-impl<'a> From<ElemInner<'a>> for Elem<'a> {
-    fn ex_from(m: ElemInner<'a>) -> Elem<'a> {
-        match m {
-            Either::Left(m) => Elem::Elem0(m),
-            Either::Right(Either::Left(m)) => Elem::Elem1(m),
-            Either::Right(Either::Right(Either::Left(m))) => Elem::Elem2(m),
-            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => Elem::Elem3(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => Elem::Elem4(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => Elem::Elem5(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => Elem::Elem6(m),
-            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))) => Elem::Elem7(m),
-        }
+impl<'a> From<ActiveDataxInner<'a>> for ActiveDatax<'a> {
+    fn ex_from(m: ActiveDataxInner) -> ActiveDatax {
+        let (memory, (offset, init)) = m;
+        ActiveDatax { memory, offset, init }
     }
-    
 }
 
-
-pub struct ElemMapper;
-impl View for ElemMapper {
+pub struct ActiveDataxMapper;
+impl View for ActiveDataxMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ElemMapper {
-    type Src = SpecElemInner;
-    type Dst = SpecElem;
+impl SpecIso for ActiveDataxMapper {
+    type Src = SpecActiveDataxInner;
+    type Dst = SpecActiveDatax;
 }
-impl SpecIsoProof for ElemMapper {
+impl SpecIsoProof for ActiveDataxMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -13540,519 +13520,367 @@ impl SpecIsoProof for ElemMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ElemMapper {
-    type Src = ElemInner<'a>;
-    type Dst = Elem<'a>;
-    type RefSrc = ElemInnerRef<'a>;
+impl<'a> Iso<'a> for ActiveDataxMapper {
+    type Src = ActiveDataxInner<'a>;
+    type Dst = ActiveDatax<'a>;
+    type RefSrc = ActiveDataxInnerRef<'a>;
 }
+type SpecActiveDataxCombinatorAlias1 = (SpecExprCombinator, SpecByteVecCombinator);
+type SpecActiveDataxCombinatorAlias2 = (SpecMemidxCombinator, SpecActiveDataxCombinatorAlias1);
+pub struct SpecActiveDataxCombinator(pub SpecActiveDataxCombinatorAlias);
 
-pub const ELEMELEM0_0_FRONT_CONST: u64 = 0;
-
-pub const ELEMELEM1_0_FRONT_CONST: u64 = 1;
-
-pub const ELEMELEM2_0_FRONT_CONST: u64 = 2;
-
-pub const ELEMELEM3_0_FRONT_CONST: u64 = 3;
-
-pub const ELEMELEM4_0_FRONT_CONST: u64 = 4;
-
-pub const ELEMELEM5_0_FRONT_CONST: u64 = 5;
-
-pub const ELEMELEM6_0_FRONT_CONST: u64 = 6;
-
-pub const ELEMELEM7_0_FRONT_CONST: u64 = 7;
-
-type SpecElemCombinatorAlias1 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem6Combinator>, Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem7Combinator>>;
-type SpecElemCombinatorAlias2 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem5Combinator>, SpecElemCombinatorAlias1>;
-type SpecElemCombinatorAlias3 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem4Combinator>, SpecElemCombinatorAlias2>;
-type SpecElemCombinatorAlias4 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem3Combinator>, SpecElemCombinatorAlias3>;
-type SpecElemCombinatorAlias5 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem2Combinator>, SpecElemCombinatorAlias4>;
-type SpecElemCombinatorAlias6 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem1Combinator>, SpecElemCombinatorAlias5>;
-type SpecElemCombinatorAlias7 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem0Combinator>, SpecElemCombinatorAlias6>;
-pub struct SpecElemCombinator(pub SpecElemCombinatorAlias);
-
-impl SpecCombinator for SpecElemCombinator {
-    type Type = SpecElem;
+impl SpecCombinator for SpecActiveDataxCombinator {
+    type Type = SpecActiveDatax;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecElemCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecElemCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecActiveDataxCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecActiveDataxCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecElemCombinatorAlias = Mapped<SpecElemCombinatorAlias7, ElemMapper>;
-
-
-
-
-
-
-
-
-type ElemCombinatorAlias1 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem6Combinator>, Preceded<Tag<UnsignedLEB128, u64>, ParsedElem7Combinator>>;
-type ElemCombinatorAlias2 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem5Combinator>, ElemCombinator1>;
-type ElemCombinatorAlias3 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem4Combinator>, ElemCombinator2>;
-type ElemCombinatorAlias4 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem3Combinator>, ElemCombinator3>;
-type ElemCombinatorAlias5 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem2Combinator>, ElemCombinator4>;
-type ElemCombinatorAlias6 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem1Combinator>, ElemCombinator5>;
-type ElemCombinatorAlias7 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem0Combinator>, ElemCombinator6>;
-pub struct ElemCombinator1(pub ElemCombinatorAlias1);
-impl View for ElemCombinator1 {
-    type V = SpecElemCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ElemCombinator1, ElemCombinatorAlias1);
-
-pub struct ElemCombinator2(pub ElemCombinatorAlias2);
-impl View for ElemCombinator2 {
-    type V = SpecElemCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ElemCombinator2, ElemCombinatorAlias2);
-
-pub struct ElemCombinator3(pub ElemCombinatorAlias3);
-impl View for ElemCombinator3 {
-    type V = SpecElemCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ElemCombinator3, ElemCombinatorAlias3);
-
-pub struct ElemCombinator4(pub ElemCombinatorAlias4);
-impl View for ElemCombinator4 {
-    type V = SpecElemCombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ElemCombinator4, ElemCombinatorAlias4);
-
-pub struct ElemCombinator5(pub ElemCombinatorAlias5);
-impl View for ElemCombinator5 {
-    type V = SpecElemCombinatorAlias5;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ElemCombinator5, ElemCombinatorAlias5);
-
-pub struct ElemCombinator6(pub ElemCombinatorAlias6);
-impl View for ElemCombinator6 {
-    type V = SpecElemCombinatorAlias6;
+pub type SpecActiveDataxCombinatorAlias = Mapped<SpecActiveDataxCombinatorAlias2, ActiveDataxMapper>;
+type ActiveDataxCombinatorAlias1 = (ExprCombinator, ByteVecCombinator);
+type ActiveDataxCombinatorAlias2 = (MemidxCombinator, ActiveDataxCombinator1);
+pub struct ActiveDataxCombinator1(pub ActiveDataxCombinatorAlias1);
+impl View for ActiveDataxCombinator1 {
+    type V = SpecActiveDataxCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ElemCombinator6, ElemCombinatorAlias6);
+impl_wrapper_combinator!(ActiveDataxCombinator1, ActiveDataxCombinatorAlias1);
 
-pub struct ElemCombinator7(pub ElemCombinatorAlias7);
-impl View for ElemCombinator7 {
-    type V = SpecElemCombinatorAlias7;
+pub struct ActiveDataxCombinator2(pub ActiveDataxCombinatorAlias2);
+impl View for ActiveDataxCombinator2 {
+    type V = SpecActiveDataxCombinatorAlias2;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ElemCombinator7, ElemCombinatorAlias7);
-
-pub struct ElemCombinator(pub ElemCombinatorAlias);
+impl_wrapper_combinator!(ActiveDataxCombinator2, ActiveDataxCombinatorAlias2);
 
-impl View for ElemCombinator {
-    type V = SpecElemCombinator;
-    open spec fn view(&self) -> Self::V { SpecElemCombinator(self.0@) }
+pub struct ActiveDataxCombinator(pub ActiveDataxCombinatorAlias);
+
+impl View for ActiveDataxCombinator {
+    type V = SpecActiveDataxCombinator;
+    open spec fn view(&self) -> Self::V { SpecActiveDataxCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ElemCombinator {
-    type Type = Elem<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ActiveDataxCombinator {
+    type Type = ActiveDatax<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ElemCombinatorAlias = Mapped<ElemCombinator7, ElemMapper>;
+}
+pub type ActiveDataxCombinatorAlias = Mapped<ActiveDataxCombinator2, ActiveDataxMapper>;
 
 
-pub open spec fn spec_elem() -> SpecElemCombinator {
-    SpecElemCombinator(Mapped { inner: Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM0_0_FRONT_CONST), spec_parsed_elem0()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM1_0_FRONT_CONST), spec_parsed_elem1()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM2_0_FRONT_CONST), spec_parsed_elem2()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM3_0_FRONT_CONST), spec_parsed_elem3()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM4_0_FRONT_CONST), spec_parsed_elem4()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM5_0_FRONT_CONST), spec_parsed_elem5()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM6_0_FRONT_CONST), spec_parsed_elem6()), Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM7_0_FRONT_CONST), spec_parsed_elem7())))))))), mapper: ElemMapper })
+pub open spec fn spec_active_datax() -> SpecActiveDataxCombinator {
+    SpecActiveDataxCombinator(
+    Mapped {
+        inner: (spec_memidx(), (spec_expr(), spec_byte_vec())),
+        mapper: ActiveDataxMapper,
+    })
 }
 
                 
-pub fn elem<'a>() -> (o: ElemCombinator)
-    ensures o@ == spec_elem(),
+pub fn active_datax<'a>() -> (o: ActiveDataxCombinator)
+    ensures o@ == spec_active_datax(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ElemCombinator(Mapped { inner: ElemCombinator7(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM0_0_FRONT_CONST), parsed_elem0()), ElemCombinator6(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM1_0_FRONT_CONST), parsed_elem1()), ElemCombinator5(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM2_0_FRONT_CONST), parsed_elem2()), ElemCombinator4(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM3_0_FRONT_CONST), parsed_elem3()), ElemCombinator3(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM4_0_FRONT_CONST), parsed_elem4()), ElemCombinator2(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM5_0_FRONT_CONST), parsed_elem5()), ElemCombinator1(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM6_0_FRONT_CONST), parsed_elem6()), Preceded(Tag::new(UnsignedLEB128, ELEMELEM7_0_FRONT_CONST), parsed_elem7()))))))))))))))), mapper: ElemMapper });
-    assert({
-        &&& combinator@ == spec_elem()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ActiveDataxCombinator(
+    Mapped {
+        inner: ActiveDataxCombinator2((memidx(), ActiveDataxCombinator1((expr(), byte_vec())))),
+        mapper: ActiveDataxMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_active_datax()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_elem<'a>(input: &'a [u8]) -> (res: PResult<<ElemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_active_datax<'a>(input: &'a [u8]) -> (res: PResult<<ActiveDataxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_elem().spec_parse(input@) == Some((n as int, v@)),
-        spec_elem().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_active_datax().spec_parse(input@) == Some((n as int, v@)),
+        spec_active_datax().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_elem().spec_parse(input@) is None,
-        spec_elem().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_active_datax().spec_parse(input@) is None,
+        spec_active_datax().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = elem();
+    let combinator = active_datax();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_elem<'a>(v: <ElemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_active_datax<'a>(v: <ActiveDataxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_elem().wf(v@),
+        spec_active_datax().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_elem().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_elem().spec_serialize(v@))
+            &&& n == spec_active_datax().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_active_datax().spec_serialize(v@))
         },
 {
-    let combinator = elem();
+    let combinator = active_datax();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn elem_len<'a>(v: <ElemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn active_datax_len<'a>(v: <ActiveDataxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_elem().wf(v@),
-        spec_elem().spec_serialize(v@).len() <= usize::MAX,
+        spec_active_datax().wf(v@),
+        spec_active_datax().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_elem().spec_serialize(v@).len(),
+        serialize_len == spec_active_datax().spec_serialize(v@).len(),
 {
-    let combinator = elem();
+    let combinator = active_datax();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
+pub type SpecName = SpecByteVec;
+pub type Name = ByteVec;
+pub type NameRef<'a> = &'a ByteVec;
 
-pub struct SpecElemsecContent {
-    pub l: u64,
-    pub v: Seq<SpecElem>,
-}
-
-pub type SpecElemsecContentInner = (u64, Seq<SpecElem>);
-
-
-impl SpecFrom<SpecElemsecContent> for SpecElemsecContentInner {
-    open spec fn spec_from(m: SpecElemsecContent) -> SpecElemsecContentInner {
-        (m.l, m.v)
-    }
-}
-
-impl SpecFrom<SpecElemsecContentInner> for SpecElemsecContent {
-    open spec fn spec_from(m: SpecElemsecContentInner) -> SpecElemsecContent {
-        let (l, v) = m;
-        SpecElemsecContent { l, v }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct ElemsecContent<'a> {
-    pub l: u64,
-    pub v: RepeatResult<Elem<'a>>,
-}
-
-impl View for ElemsecContent<'_> {
-    type V = SpecElemsecContent;
-
-    open spec fn view(&self) -> Self::V {
-        SpecElemsecContent {
-            l: self.l@,
-            v: self.v@,
-        }
-    }
-}
-pub type ElemsecContentInner<'a> = (u64, RepeatResult<Elem<'a>>);
-
-pub type ElemsecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Elem<'a>>);
-impl<'a> From<&'a ElemsecContent<'a>> for ElemsecContentInnerRef<'a> {
-    fn ex_from(m: &'a ElemsecContent) -> ElemsecContentInnerRef<'a> {
-        (&m.l, &m.v)
-    }
-}
-
-impl<'a> From<ElemsecContentInner<'a>> for ElemsecContent<'a> {
-    fn ex_from(m: ElemsecContentInner) -> ElemsecContent {
-        let (l, v) = m;
-        ElemsecContent { l, v }
-    }
-}
-
-pub struct ElemsecContentMapper;
-impl View for ElemsecContentMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ElemsecContentMapper {
-    type Src = SpecElemsecContentInner;
-    type Dst = SpecElemsecContent;
-}
-impl SpecIsoProof for ElemsecContentMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for ElemsecContentMapper {
-    type Src = ElemsecContentInner<'a>;
-    type Dst = ElemsecContent<'a>;
-    type RefSrc = ElemsecContentInnerRef<'a>;
-}
 
-pub struct SpecElemsecContentCombinator(pub SpecElemsecContentCombinatorAlias);
+pub struct SpecNameCombinator(pub SpecNameCombinatorAlias);
 
-impl SpecCombinator for SpecElemsecContentCombinator {
-    type Type = SpecElemsecContent;
+impl SpecCombinator for SpecNameCombinator {
+    type Type = SpecName;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecElemsecContentCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecElemsecContentCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecNameCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecNameCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecElemsecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecElemCombinator>>, ElemsecContentMapper>;
+pub type SpecNameCombinatorAlias = SpecByteVecCombinator;
 
-pub struct ElemsecContentCombinator(pub ElemsecContentCombinatorAlias);
+pub struct NameCombinator(pub NameCombinatorAlias);
 
-impl View for ElemsecContentCombinator {
-    type V = SpecElemsecContentCombinator;
-    open spec fn view(&self) -> Self::V { SpecElemsecContentCombinator(self.0@) }
+impl View for NameCombinator {
+    type V = SpecNameCombinator;
+    open spec fn view(&self) -> Self::V { SpecNameCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ElemsecContentCombinator {
-    type Type = ElemsecContent<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NameCombinator {
+    type Type = Name;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ElemsecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ElemCombinator>, ElemsecContentCont0>, ElemsecContentMapper>;
-
-
-pub open spec fn spec_elemsec_content() -> SpecElemsecContentCombinator {
-    SpecElemsecContentCombinator(
-    Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_elemsec_content_cont0(deps)),
-        mapper: ElemsecContentMapper,
-    })
-}
-
-pub open spec fn spec_elemsec_content_cont0(deps: u64) -> RepeatN<SpecElemCombinator> {
-    let l = deps;
-    RepeatN(spec_elem(), l.spec_into())
 }
+pub type NameCombinatorAlias = ByteVecCombinator;
 
-impl View for ElemsecContentCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecElemCombinator>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_elemsec_content_cont0(deps)
-        }
-    }
+pub open spec fn spec_name() -> SpecNameCombinator {
+    SpecNameCombinator(spec_byte_vec())
 }
 
                 
-pub fn elemsec_content<'a>() -> (o: ElemsecContentCombinator)
-    ensures o@ == spec_elemsec_content(),
+pub fn name<'a>() -> (o: NameCombinator)
+    ensures o@ == spec_name(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ElemsecContentCombinator(
-    Mapped {
-        inner: Pair::new(UnsignedLEB128, ElemsecContentCont0),
-        mapper: ElemsecContentMapper,
-    });
-    assert({
-        &&& combinator@ == spec_elemsec_content()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = NameCombinator(byte_vec());
+    // assert({
+    //     &&& combinator@ == spec_name()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_elemsec_content<'a>(input: &'a [u8]) -> (res: PResult<<ElemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_name<'a>(input: &'a [u8]) -> (res: PResult<<NameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_elemsec_content().spec_parse(input@) == Some((n as int, v@)),
-        spec_elemsec_content().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_name().spec_parse(input@) == Some((n as int, v@)),
+        spec_name().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_elemsec_content().spec_parse(input@) is None,
-        spec_elemsec_content().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_name().spec_parse(input@) is None,
+        spec_name().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = elemsec_content();
+    let combinator = name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_elemsec_content<'a>(v: <ElemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_name<'a>(v: <NameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_elemsec_content().wf(v@),
+        spec_name().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_elemsec_content().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_elemsec_content().spec_serialize(v@))
+            &&& n == spec_name().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_name().spec_serialize(v@))
         },
 {
-    let combinator = elemsec_content();
+    let combinator = name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn elemsec_content_len<'a>(v: <ElemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn name_len<'a>(v: <NameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_elemsec_content().wf(v@),
-        spec_elemsec_content().spec_serialize(v@).len() <= usize::MAX,
+        spec_name().wf(v@),
+        spec_name().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_elemsec_content().spec_serialize(v@).len(),
+        serialize_len == spec_name().spec_serialize(v@).len(),
 {
-    let combinator = elemsec_content();
+    let combinator = name();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ElemsecContentCont0;
-type ElemsecContentCont0Type<'a, 'b> = &'b u64;
-type ElemsecContentCont0SType<'a, 'x> = &'x u64;
-type ElemsecContentCont0Input<'a, 'b, 'x> = POrSType<ElemsecContentCont0Type<'a, 'b>, ElemsecContentCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ElemsecContentCont0Input<'a, 'b, 'x>> for ElemsecContentCont0 {
-    type Output = RepeatN<ElemCombinator>;
+                
 
-    open spec fn requires(&self, deps: ElemsecContentCont0Input<'a, 'b, 'x>) -> bool { true }
+pub enum SpecExportdesc {
+    Func(SpecFuncidx),
+    Table(SpecTableidx),
+    Mem(SpecMemidx),
+    Global(SpecGlobalidx),
+}
 
-    open spec fn ensures(&self, deps: ElemsecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_elemsec_content_cont0(deps@)
-    }
+pub type SpecExportdescInner = Either<SpecFuncidx, Either<SpecTableidx, Either<SpecMemidx, SpecGlobalidx>>>;
 
-    fn apply(&self, deps: ElemsecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(elem(), l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(elem(), l.ex_into())
-            }
+impl SpecFrom<SpecExportdesc> for SpecExportdescInner {
+    open spec fn spec_from(m: SpecExportdesc) -> SpecExportdescInner {
+        match m {
+            SpecExportdesc::Func(m) => Either::Left(m),
+            SpecExportdesc::Table(m) => Either::Right(Either::Left(m)),
+            SpecExportdesc::Mem(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecExportdesc::Global(m) => Either::Right(Either::Right(Either::Right(m))),
         }
     }
+
 }
+
                 
+impl SpecFrom<SpecExportdescInner> for SpecExportdesc {
+    open spec fn spec_from(m: SpecExportdescInner) -> SpecExportdesc {
+        match m {
+            Either::Left(m) => SpecExportdesc::Func(m),
+            Either::Right(Either::Left(m)) => SpecExportdesc::Table(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecExportdesc::Mem(m),
+            Either::Right(Either::Right(Either::Right(m))) => SpecExportdesc::Global(m),
+        }
+    }
 
-pub struct SpecElemsec {
-    pub size: u64,
-    pub cont: SpecElemsecContent,
 }
 
-pub type SpecElemsecInner = (u64, SpecElemsecContent);
 
 
-impl SpecFrom<SpecElemsec> for SpecElemsecInner {
-    open spec fn spec_from(m: SpecElemsec) -> SpecElemsecInner {
-        (m.size, m.cont)
-    }
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Exportdesc {
+    Func(Funcidx),
+    Table(Tableidx),
+    Mem(Memidx),
+    Global(Globalidx),
 }
 
-impl SpecFrom<SpecElemsecInner> for SpecElemsec {
-    open spec fn spec_from(m: SpecElemsecInner) -> SpecElemsec {
-        let (size, cont) = m;
-        SpecElemsec { size, cont }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
+pub type ExportdescInner = Either<Funcidx, Either<Tableidx, Either<Memidx, Globalidx>>>;
 
-pub struct Elemsec<'a> {
-    pub size: u64,
-    pub cont: ElemsecContent<'a>,
-}
+pub type ExportdescInnerRef<'a> = Either<&'a Funcidx, Either<&'a Tableidx, Either<&'a Memidx, &'a Globalidx>>>;
 
-impl View for Elemsec<'_> {
-    type V = SpecElemsec;
 
+impl View for Exportdesc {
+    type V = SpecExportdesc;
     open spec fn view(&self) -> Self::V {
-        SpecElemsec {
-            size: self.size@,
-            cont: self.cont@,
+        match self {
+            Exportdesc::Func(m) => SpecExportdesc::Func(m@),
+            Exportdesc::Table(m) => SpecExportdesc::Table(m@),
+            Exportdesc::Mem(m) => SpecExportdesc::Mem(m@),
+            Exportdesc::Global(m) => SpecExportdesc::Global(m@),
         }
     }
 }
-pub type ElemsecInner<'a> = (u64, ElemsecContent<'a>);
 
-pub type ElemsecInnerRef<'a> = (&'a u64, &'a ElemsecContent<'a>);
-impl<'a> From<&'a Elemsec<'a>> for ElemsecInnerRef<'a> {
-    fn ex_from(m: &'a Elemsec) -> ElemsecInnerRef<'a> {
-        (&m.size, &m.cont)
+
+impl<'a> From<&'a Exportdesc> for ExportdescInnerRef<'a> {
+    fn ex_from(m: &'a Exportdesc) -> ExportdescInnerRef<'a> {
+        match m {
+            Exportdesc::Func(m) => Either::Left(m),
+            Exportdesc::Table(m) => Either::Right(Either::Left(m)),
+            Exportdesc::Mem(m) => Either::Right(Either::Right(Either::Left(m))),
+            Exportdesc::Global(m) => Either::Right(Either::Right(Either::Right(m))),
+        }
     }
+
 }
 
-impl<'a> From<ElemsecInner<'a>> for Elemsec<'a> {
-    fn ex_from(m: ElemsecInner) -> Elemsec {
-        let (size, cont) = m;
-        Elemsec { size, cont }
+impl From<ExportdescInner> for Exportdesc {
+    fn ex_from(m: ExportdescInner) -> Exportdesc {
+        match m {
+            Either::Left(m) => Exportdesc::Func(m),
+            Either::Right(Either::Left(m)) => Exportdesc::Table(m),
+            Either::Right(Either::Right(Either::Left(m))) => Exportdesc::Mem(m),
+            Either::Right(Either::Right(Either::Right(m))) => Exportdesc::Global(m),
+        }
     }
+    
 }
 
-pub struct ElemsecMapper;
-impl View for ElemsecMapper {
+
+pub struct ExportdescMapper;
+impl View for ExportdescMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ElemsecMapper {
-    type Src = SpecElemsecInner;
-    type Dst = SpecElemsec;
+impl SpecIso for ExportdescMapper {
+    type Src = SpecExportdescInner;
+    type Dst = SpecExportdesc;
 }
-impl SpecIsoProof for ElemsecMapper {
+impl SpecIsoProof for ExportdescMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -14060,241 +13888,229 @@ impl SpecIsoProof for ElemsecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ElemsecMapper {
-    type Src = ElemsecInner<'a>;
-    type Dst = Elemsec<'a>;
-    type RefSrc = ElemsecInnerRef<'a>;
+impl<'a> Iso<'a> for ExportdescMapper {
+    type Src = ExportdescInner;
+    type Dst = Exportdesc;
+    type RefSrc = ExportdescInnerRef<'a>;
 }
 
-pub struct SpecElemsecCombinator(pub SpecElemsecCombinatorAlias);
+pub const EXPORTDESCFUNC_0_FRONT_CONST: u8 = 0;
 
-impl SpecCombinator for SpecElemsecCombinator {
-    type Type = SpecElemsec;
+pub const EXPORTDESCTABLE_0_FRONT_CONST: u8 = 1;
+
+pub const EXPORTDESCMEM_0_FRONT_CONST: u8 = 2;
+
+pub const EXPORTDESCGLOBAL_0_FRONT_CONST: u8 = 3;
+
+type SpecExportdescCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, SpecMemidxCombinator>, Preceded<Tag<U8, u8>, SpecGlobalidxCombinator>>;
+type SpecExportdescCombinatorAlias2 = Choice<Preceded<Tag<U8, u8>, SpecTableidxCombinator>, SpecExportdescCombinatorAlias1>;
+type SpecExportdescCombinatorAlias3 = Choice<Preceded<Tag<U8, u8>, SpecFuncidxCombinator>, SpecExportdescCombinatorAlias2>;
+pub struct SpecExportdescCombinator(pub SpecExportdescCombinatorAlias);
+
+impl SpecCombinator for SpecExportdescCombinator {
+    type Type = SpecExportdesc;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecElemsecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecElemsecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecExportdescCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecExportdescCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecElemsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecElemsecContentCombinator>>, ElemsecMapper>;
+pub type SpecExportdescCombinatorAlias = Mapped<SpecExportdescCombinatorAlias3, ExportdescMapper>;
 
-pub struct ElemsecCombinator(pub ElemsecCombinatorAlias);
 
-impl View for ElemsecCombinator {
-    type V = SpecElemsecCombinator;
-    open spec fn view(&self) -> Self::V { SpecElemsecCombinator(self.0@) }
+
+
+type ExportdescCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, MemidxCombinator>, Preceded<Tag<U8, u8>, GlobalidxCombinator>>;
+type ExportdescCombinatorAlias2 = Choice<Preceded<Tag<U8, u8>, TableidxCombinator>, ExportdescCombinator1>;
+type ExportdescCombinatorAlias3 = Choice<Preceded<Tag<U8, u8>, FuncidxCombinator>, ExportdescCombinator2>;
+pub struct ExportdescCombinator1(pub ExportdescCombinatorAlias1);
+impl View for ExportdescCombinator1 {
+    type V = SpecExportdescCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ElemsecCombinator {
-    type Type = Elemsec<'a>;
+impl_wrapper_combinator!(ExportdescCombinator1, ExportdescCombinatorAlias1);
+
+pub struct ExportdescCombinator2(pub ExportdescCombinatorAlias2);
+impl View for ExportdescCombinator2 {
+    type V = SpecExportdescCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ExportdescCombinator2, ExportdescCombinatorAlias2);
+
+pub struct ExportdescCombinator3(pub ExportdescCombinatorAlias3);
+impl View for ExportdescCombinator3 {
+    type V = SpecExportdescCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ExportdescCombinator3, ExportdescCombinatorAlias3);
+
+pub struct ExportdescCombinator(pub ExportdescCombinatorAlias);
+
+impl View for ExportdescCombinator {
+    type V = SpecExportdescCombinator;
+    open spec fn view(&self) -> Self::V { SpecExportdescCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExportdescCombinator {
+    type Type = Exportdesc;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ElemsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, ElemsecContentCombinator>, ElemsecCont0>, ElemsecMapper>;
-
-
-pub open spec fn spec_elemsec() -> SpecElemsecCombinator {
-    SpecElemsecCombinator(
-    Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_elemsec_cont0(deps)),
-        mapper: ElemsecMapper,
-    })
-}
-
-pub open spec fn spec_elemsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecElemsecContentCombinator> {
-    let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_elemsec_content())
 }
+pub type ExportdescCombinatorAlias = Mapped<ExportdescCombinator3, ExportdescMapper>;
 
-impl View for ElemsecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecElemsecContentCombinator>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_elemsec_cont0(deps)
-        }
-    }
+pub open spec fn spec_exportdesc() -> SpecExportdescCombinator {
+    SpecExportdescCombinator(Mapped { inner: Choice(Preceded(Tag::spec_new(U8, EXPORTDESCFUNC_0_FRONT_CONST), spec_funcidx()), Choice(Preceded(Tag::spec_new(U8, EXPORTDESCTABLE_0_FRONT_CONST), spec_tableidx()), Choice(Preceded(Tag::spec_new(U8, EXPORTDESCMEM_0_FRONT_CONST), spec_memidx()), Preceded(Tag::spec_new(U8, EXPORTDESCGLOBAL_0_FRONT_CONST), spec_globalidx())))), mapper: ExportdescMapper })
 }
 
                 
-pub fn elemsec<'a>() -> (o: ElemsecCombinator)
-    ensures o@ == spec_elemsec(),
+pub fn exportdesc<'a>() -> (o: ExportdescCombinator)
+    ensures o@ == spec_exportdesc(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ElemsecCombinator(
-    Mapped {
-        inner: Pair::new(UnsignedLEB128, ElemsecCont0),
-        mapper: ElemsecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_elemsec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ExportdescCombinator(Mapped { inner: ExportdescCombinator3(Choice::new(Preceded(Tag::new(U8, EXPORTDESCFUNC_0_FRONT_CONST), funcidx()), ExportdescCombinator2(Choice::new(Preceded(Tag::new(U8, EXPORTDESCTABLE_0_FRONT_CONST), tableidx()), ExportdescCombinator1(Choice::new(Preceded(Tag::new(U8, EXPORTDESCMEM_0_FRONT_CONST), memidx()), Preceded(Tag::new(U8, EXPORTDESCGLOBAL_0_FRONT_CONST), globalidx()))))))), mapper: ExportdescMapper });
+    // assert({
+    //     &&& combinator@ == spec_exportdesc()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_elemsec<'a>(input: &'a [u8]) -> (res: PResult<<ElemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_exportdesc<'a>(input: &'a [u8]) -> (res: PResult<<ExportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_elemsec().spec_parse(input@) == Some((n as int, v@)),
-        spec_elemsec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_exportdesc().spec_parse(input@) == Some((n as int, v@)),
+        spec_exportdesc().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_elemsec().spec_parse(input@) is None,
-        spec_elemsec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_exportdesc().spec_parse(input@) is None,
+        spec_exportdesc().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = elemsec();
+    let combinator = exportdesc();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_elemsec<'a>(v: <ElemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_exportdesc<'a>(v: <ExportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_elemsec().wf(v@),
+        spec_exportdesc().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_elemsec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_elemsec().spec_serialize(v@))
+            &&& n == spec_exportdesc().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_exportdesc().spec_serialize(v@))
         },
 {
-    let combinator = elemsec();
+    let combinator = exportdesc();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn elemsec_len<'a>(v: <ElemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn exportdesc_len<'a>(v: <ExportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_elemsec().wf(v@),
-        spec_elemsec().spec_serialize(v@).len() <= usize::MAX,
+        spec_exportdesc().wf(v@),
+        spec_exportdesc().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_elemsec().spec_serialize(v@).len(),
+        serialize_len == spec_exportdesc().spec_serialize(v@).len(),
 {
-    let combinator = elemsec();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
-}
-
-pub struct ElemsecCont0;
-type ElemsecCont0Type<'a, 'b> = &'b u64;
-type ElemsecCont0SType<'a, 'x> = &'x u64;
-type ElemsecCont0Input<'a, 'b, 'x> = POrSType<ElemsecCont0Type<'a, 'b>, ElemsecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ElemsecCont0Input<'a, 'b, 'x>> for ElemsecCont0 {
-    type Output = AndThen<bytes::Variable, ElemsecContentCombinator>;
-
-    open spec fn requires(&self, deps: ElemsecCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: ElemsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_elemsec_cont0(deps@)
-    }
-
-    fn apply(&self, deps: ElemsecCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), elemsec_content())
-            }
-            POrSType::S(deps) => {
-                let size = deps;
-                let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), elemsec_content())
-            }
-        }
-    }
+    let combinator = exportdesc();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
+
                 
 
-pub struct SpecByteVec {
-    pub l: u64,
-    pub v: Seq<u8>,
+pub struct SpecExport {
+    pub nm: SpecName,
+    pub d: SpecExportdesc,
 }
 
-pub type SpecByteVecInner = (u64, Seq<u8>);
+pub type SpecExportInner = (SpecName, SpecExportdesc);
 
 
-impl SpecFrom<SpecByteVec> for SpecByteVecInner {
-    open spec fn spec_from(m: SpecByteVec) -> SpecByteVecInner {
-        (m.l, m.v)
+impl SpecFrom<SpecExport> for SpecExportInner {
+    open spec fn spec_from(m: SpecExport) -> SpecExportInner {
+        (m.nm, m.d)
     }
 }
 
-impl SpecFrom<SpecByteVecInner> for SpecByteVec {
-    open spec fn spec_from(m: SpecByteVecInner) -> SpecByteVec {
-        let (l, v) = m;
-        SpecByteVec { l, v }
+impl SpecFrom<SpecExportInner> for SpecExport {
+    open spec fn spec_from(m: SpecExportInner) -> SpecExport {
+        let (nm, d) = m;
+        SpecExport { nm, d }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ByteVec {
-    pub l: u64,
-    pub v: RepeatResult<u8>,
+pub struct Export {
+    pub nm: Name,
+    pub d: Exportdesc,
 }
 
-impl View for ByteVec {
-    type V = SpecByteVec;
+impl View for Export {
+    type V = SpecExport;
 
     open spec fn view(&self) -> Self::V {
-        SpecByteVec {
-            l: self.l@,
-            v: self.v@,
+        SpecExport {
+            nm: self.nm@,
+            d: self.d@,
         }
     }
 }
-pub type ByteVecInner = (u64, RepeatResult<u8>);
+pub type ExportInner = (Name, Exportdesc);
 
-pub type ByteVecInnerRef<'a> = (&'a u64, &'a RepeatResult<u8>);
-impl<'a> From<&'a ByteVec> for ByteVecInnerRef<'a> {
-    fn ex_from(m: &'a ByteVec) -> ByteVecInnerRef<'a> {
-        (&m.l, &m.v)
+pub type ExportInnerRef<'a> = (&'a Name, &'a Exportdesc);
+impl<'a> From<&'a Export> for ExportInnerRef<'a> {
+    fn ex_from(m: &'a Export) -> ExportInnerRef<'a> {
+        (&m.nm, &m.d)
     }
 }
 
-impl From<ByteVecInner> for ByteVec {
-    fn ex_from(m: ByteVecInner) -> ByteVec {
-        let (l, v) = m;
-        ByteVec { l, v }
+impl From<ExportInner> for Export {
+    fn ex_from(m: ExportInner) -> Export {
+        let (nm, d) = m;
+        Export { nm, d }
     }
 }
 
-pub struct ByteVecMapper;
-impl View for ByteVecMapper {
+pub struct ExportMapper;
+impl View for ExportMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ByteVecMapper {
-    type Src = SpecByteVecInner;
-    type Dst = SpecByteVec;
+impl SpecIso for ExportMapper {
+    type Src = SpecExportInner;
+    type Dst = SpecExport;
 }
-impl SpecIsoProof for ByteVecMapper {
+impl SpecIsoProof for ExportMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -14302,241 +14118,206 @@ impl SpecIsoProof for ByteVecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ByteVecMapper {
-    type Src = ByteVecInner;
-    type Dst = ByteVec;
-    type RefSrc = ByteVecInnerRef<'a>;
+impl<'a> Iso<'a> for ExportMapper {
+    type Src = ExportInner;
+    type Dst = Export;
+    type RefSrc = ExportInnerRef<'a>;
 }
+type SpecExportCombinatorAlias1 = (SpecNameCombinator, SpecExportdescCombinator);
+pub struct SpecExportCombinator(pub SpecExportCombinatorAlias);
 
-pub struct SpecByteVecCombinator(pub SpecByteVecCombinatorAlias);
-
-impl SpecCombinator for SpecByteVecCombinator {
-    type Type = SpecByteVec;
+impl SpecCombinator for SpecExportCombinator {
+    type Type = SpecExport;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecByteVecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecByteVecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecExportCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecExportCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecByteVecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<U8>>, ByteVecMapper>;
+pub type SpecExportCombinatorAlias = Mapped<SpecExportCombinatorAlias1, ExportMapper>;
+type ExportCombinatorAlias1 = (NameCombinator, ExportdescCombinator);
+pub struct ExportCombinator1(pub ExportCombinatorAlias1);
+impl View for ExportCombinator1 {
+    type V = SpecExportCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ExportCombinator1, ExportCombinatorAlias1);
 
-pub struct ByteVecCombinator(pub ByteVecCombinatorAlias);
+pub struct ExportCombinator(pub ExportCombinatorAlias);
 
-impl View for ByteVecCombinator {
-    type V = SpecByteVecCombinator;
-    open spec fn view(&self) -> Self::V { SpecByteVecCombinator(self.0@) }
+impl View for ExportCombinator {
+    type V = SpecExportCombinator;
+    open spec fn view(&self) -> Self::V { SpecExportCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ByteVecCombinator {
-    type Type = ByteVec;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExportCombinator {
+    type Type = Export;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ByteVecCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<U8>, ByteVecCont0>, ByteVecMapper>;
+}
+pub type ExportCombinatorAlias = Mapped<ExportCombinator1, ExportMapper>;
 
 
-pub open spec fn spec_byte_vec() -> SpecByteVecCombinator {
-    SpecByteVecCombinator(
+pub open spec fn spec_export() -> SpecExportCombinator {
+    SpecExportCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_byte_vec_cont0(deps)),
-        mapper: ByteVecMapper,
+        inner: (spec_name(), spec_exportdesc()),
+        mapper: ExportMapper,
     })
 }
 
-pub open spec fn spec_byte_vec_cont0(deps: u64) -> RepeatN<U8> {
-    let l = deps;
-    RepeatN(U8, l.spec_into())
-}
-
-impl View for ByteVecCont0 {
-    type V = spec_fn(u64) -> RepeatN<U8>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_byte_vec_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn byte_vec<'a>() -> (o: ByteVecCombinator)
-    ensures o@ == spec_byte_vec(),
+pub fn export<'a>() -> (o: ExportCombinator)
+    ensures o@ == spec_export(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ByteVecCombinator(
+    let combinator = ExportCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, ByteVecCont0),
-        mapper: ByteVecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_byte_vec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: ExportCombinator1((name(), exportdesc())),
+        mapper: ExportMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_export()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_byte_vec<'a>(input: &'a [u8]) -> (res: PResult<<ByteVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_export<'a>(input: &'a [u8]) -> (res: PResult<<ExportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_byte_vec().spec_parse(input@) == Some((n as int, v@)),
-        spec_byte_vec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_export().spec_parse(input@) == Some((n as int, v@)),
+        spec_export().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_byte_vec().spec_parse(input@) is None,
-        spec_byte_vec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_export().spec_parse(input@) is None,
+        spec_export().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = byte_vec();
+    let combinator = export();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_byte_vec<'a>(v: <ByteVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_export<'a>(v: <ExportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_byte_vec().wf(v@),
+        spec_export().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_byte_vec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_byte_vec().spec_serialize(v@))
+            &&& n == spec_export().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_export().spec_serialize(v@))
         },
 {
-    let combinator = byte_vec();
+    let combinator = export();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn byte_vec_len<'a>(v: <ByteVecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn export_len<'a>(v: <ExportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_byte_vec().wf(v@),
-        spec_byte_vec().spec_serialize(v@).len() <= usize::MAX,
+        spec_export().wf(v@),
+        spec_export().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_byte_vec().spec_serialize(v@).len(),
+        serialize_len == spec_export().spec_serialize(v@).len(),
 {
-    let combinator = byte_vec();
+    let combinator = export();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ByteVecCont0;
-type ByteVecCont0Type<'a, 'b> = &'b u64;
-type ByteVecCont0SType<'a, 'x> = &'x u64;
-type ByteVecCont0Input<'a, 'b, 'x> = POrSType<ByteVecCont0Type<'a, 'b>, ByteVecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ByteVecCont0Input<'a, 'b, 'x>> for ByteVecCont0 {
-    type Output = RepeatN<U8>;
-
-    open spec fn requires(&self, deps: ByteVecCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: ByteVecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_byte_vec_cont0(deps@)
-    }
-
-    fn apply(&self, deps: ByteVecCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(U8, l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(U8, l.ex_into())
-            }
-        }
-    }
-}
                 
 
-pub struct SpecActiveData0 {
-    pub offset: SpecExpr,
-    pub init: SpecByteVec,
+pub struct SpecResulttype {
+    pub l: u64,
+    pub v: Seq<SpecValtype>,
 }
 
-pub type SpecActiveData0Inner = (SpecExpr, SpecByteVec);
+pub type SpecResulttypeInner = (u64, Seq<SpecValtype>);
 
 
-impl SpecFrom<SpecActiveData0> for SpecActiveData0Inner {
-    open spec fn spec_from(m: SpecActiveData0) -> SpecActiveData0Inner {
-        (m.offset, m.init)
+impl SpecFrom<SpecResulttype> for SpecResulttypeInner {
+    open spec fn spec_from(m: SpecResulttype) -> SpecResulttypeInner {
+        (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecActiveData0Inner> for SpecActiveData0 {
-    open spec fn spec_from(m: SpecActiveData0Inner) -> SpecActiveData0 {
-        let (offset, init) = m;
-        SpecActiveData0 { offset, init }
+impl SpecFrom<SpecResulttypeInner> for SpecResulttype {
+    open spec fn spec_from(m: SpecResulttypeInner) -> SpecResulttype {
+        let (l, v) = m;
+        SpecResulttype { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ActiveData0<'a> {
-    pub offset: Expr<'a>,
-    pub init: ByteVec,
+pub struct Resulttype {
+    pub l: u64,
+    pub v: RepeatResult<Valtype>,
 }
 
-impl View for ActiveData0<'_> {
-    type V = SpecActiveData0;
+impl View for Resulttype {
+    type V = SpecResulttype;
 
     open spec fn view(&self) -> Self::V {
-        SpecActiveData0 {
-            offset: self.offset@,
-            init: self.init@,
+        SpecResulttype {
+            l: self.l@,
+            v: self.v@,
         }
     }
 }
-pub type ActiveData0Inner<'a> = (Expr<'a>, ByteVec);
-
-pub type ActiveData0InnerRef<'a> = (&'a Expr<'a>, &'a ByteVec);
-impl<'a> From<&'a ActiveData0<'a>> for ActiveData0InnerRef<'a> {
-    fn ex_from(m: &'a ActiveData0) -> ActiveData0InnerRef<'a> {
-        (&m.offset, &m.init)
-    }
-}
+pub type ResulttypeInner = (u64, RepeatResult<Valtype>);
 
-impl<'a> From<ActiveData0Inner<'a>> for ActiveData0<'a> {
-    fn ex_from(m: ActiveData0Inner) -> ActiveData0 {
-        let (offset, init) = m;
-        ActiveData0 { offset, init }
+pub type ResulttypeInnerRef<'a> = (&'a u64, &'a RepeatResult<Valtype>);
+impl<'a> From<&'a Resulttype> for ResulttypeInnerRef<'a> {
+    fn ex_from(m: &'a Resulttype) -> ResulttypeInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-pub struct ActiveData0Mapper;
-impl View for ActiveData0Mapper {
+impl From<ResulttypeInner> for Resulttype {
+    fn ex_from(m: ResulttypeInner) -> Resulttype {
+        let (l, v) = m;
+        Resulttype { l, v }
+    }
+}
+
+pub struct ResulttypeMapper;
+impl View for ResulttypeMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ActiveData0Mapper {
-    type Src = SpecActiveData0Inner;
-    type Dst = SpecActiveData0;
+impl SpecIso for ResulttypeMapper {
+    type Src = SpecResulttypeInner;
+    type Dst = SpecResulttype;
 }
-impl SpecIsoProof for ActiveData0Mapper {
+impl SpecIsoProof for ResulttypeMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -14544,445 +14325,465 @@ impl SpecIsoProof for ActiveData0Mapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ActiveData0Mapper {
-    type Src = ActiveData0Inner<'a>;
-    type Dst = ActiveData0<'a>;
-    type RefSrc = ActiveData0InnerRef<'a>;
+impl<'a> Iso<'a> for ResulttypeMapper {
+    type Src = ResulttypeInner;
+    type Dst = Resulttype;
+    type RefSrc = ResulttypeInnerRef<'a>;
 }
-type SpecActiveData0CombinatorAlias1 = (SpecExprCombinator, SpecByteVecCombinator);
-pub struct SpecActiveData0Combinator(pub SpecActiveData0CombinatorAlias);
 
-impl SpecCombinator for SpecActiveData0Combinator {
-    type Type = SpecActiveData0;
+pub struct SpecResulttypeCombinator(pub SpecResulttypeCombinatorAlias);
+
+impl SpecCombinator for SpecResulttypeCombinator {
+    type Type = SpecResulttype;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecActiveData0Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecActiveData0CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecResulttypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecResulttypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecActiveData0CombinatorAlias = Mapped<SpecActiveData0CombinatorAlias1, ActiveData0Mapper>;
-type ActiveData0CombinatorAlias1 = (ExprCombinator, ByteVecCombinator);
-pub struct ActiveData0Combinator1(pub ActiveData0CombinatorAlias1);
-impl View for ActiveData0Combinator1 {
-    type V = SpecActiveData0CombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ActiveData0Combinator1, ActiveData0CombinatorAlias1);
+pub type SpecResulttypeCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecValtypeCombinator>>, ResulttypeMapper>;
 
-pub struct ActiveData0Combinator(pub ActiveData0CombinatorAlias);
+pub struct ResulttypeCombinator(pub ResulttypeCombinatorAlias);
 
-impl View for ActiveData0Combinator {
-    type V = SpecActiveData0Combinator;
-    open spec fn view(&self) -> Self::V { SpecActiveData0Combinator(self.0@) }
+impl View for ResulttypeCombinator {
+    type V = SpecResulttypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecResulttypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ActiveData0Combinator {
-    type Type = ActiveData0<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ResulttypeCombinator {
+    type Type = Resulttype;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ActiveData0CombinatorAlias = Mapped<ActiveData0Combinator1, ActiveData0Mapper>;
+}
+pub type ResulttypeCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ValtypeCombinator>, ResulttypeCont0>, ResulttypeMapper>;
 
 
-pub open spec fn spec_active_data0() -> SpecActiveData0Combinator {
-    SpecActiveData0Combinator(
+pub open spec fn spec_resulttype() -> SpecResulttypeCombinator {
+    SpecResulttypeCombinator(
     Mapped {
-        inner: (spec_expr(), spec_byte_vec()),
-        mapper: ActiveData0Mapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_resulttype_cont0(deps)),
+        mapper: ResulttypeMapper,
     })
 }
 
+pub open spec fn spec_resulttype_cont0(deps: u64) -> RepeatN<SpecValtypeCombinator> {
+    let l = deps;
+    RepeatN(spec_valtype(), (usize::spec_from(l)) as usize)
+}
+
+impl View for ResulttypeCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecValtypeCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_resulttype_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn active_data0<'a>() -> (o: ActiveData0Combinator)
-    ensures o@ == spec_active_data0(),
+pub fn resulttype<'a>() -> (o: ResulttypeCombinator)
+    ensures o@ == spec_resulttype(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ActiveData0Combinator(
+    let combinator = ResulttypeCombinator(
     Mapped {
-        inner: ActiveData0Combinator1((expr(), byte_vec())),
-        mapper: ActiveData0Mapper,
-    });
-    assert({
-        &&& combinator@ == spec_active_data0()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, ResulttypeCont0),
+        mapper: ResulttypeMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_resulttype()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_active_data0<'a>(input: &'a [u8]) -> (res: PResult<<ActiveData0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_resulttype<'a>(input: &'a [u8]) -> (res: PResult<<ResulttypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_active_data0().spec_parse(input@) == Some((n as int, v@)),
-        spec_active_data0().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_resulttype().spec_parse(input@) == Some((n as int, v@)),
+        spec_resulttype().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_active_data0().spec_parse(input@) is None,
-        spec_active_data0().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_resulttype().spec_parse(input@) is None,
+        spec_resulttype().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = active_data0();
+    let combinator = resulttype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_active_data0<'a>(v: <ActiveData0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_resulttype<'a>(v: <ResulttypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_active_data0().wf(v@),
+        spec_resulttype().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_active_data0().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_active_data0().spec_serialize(v@))
+            &&& n == spec_resulttype().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_resulttype().spec_serialize(v@))
         },
 {
-    let combinator = active_data0();
+    let combinator = resulttype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn active_data0_len<'a>(v: <ActiveData0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn resulttype_len<'a>(v: <ResulttypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_active_data0().wf(v@),
-        spec_active_data0().spec_serialize(v@).len() <= usize::MAX,
+        spec_resulttype().wf(v@),
+        spec_resulttype().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_active_data0().spec_serialize(v@).len(),
+        serialize_len == spec_resulttype().spec_serialize(v@).len(),
 {
-    let combinator = active_data0();
+    let combinator = resulttype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
-pub type SpecPassiveData = SpecByteVec;
-pub type PassiveData = ByteVec;
-pub type PassiveDataRef<'a> = &'a ByteVec;
+pub struct ResulttypeCont0;
+type ResulttypeCont0Type<'a, 'b> = &'b u64;
+type ResulttypeCont0SType<'a, 'x> = &'x u64;
+type ResulttypeCont0Input<'a, 'b, 'x> = POrSType<ResulttypeCont0Type<'a, 'b>, ResulttypeCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ResulttypeCont0Input<'a, 'b, 'x>> for ResulttypeCont0 {
+    type Output = RepeatN<ValtypeCombinator>;
 
+    open spec fn requires(&self, deps: ResulttypeCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-pub struct SpecPassiveDataCombinator(pub SpecPassiveDataCombinatorAlias);
+    open spec fn ensures(&self, deps: ResulttypeCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_resulttype_cont0(deps@)
+    }
 
-impl SpecCombinator for SpecPassiveDataCombinator {
-    type Type = SpecPassiveData;
-    open spec fn requires(&self) -> bool
-    { self.0.requires() }
-    open spec fn wf(&self, v: Self::Type) -> bool
-    { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
-    { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
-    { self.0.spec_serialize(v) }
-}
-impl SecureSpecCombinator for SpecPassiveDataCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecPassiveDataCombinatorAlias::is_prefix_secure() }
-    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
-    { self.0.theorem_serialize_parse_roundtrip(v) }
-    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
-    { self.0.theorem_parse_serialize_roundtrip(buf) }
-    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
-    { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
+    fn apply(&self, deps: ResulttypeCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(valtype(), (usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(valtype(), (usize::ex_from(l)) as usize)
+            }
+        }
+    }
 }
-pub type SpecPassiveDataCombinatorAlias = SpecByteVecCombinator;
-
-pub struct PassiveDataCombinator(pub PassiveDataCombinatorAlias);
+                
 
-impl View for PassiveDataCombinator {
-    type V = SpecPassiveDataCombinator;
-    open spec fn view(&self) -> Self::V { SpecPassiveDataCombinator(self.0@) }
+pub struct SpecFunctype {
+    pub tag: u8,
+    pub params: SpecResulttype,
+    pub results: SpecResulttype,
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PassiveDataCombinator {
-    type Type = PassiveData;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type PassiveDataCombinatorAlias = ByteVecCombinator;
+
+pub type SpecFunctypeInner = (u8, (SpecResulttype, SpecResulttype));
 
 
-pub open spec fn spec_passive_data() -> SpecPassiveDataCombinator {
-    SpecPassiveDataCombinator(spec_byte_vec())
+impl SpecFrom<SpecFunctype> for SpecFunctypeInner {
+    open spec fn spec_from(m: SpecFunctype) -> SpecFunctypeInner {
+        (m.tag, (m.params, m.results))
+    }
 }
 
-                
-pub fn passive_data<'a>() -> (o: PassiveDataCombinator)
-    ensures o@ == spec_passive_data(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = PassiveDataCombinator(byte_vec());
-    assert({
-        &&& combinator@ == spec_passive_data()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
+impl SpecFrom<SpecFunctypeInner> for SpecFunctype {
+    open spec fn spec_from(m: SpecFunctypeInner) -> SpecFunctype {
+        let (tag, (params, results)) = m;
+        SpecFunctype { tag, params, results }
+    }
 }
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub fn parse_passive_data<'a>(input: &'a [u8]) -> (res: PResult<<PassiveDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_passive_data().spec_parse(input@) == Some((n as int, v@)),
-        spec_passive_data().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_passive_data().spec_parse(input@) is None,
-        spec_passive_data().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = passive_data();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+pub struct Functype {
+    pub tag: u8,
+    pub params: Resulttype,
+    pub results: Resulttype,
 }
 
-pub fn serialize_passive_data<'a>(v: <PassiveDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_passive_data().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_passive_data().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_passive_data().spec_serialize(v@))
-        },
-{
-    let combinator = passive_data();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+impl View for Functype {
+    type V = SpecFunctype;
+
+    open spec fn view(&self) -> Self::V {
+        SpecFunctype {
+            tag: self.tag@,
+            params: self.params@,
+            results: self.results@,
+        }
+    }
 }
+pub type FunctypeInner = (u8, (Resulttype, Resulttype));
 
-pub fn passive_data_len<'a>(v: <PassiveDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_passive_data().wf(v@),
-        spec_passive_data().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_passive_data().spec_serialize(v@).len(),
-{
-    let combinator = passive_data();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+pub type FunctypeInnerRef<'a> = (&'a u8, (&'a Resulttype, &'a Resulttype));
+impl<'a> From<&'a Functype> for FunctypeInnerRef<'a> {
+    fn ex_from(m: &'a Functype) -> FunctypeInnerRef<'a> {
+        (&m.tag, (&m.params, &m.results))
+    }
 }
 
-                
-pub type SpecMemidx = u64;
-pub type Memidx = u64;
-pub type MemidxRef<'a> = &'a u64;
-
+impl From<FunctypeInner> for Functype {
+    fn ex_from(m: FunctypeInner) -> Functype {
+        let (tag, (params, results)) = m;
+        Functype { tag, params, results }
+    }
+}
 
-pub struct SpecMemidxCombinator(pub SpecMemidxCombinatorAlias);
+pub struct FunctypeMapper;
+impl View for FunctypeMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for FunctypeMapper {
+    type Src = SpecFunctypeInner;
+    type Dst = SpecFunctype;
+}
+impl SpecIsoProof for FunctypeMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for FunctypeMapper {
+    type Src = FunctypeInner;
+    type Dst = Functype;
+    type RefSrc = FunctypeInnerRef<'a>;
+}
+pub const FUNCTYPETAG_CONST: u8 = 96;
+type SpecFunctypeCombinatorAlias1 = (SpecResulttypeCombinator, SpecResulttypeCombinator);
+type SpecFunctypeCombinatorAlias2 = (Refined<U8, TagPred<u8>>, SpecFunctypeCombinatorAlias1);
+pub struct SpecFunctypeCombinator(pub SpecFunctypeCombinatorAlias);
 
-impl SpecCombinator for SpecMemidxCombinator {
-    type Type = SpecMemidx;
+impl SpecCombinator for SpecFunctypeCombinator {
+    type Type = SpecFunctype;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecMemidxCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecMemidxCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecFunctypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecFunctypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecMemidxCombinatorAlias = UnsignedLEB128;
+pub type SpecFunctypeCombinatorAlias = Mapped<SpecFunctypeCombinatorAlias2, FunctypeMapper>;
+type FunctypeCombinatorAlias1 = (ResulttypeCombinator, ResulttypeCombinator);
+type FunctypeCombinatorAlias2 = (Refined<U8, TagPred<u8>>, FunctypeCombinator1);
+pub struct FunctypeCombinator1(pub FunctypeCombinatorAlias1);
+impl View for FunctypeCombinator1 {
+    type V = SpecFunctypeCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(FunctypeCombinator1, FunctypeCombinatorAlias1);
 
-pub struct MemidxCombinator(pub MemidxCombinatorAlias);
+pub struct FunctypeCombinator2(pub FunctypeCombinatorAlias2);
+impl View for FunctypeCombinator2 {
+    type V = SpecFunctypeCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(FunctypeCombinator2, FunctypeCombinatorAlias2);
 
-impl View for MemidxCombinator {
-    type V = SpecMemidxCombinator;
-    open spec fn view(&self) -> Self::V { SpecMemidxCombinator(self.0@) }
+pub struct FunctypeCombinator(pub FunctypeCombinatorAlias);
+
+impl View for FunctypeCombinator {
+    type V = SpecFunctypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecFunctypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemidxCombinator {
-    type Type = Memidx;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FunctypeCombinator {
+    type Type = Functype;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type MemidxCombinatorAlias = UnsignedLEB128;
+}
+pub type FunctypeCombinatorAlias = Mapped<FunctypeCombinator2, FunctypeMapper>;
 
 
-pub open spec fn spec_memidx() -> SpecMemidxCombinator {
-    SpecMemidxCombinator(UnsignedLEB128)
+pub open spec fn spec_functype() -> SpecFunctypeCombinator {
+    SpecFunctypeCombinator(
+    Mapped {
+        inner: (Refined { inner: U8, predicate: TagPred(FUNCTYPETAG_CONST) }, (spec_resulttype(), spec_resulttype())),
+        mapper: FunctypeMapper,
+    })
 }
 
                 
-pub fn memidx<'a>() -> (o: MemidxCombinator)
-    ensures o@ == spec_memidx(),
+pub fn functype<'a>() -> (o: FunctypeCombinator)
+    ensures o@ == spec_functype(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = MemidxCombinator(UnsignedLEB128);
-    assert({
-        &&& combinator@ == spec_memidx()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = FunctypeCombinator(
+    Mapped {
+        inner: FunctypeCombinator2((Refined { inner: U8, predicate: TagPred(FUNCTYPETAG_CONST) }, FunctypeCombinator1((resulttype(), resulttype())))),
+        mapper: FunctypeMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_functype()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_memidx<'a>(input: &'a [u8]) -> (res: PResult<<MemidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_functype<'a>(input: &'a [u8]) -> (res: PResult<<FunctypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_memidx().spec_parse(input@) == Some((n as int, v@)),
-        spec_memidx().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_functype().spec_parse(input@) == Some((n as int, v@)),
+        spec_functype().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_memidx().spec_parse(input@) is None,
-        spec_memidx().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_functype().spec_parse(input@) is None,
+        spec_functype().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = memidx();
+    let combinator = functype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_memidx<'a>(v: <MemidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_functype<'a>(v: <FunctypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_memidx().wf(v@),
+        spec_functype().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_memidx().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_memidx().spec_serialize(v@))
+            &&& n == spec_functype().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_functype().spec_serialize(v@))
         },
 {
-    let combinator = memidx();
+    let combinator = functype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn memidx_len<'a>(v: <MemidxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn functype_len<'a>(v: <FunctypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_memidx().wf(v@),
-        spec_memidx().spec_serialize(v@).len() <= usize::MAX,
+        spec_functype().wf(v@),
+        spec_functype().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_memidx().spec_serialize(v@).len(),
+        serialize_len == spec_functype().spec_serialize(v@).len(),
 {
-    let combinator = memidx();
+    let combinator = functype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecActiveDatax {
-    pub memory: SpecMemidx,
-    pub offset: SpecExpr,
-    pub init: SpecByteVec,
+pub struct SpecTypesecContent {
+    pub l: u64,
+    pub v: Seq<SpecFunctype>,
 }
 
-pub type SpecActiveDataxInner = (SpecMemidx, (SpecExpr, SpecByteVec));
+pub type SpecTypesecContentInner = (u64, Seq<SpecFunctype>);
 
 
-impl SpecFrom<SpecActiveDatax> for SpecActiveDataxInner {
-    open spec fn spec_from(m: SpecActiveDatax) -> SpecActiveDataxInner {
-        (m.memory, (m.offset, m.init))
+impl SpecFrom<SpecTypesecContent> for SpecTypesecContentInner {
+    open spec fn spec_from(m: SpecTypesecContent) -> SpecTypesecContentInner {
+        (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecActiveDataxInner> for SpecActiveDatax {
-    open spec fn spec_from(m: SpecActiveDataxInner) -> SpecActiveDatax {
-        let (memory, (offset, init)) = m;
-        SpecActiveDatax { memory, offset, init }
+impl SpecFrom<SpecTypesecContentInner> for SpecTypesecContent {
+    open spec fn spec_from(m: SpecTypesecContentInner) -> SpecTypesecContent {
+        let (l, v) = m;
+        SpecTypesecContent { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct ActiveDatax<'a> {
-    pub memory: Memidx,
-    pub offset: Expr<'a>,
-    pub init: ByteVec,
+pub struct TypesecContent {
+    pub l: u64,
+    pub v: RepeatResult<Functype>,
 }
 
-impl View for ActiveDatax<'_> {
-    type V = SpecActiveDatax;
+impl View for TypesecContent {
+    type V = SpecTypesecContent;
 
     open spec fn view(&self) -> Self::V {
-        SpecActiveDatax {
-            memory: self.memory@,
-            offset: self.offset@,
-            init: self.init@,
+        SpecTypesecContent {
+            l: self.l@,
+            v: self.v@,
         }
     }
 }
-pub type ActiveDataxInner<'a> = (Memidx, (Expr<'a>, ByteVec));
+pub type TypesecContentInner = (u64, RepeatResult<Functype>);
 
-pub type ActiveDataxInnerRef<'a> = (&'a Memidx, (&'a Expr<'a>, &'a ByteVec));
-impl<'a> From<&'a ActiveDatax<'a>> for ActiveDataxInnerRef<'a> {
-    fn ex_from(m: &'a ActiveDatax) -> ActiveDataxInnerRef<'a> {
-        (&m.memory, (&m.offset, &m.init))
+pub type TypesecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Functype>);
+impl<'a> From<&'a TypesecContent> for TypesecContentInnerRef<'a> {
+    fn ex_from(m: &'a TypesecContent) -> TypesecContentInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-impl<'a> From<ActiveDataxInner<'a>> for ActiveDatax<'a> {
-    fn ex_from(m: ActiveDataxInner) -> ActiveDatax {
-        let (memory, (offset, init)) = m;
-        ActiveDatax { memory, offset, init }
+impl From<TypesecContentInner> for TypesecContent {
+    fn ex_from(m: TypesecContentInner) -> TypesecContent {
+        let (l, v) = m;
+        TypesecContent { l, v }
     }
 }
 
-pub struct ActiveDataxMapper;
-impl View for ActiveDataxMapper {
+pub struct TypesecContentMapper;
+impl View for TypesecContentMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ActiveDataxMapper {
-    type Src = SpecActiveDataxInner;
-    type Dst = SpecActiveDatax;
+impl SpecIso for TypesecContentMapper {
+    type Src = SpecTypesecContentInner;
+    type Dst = SpecTypesecContent;
 }
-impl SpecIsoProof for ActiveDataxMapper {
+impl SpecIsoProof for TypesecContentMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -14990,242 +14791,245 @@ impl SpecIsoProof for ActiveDataxMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ActiveDataxMapper {
-    type Src = ActiveDataxInner<'a>;
-    type Dst = ActiveDatax<'a>;
-    type RefSrc = ActiveDataxInnerRef<'a>;
+impl<'a> Iso<'a> for TypesecContentMapper {
+    type Src = TypesecContentInner;
+    type Dst = TypesecContent;
+    type RefSrc = TypesecContentInnerRef<'a>;
 }
-type SpecActiveDataxCombinatorAlias1 = (SpecExprCombinator, SpecByteVecCombinator);
-type SpecActiveDataxCombinatorAlias2 = (SpecMemidxCombinator, SpecActiveDataxCombinatorAlias1);
-pub struct SpecActiveDataxCombinator(pub SpecActiveDataxCombinatorAlias);
 
-impl SpecCombinator for SpecActiveDataxCombinator {
-    type Type = SpecActiveDatax;
+pub struct SpecTypesecContentCombinator(pub SpecTypesecContentCombinatorAlias);
+
+impl SpecCombinator for SpecTypesecContentCombinator {
+    type Type = SpecTypesecContent;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecActiveDataxCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecActiveDataxCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTypesecContentCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTypesecContentCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
-    { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
-    { self.0.lemma_parse_productive(s) }
-}
-pub type SpecActiveDataxCombinatorAlias = Mapped<SpecActiveDataxCombinatorAlias2, ActiveDataxMapper>;
-type ActiveDataxCombinatorAlias1 = (ExprCombinator, ByteVecCombinator);
-type ActiveDataxCombinatorAlias2 = (MemidxCombinator, ActiveDataxCombinator1);
-pub struct ActiveDataxCombinator1(pub ActiveDataxCombinatorAlias1);
-impl View for ActiveDataxCombinator1 {
-    type V = SpecActiveDataxCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ActiveDataxCombinator1, ActiveDataxCombinatorAlias1);
-
-pub struct ActiveDataxCombinator2(pub ActiveDataxCombinatorAlias2);
-impl View for ActiveDataxCombinator2 {
-    type V = SpecActiveDataxCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
 }
-impl_wrapper_combinator!(ActiveDataxCombinator2, ActiveDataxCombinatorAlias2);
+pub type SpecTypesecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecFunctypeCombinator>>, TypesecContentMapper>;
 
-pub struct ActiveDataxCombinator(pub ActiveDataxCombinatorAlias);
+pub struct TypesecContentCombinator(pub TypesecContentCombinatorAlias);
 
-impl View for ActiveDataxCombinator {
-    type V = SpecActiveDataxCombinator;
-    open spec fn view(&self) -> Self::V { SpecActiveDataxCombinator(self.0@) }
+impl View for TypesecContentCombinator {
+    type V = SpecTypesecContentCombinator;
+    open spec fn view(&self) -> Self::V { SpecTypesecContentCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ActiveDataxCombinator {
-    type Type = ActiveDatax<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TypesecContentCombinator {
+    type Type = TypesecContent;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ActiveDataxCombinatorAlias = Mapped<ActiveDataxCombinator2, ActiveDataxMapper>;
+}
+pub type TypesecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<FunctypeCombinator>, TypesecContentCont0>, TypesecContentMapper>;
 
 
-pub open spec fn spec_active_datax() -> SpecActiveDataxCombinator {
-    SpecActiveDataxCombinator(
+pub open spec fn spec_typesec_content() -> SpecTypesecContentCombinator {
+    SpecTypesecContentCombinator(
     Mapped {
-        inner: (spec_memidx(), (spec_expr(), spec_byte_vec())),
-        mapper: ActiveDataxMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_typesec_content_cont0(deps)),
+        mapper: TypesecContentMapper,
     })
 }
 
+pub open spec fn spec_typesec_content_cont0(deps: u64) -> RepeatN<SpecFunctypeCombinator> {
+    let l = deps;
+    RepeatN(spec_functype(), (usize::spec_from(l)) as usize)
+}
+
+impl View for TypesecContentCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecFunctypeCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_typesec_content_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn active_datax<'a>() -> (o: ActiveDataxCombinator)
-    ensures o@ == spec_active_datax(),
+pub fn typesec_content<'a>() -> (o: TypesecContentCombinator)
+    ensures o@ == spec_typesec_content(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ActiveDataxCombinator(
+    let combinator = TypesecContentCombinator(
     Mapped {
-        inner: ActiveDataxCombinator2((memidx(), ActiveDataxCombinator1((expr(), byte_vec())))),
-        mapper: ActiveDataxMapper,
-    });
-    assert({
-        &&& combinator@ == spec_active_datax()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, TypesecContentCont0),
+        mapper: TypesecContentMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_typesec_content()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_active_datax<'a>(input: &'a [u8]) -> (res: PResult<<ActiveDataxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_typesec_content<'a>(input: &'a [u8]) -> (res: PResult<<TypesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_active_datax().spec_parse(input@) == Some((n as int, v@)),
-        spec_active_datax().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_typesec_content().spec_parse(input@) == Some((n as int, v@)),
+        spec_typesec_content().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_active_datax().spec_parse(input@) is None,
-        spec_active_datax().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_typesec_content().spec_parse(input@) is None,
+        spec_typesec_content().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = active_datax();
+    let combinator = typesec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_active_datax<'a>(v: <ActiveDataxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_typesec_content<'a>(v: <TypesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_active_datax().wf(v@),
+        spec_typesec_content().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_active_datax().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_active_datax().spec_serialize(v@))
+            &&& n == spec_typesec_content().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_typesec_content().spec_serialize(v@))
         },
 {
-    let combinator = active_datax();
+    let combinator = typesec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn active_datax_len<'a>(v: <ActiveDataxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn typesec_content_len<'a>(v: <TypesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_active_datax().wf(v@),
-        spec_active_datax().spec_serialize(v@).len() <= usize::MAX,
+        spec_typesec_content().wf(v@),
+        spec_typesec_content().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_active_datax().spec_serialize(v@).len(),
+        serialize_len == spec_typesec_content().spec_serialize(v@).len(),
 {
-    let combinator = active_datax();
+    let combinator = typesec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
+pub struct TypesecContentCont0;
+type TypesecContentCont0Type<'a, 'b> = &'b u64;
+type TypesecContentCont0SType<'a, 'x> = &'x u64;
+type TypesecContentCont0Input<'a, 'b, 'x> = POrSType<TypesecContentCont0Type<'a, 'b>, TypesecContentCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TypesecContentCont0Input<'a, 'b, 'x>> for TypesecContentCont0 {
+    type Output = RepeatN<FunctypeCombinator>;
 
-pub enum SpecData {
-    ActiveData0(SpecActiveData0),
-    PassiveData(SpecPassiveData),
-    ActiveDataX(SpecActiveDatax),
-}
+    open spec fn requires(&self, deps: TypesecContentCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-pub type SpecDataInner = Either<SpecActiveData0, Either<SpecPassiveData, SpecActiveDatax>>;
+    open spec fn ensures(&self, deps: TypesecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_typesec_content_cont0(deps@)
+    }
 
-impl SpecFrom<SpecData> for SpecDataInner {
-    open spec fn spec_from(m: SpecData) -> SpecDataInner {
-        match m {
-            SpecData::ActiveData0(m) => Either::Left(m),
-            SpecData::PassiveData(m) => Either::Right(Either::Left(m)),
-            SpecData::ActiveDataX(m) => Either::Right(Either::Right(m)),
+    fn apply(&self, deps: TypesecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(functype(), (usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(functype(), (usize::ex_from(l)) as usize)
+            }
         }
     }
-
 }
-
                 
-impl SpecFrom<SpecDataInner> for SpecData {
-    open spec fn spec_from(m: SpecDataInner) -> SpecData {
-        match m {
-            Either::Left(m) => SpecData::ActiveData0(m),
-            Either::Right(Either::Left(m)) => SpecData::PassiveData(m),
-            Either::Right(Either::Right(m)) => SpecData::ActiveDataX(m),
-        }
-    }
 
+pub struct SpecTypesec {
+    pub size: u64,
+    pub cont: SpecTypesecContent,
 }
 
+pub type SpecTypesecInner = (u64, SpecTypesecContent);
 
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Data<'a> {
-    ActiveData0(ActiveData0<'a>),
-    PassiveData(PassiveData),
-    ActiveDataX(ActiveDatax<'a>),
+impl SpecFrom<SpecTypesec> for SpecTypesecInner {
+    open spec fn spec_from(m: SpecTypesec) -> SpecTypesecInner {
+        (m.size, m.cont)
+    }
 }
 
-pub type DataInner<'a> = Either<ActiveData0<'a>, Either<PassiveData, ActiveDatax<'a>>>;
+impl SpecFrom<SpecTypesecInner> for SpecTypesec {
+    open spec fn spec_from(m: SpecTypesecInner) -> SpecTypesec {
+        let (size, cont) = m;
+        SpecTypesec { size, cont }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub type DataInnerRef<'a> = Either<&'a ActiveData0<'a>, Either<&'a PassiveData, &'a ActiveDatax<'a>>>;
+pub struct Typesec {
+    pub size: u64,
+    pub cont: TypesecContent,
+}
 
+impl View for Typesec {
+    type V = SpecTypesec;
 
-impl<'a> View for Data<'a> {
-    type V = SpecData;
     open spec fn view(&self) -> Self::V {
-        match self {
-            Data::ActiveData0(m) => SpecData::ActiveData0(m@),
-            Data::PassiveData(m) => SpecData::PassiveData(m@),
-            Data::ActiveDataX(m) => SpecData::ActiveDataX(m@),
+        SpecTypesec {
+            size: self.size@,
+            cont: self.cont@,
         }
     }
 }
+pub type TypesecInner = (u64, TypesecContent);
 
-
-impl<'a> From<&'a Data<'a>> for DataInnerRef<'a> {
-    fn ex_from(m: &'a Data<'a>) -> DataInnerRef<'a> {
-        match m {
-            Data::ActiveData0(m) => Either::Left(m),
-            Data::PassiveData(m) => Either::Right(Either::Left(m)),
-            Data::ActiveDataX(m) => Either::Right(Either::Right(m)),
-        }
+pub type TypesecInnerRef<'a> = (&'a u64, &'a TypesecContent);
+impl<'a> From<&'a Typesec> for TypesecInnerRef<'a> {
+    fn ex_from(m: &'a Typesec) -> TypesecInnerRef<'a> {
+        (&m.size, &m.cont)
     }
-
 }
 
-impl<'a> From<DataInner<'a>> for Data<'a> {
-    fn ex_from(m: DataInner<'a>) -> Data<'a> {
-        match m {
-            Either::Left(m) => Data::ActiveData0(m),
-            Either::Right(Either::Left(m)) => Data::PassiveData(m),
-            Either::Right(Either::Right(m)) => Data::ActiveDataX(m),
-        }
+impl From<TypesecInner> for Typesec {
+    fn ex_from(m: TypesecInner) -> Typesec {
+        let (size, cont) = m;
+        Typesec { size, cont }
     }
-    
 }
 
-
-pub struct DataMapper;
-impl View for DataMapper {
+pub struct TypesecMapper;
+impl View for TypesecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for DataMapper {
-    type Src = SpecDataInner;
-    type Dst = SpecData;
+impl SpecIso for TypesecMapper {
+    type Src = SpecTypesecInner;
+    type Dst = SpecTypesec;
 }
-impl SpecIsoProof for DataMapper {
+impl SpecIsoProof for TypesecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -15233,217 +15037,245 @@ impl SpecIsoProof for DataMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for DataMapper {
-    type Src = DataInner<'a>;
-    type Dst = Data<'a>;
-    type RefSrc = DataInnerRef<'a>;
+impl<'a> Iso<'a> for TypesecMapper {
+    type Src = TypesecInner;
+    type Dst = Typesec;
+    type RefSrc = TypesecInnerRef<'a>;
 }
 
-pub const DATAACTIVEDATA0_0_FRONT_CONST: u64 = 0;
-
-pub const DATAPASSIVEDATA_0_FRONT_CONST: u64 = 1;
-
-pub const DATAACTIVEDATAX_0_FRONT_CONST: u64 = 2;
-
-type SpecDataCombinatorAlias1 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecPassiveDataCombinator>, Preceded<Tag<UnsignedLEB128, u64>, SpecActiveDataxCombinator>>;
-type SpecDataCombinatorAlias2 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecActiveData0Combinator>, SpecDataCombinatorAlias1>;
-pub struct SpecDataCombinator(pub SpecDataCombinatorAlias);
+pub struct SpecTypesecCombinator(pub SpecTypesecCombinatorAlias);
 
-impl SpecCombinator for SpecDataCombinator {
-    type Type = SpecData;
+impl SpecCombinator for SpecTypesecCombinator {
+    type Type = SpecTypesec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecDataCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecDataCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTypesecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTypesecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecDataCombinatorAlias = Mapped<SpecDataCombinatorAlias2, DataMapper>;
-
-
-
-type DataCombinatorAlias1 = Choice<Preceded<Tag<UnsignedLEB128, u64>, PassiveDataCombinator>, Preceded<Tag<UnsignedLEB128, u64>, ActiveDataxCombinator>>;
-type DataCombinatorAlias2 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ActiveData0Combinator>, DataCombinator1>;
-pub struct DataCombinator1(pub DataCombinatorAlias1);
-impl View for DataCombinator1 {
-    type V = SpecDataCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(DataCombinator1, DataCombinatorAlias1);
-
-pub struct DataCombinator2(pub DataCombinatorAlias2);
-impl View for DataCombinator2 {
-    type V = SpecDataCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(DataCombinator2, DataCombinatorAlias2);
+pub type SpecTypesecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecTypesecContentCombinator>>, TypesecMapper>;
 
-pub struct DataCombinator(pub DataCombinatorAlias);
+pub struct TypesecCombinator(pub TypesecCombinatorAlias);
 
-impl View for DataCombinator {
-    type V = SpecDataCombinator;
-    open spec fn view(&self) -> Self::V { SpecDataCombinator(self.0@) }
+impl View for TypesecCombinator {
+    type V = SpecTypesecCombinator;
+    open spec fn view(&self) -> Self::V { SpecTypesecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DataCombinator {
-    type Type = Data<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TypesecCombinator {
+    type Type = Typesec;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type DataCombinatorAlias = Mapped<DataCombinator2, DataMapper>;
+}
+pub type TypesecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, TypesecContentCombinator>, TypesecCont0>, TypesecMapper>;
 
 
-pub open spec fn spec_data() -> SpecDataCombinator {
-    SpecDataCombinator(Mapped { inner: Choice(Preceded(Tag::spec_new(UnsignedLEB128, DATAACTIVEDATA0_0_FRONT_CONST), spec_active_data0()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, DATAPASSIVEDATA_0_FRONT_CONST), spec_passive_data()), Preceded(Tag::spec_new(UnsignedLEB128, DATAACTIVEDATAX_0_FRONT_CONST), spec_active_datax()))), mapper: DataMapper })
+pub open spec fn spec_typesec() -> SpecTypesecCombinator {
+    SpecTypesecCombinator(
+    Mapped {
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_typesec_cont0(deps)),
+        mapper: TypesecMapper,
+    })
+}
+
+pub open spec fn spec_typesec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecTypesecContentCombinator> {
+    let size = deps;
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_typesec_content())
+}
+
+impl View for TypesecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecTypesecContentCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_typesec_cont0(deps)
+        }
+    }
 }
 
                 
-pub fn data<'a>() -> (o: DataCombinator)
-    ensures o@ == spec_data(),
+pub fn typesec<'a>() -> (o: TypesecCombinator)
+    ensures o@ == spec_typesec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = DataCombinator(Mapped { inner: DataCombinator2(Choice::new(Preceded(Tag::new(UnsignedLEB128, DATAACTIVEDATA0_0_FRONT_CONST), active_data0()), DataCombinator1(Choice::new(Preceded(Tag::new(UnsignedLEB128, DATAPASSIVEDATA_0_FRONT_CONST), passive_data()), Preceded(Tag::new(UnsignedLEB128, DATAACTIVEDATAX_0_FRONT_CONST), active_datax()))))), mapper: DataMapper });
-    assert({
-        &&& combinator@ == spec_data()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = TypesecCombinator(
+    Mapped {
+        inner: Pair::new(UnsignedLEB128, TypesecCont0),
+        mapper: TypesecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_typesec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_data<'a>(input: &'a [u8]) -> (res: PResult<<DataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_typesec<'a>(input: &'a [u8]) -> (res: PResult<<TypesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_data().spec_parse(input@) == Some((n as int, v@)),
-        spec_data().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_typesec().spec_parse(input@) == Some((n as int, v@)),
+        spec_typesec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_data().spec_parse(input@) is None,
-        spec_data().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_typesec().spec_parse(input@) is None,
+        spec_typesec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = data();
+    let combinator = typesec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_data<'a>(v: <DataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_typesec<'a>(v: <TypesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_data().wf(v@),
+        spec_typesec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_data().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_data().spec_serialize(v@))
+            &&& n == spec_typesec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_typesec().spec_serialize(v@))
         },
 {
-    let combinator = data();
+    let combinator = typesec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn data_len<'a>(v: <DataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn typesec_len<'a>(v: <TypesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_data().wf(v@),
-        spec_data().spec_serialize(v@).len() <= usize::MAX,
+        spec_typesec().wf(v@),
+        spec_typesec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_data().spec_serialize(v@).len(),
+        serialize_len == spec_typesec().spec_serialize(v@).len(),
 {
-    let combinator = data();
+    let combinator = typesec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct TypesecCont0;
+type TypesecCont0Type<'a, 'b> = &'b u64;
+type TypesecCont0SType<'a, 'x> = &'x u64;
+type TypesecCont0Input<'a, 'b, 'x> = POrSType<TypesecCont0Type<'a, 'b>, TypesecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TypesecCont0Input<'a, 'b, 'x>> for TypesecCont0 {
+    type Output = AndThen<bytes::Variable, TypesecContentCombinator>;
+
+    open spec fn requires(&self, deps: TypesecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: TypesecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_typesec_cont0(deps@)
+    }
+
+    fn apply(&self, deps: TypesecCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), typesec_content())
+            }
+            POrSType::S(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), typesec_content())
+            }
+        }
+    }
+}
                 
 
-pub struct SpecDatasecContent {
-    pub l: u64,
-    pub v: Seq<SpecData>,
+pub struct SpecTabletype {
+    pub elemtype: SpecReftype,
+    pub limits: SpecLimits,
 }
 
-pub type SpecDatasecContentInner = (u64, Seq<SpecData>);
+pub type SpecTabletypeInner = (SpecReftype, SpecLimits);
 
 
-impl SpecFrom<SpecDatasecContent> for SpecDatasecContentInner {
-    open spec fn spec_from(m: SpecDatasecContent) -> SpecDatasecContentInner {
-        (m.l, m.v)
+impl SpecFrom<SpecTabletype> for SpecTabletypeInner {
+    open spec fn spec_from(m: SpecTabletype) -> SpecTabletypeInner {
+        (m.elemtype, m.limits)
     }
 }
 
-impl SpecFrom<SpecDatasecContentInner> for SpecDatasecContent {
-    open spec fn spec_from(m: SpecDatasecContentInner) -> SpecDatasecContent {
-        let (l, v) = m;
-        SpecDatasecContent { l, v }
+impl SpecFrom<SpecTabletypeInner> for SpecTabletype {
+    open spec fn spec_from(m: SpecTabletypeInner) -> SpecTabletype {
+        let (elemtype, limits) = m;
+        SpecTabletype { elemtype, limits }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct DatasecContent<'a> {
-    pub l: u64,
-    pub v: RepeatResult<Data<'a>>,
+pub struct Tabletype {
+    pub elemtype: Reftype,
+    pub limits: Limits,
 }
 
-impl View for DatasecContent<'_> {
-    type V = SpecDatasecContent;
+impl View for Tabletype {
+    type V = SpecTabletype;
 
     open spec fn view(&self) -> Self::V {
-        SpecDatasecContent {
-            l: self.l@,
-            v: self.v@,
+        SpecTabletype {
+            elemtype: self.elemtype@,
+            limits: self.limits@,
         }
     }
 }
-pub type DatasecContentInner<'a> = (u64, RepeatResult<Data<'a>>);
+pub type TabletypeInner = (Reftype, Limits);
 
-pub type DatasecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Data<'a>>);
-impl<'a> From<&'a DatasecContent<'a>> for DatasecContentInnerRef<'a> {
-    fn ex_from(m: &'a DatasecContent) -> DatasecContentInnerRef<'a> {
-        (&m.l, &m.v)
+pub type TabletypeInnerRef<'a> = (&'a Reftype, &'a Limits);
+impl<'a> From<&'a Tabletype> for TabletypeInnerRef<'a> {
+    fn ex_from(m: &'a Tabletype) -> TabletypeInnerRef<'a> {
+        (&m.elemtype, &m.limits)
     }
 }
 
-impl<'a> From<DatasecContentInner<'a>> for DatasecContent<'a> {
-    fn ex_from(m: DatasecContentInner) -> DatasecContent {
-        let (l, v) = m;
-        DatasecContent { l, v }
+impl From<TabletypeInner> for Tabletype {
+    fn ex_from(m: TabletypeInner) -> Tabletype {
+        let (elemtype, limits) = m;
+        Tabletype { elemtype, limits }
     }
 }
 
-pub struct DatasecContentMapper;
-impl View for DatasecContentMapper {
+pub struct TabletypeMapper;
+impl View for TabletypeMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for DatasecContentMapper {
-    type Src = SpecDatasecContentInner;
-    type Dst = SpecDatasecContent;
+impl SpecIso for TabletypeMapper {
+    type Src = SpecTabletypeInner;
+    type Dst = SpecTabletype;
 }
-impl SpecIsoProof for DatasecContentMapper {
+impl SpecIsoProof for TabletypeMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -15451,241 +15283,206 @@ impl SpecIsoProof for DatasecContentMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for DatasecContentMapper {
-    type Src = DatasecContentInner<'a>;
-    type Dst = DatasecContent<'a>;
-    type RefSrc = DatasecContentInnerRef<'a>;
+impl<'a> Iso<'a> for TabletypeMapper {
+    type Src = TabletypeInner;
+    type Dst = Tabletype;
+    type RefSrc = TabletypeInnerRef<'a>;
 }
+type SpecTabletypeCombinatorAlias1 = (SpecReftypeCombinator, SpecLimitsCombinator);
+pub struct SpecTabletypeCombinator(pub SpecTabletypeCombinatorAlias);
 
-pub struct SpecDatasecContentCombinator(pub SpecDatasecContentCombinatorAlias);
-
-impl SpecCombinator for SpecDatasecContentCombinator {
-    type Type = SpecDatasecContent;
+impl SpecCombinator for SpecTabletypeCombinator {
+    type Type = SpecTabletype;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecDatasecContentCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecDatasecContentCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTabletypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTabletypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecDatasecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecDataCombinator>>, DatasecContentMapper>;
+pub type SpecTabletypeCombinatorAlias = Mapped<SpecTabletypeCombinatorAlias1, TabletypeMapper>;
+type TabletypeCombinatorAlias1 = (ReftypeCombinator, LimitsCombinator);
+pub struct TabletypeCombinator1(pub TabletypeCombinatorAlias1);
+impl View for TabletypeCombinator1 {
+    type V = SpecTabletypeCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(TabletypeCombinator1, TabletypeCombinatorAlias1);
 
-pub struct DatasecContentCombinator(pub DatasecContentCombinatorAlias);
+pub struct TabletypeCombinator(pub TabletypeCombinatorAlias);
 
-impl View for DatasecContentCombinator {
-    type V = SpecDatasecContentCombinator;
-    open spec fn view(&self) -> Self::V { SpecDatasecContentCombinator(self.0@) }
+impl View for TabletypeCombinator {
+    type V = SpecTabletypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecTabletypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DatasecContentCombinator {
-    type Type = DatasecContent<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TabletypeCombinator {
+    type Type = Tabletype;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type DatasecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<DataCombinator>, DatasecContentCont0>, DatasecContentMapper>;
+}
+pub type TabletypeCombinatorAlias = Mapped<TabletypeCombinator1, TabletypeMapper>;
 
 
-pub open spec fn spec_datasec_content() -> SpecDatasecContentCombinator {
-    SpecDatasecContentCombinator(
+pub open spec fn spec_tabletype() -> SpecTabletypeCombinator {
+    SpecTabletypeCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_datasec_content_cont0(deps)),
-        mapper: DatasecContentMapper,
+        inner: (spec_reftype(), spec_limits()),
+        mapper: TabletypeMapper,
     })
 }
 
-pub open spec fn spec_datasec_content_cont0(deps: u64) -> RepeatN<SpecDataCombinator> {
-    let l = deps;
-    RepeatN(spec_data(), l.spec_into())
-}
-
-impl View for DatasecContentCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecDataCombinator>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_datasec_content_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn datasec_content<'a>() -> (o: DatasecContentCombinator)
-    ensures o@ == spec_datasec_content(),
+pub fn tabletype<'a>() -> (o: TabletypeCombinator)
+    ensures o@ == spec_tabletype(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = DatasecContentCombinator(
+    let combinator = TabletypeCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, DatasecContentCont0),
-        mapper: DatasecContentMapper,
-    });
-    assert({
-        &&& combinator@ == spec_datasec_content()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: TabletypeCombinator1((reftype(), limits())),
+        mapper: TabletypeMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_tabletype()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_datasec_content<'a>(input: &'a [u8]) -> (res: PResult<<DatasecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_tabletype<'a>(input: &'a [u8]) -> (res: PResult<<TabletypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_datasec_content().spec_parse(input@) == Some((n as int, v@)),
-        spec_datasec_content().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_tabletype().spec_parse(input@) == Some((n as int, v@)),
+        spec_tabletype().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_datasec_content().spec_parse(input@) is None,
-        spec_datasec_content().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_tabletype().spec_parse(input@) is None,
+        spec_tabletype().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = datasec_content();
+    let combinator = tabletype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_datasec_content<'a>(v: <DatasecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_tabletype<'a>(v: <TabletypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_datasec_content().wf(v@),
+        spec_tabletype().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_datasec_content().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_datasec_content().spec_serialize(v@))
+            &&& n == spec_tabletype().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_tabletype().spec_serialize(v@))
         },
 {
-    let combinator = datasec_content();
+    let combinator = tabletype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn datasec_content_len<'a>(v: <DatasecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn tabletype_len<'a>(v: <TabletypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_datasec_content().wf(v@),
-        spec_datasec_content().spec_serialize(v@).len() <= usize::MAX,
+        spec_tabletype().wf(v@),
+        spec_tabletype().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_datasec_content().spec_serialize(v@).len(),
+        serialize_len == spec_tabletype().spec_serialize(v@).len(),
 {
-    let combinator = datasec_content();
+    let combinator = tabletype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct DatasecContentCont0;
-type DatasecContentCont0Type<'a, 'b> = &'b u64;
-type DatasecContentCont0SType<'a, 'x> = &'x u64;
-type DatasecContentCont0Input<'a, 'b, 'x> = POrSType<DatasecContentCont0Type<'a, 'b>, DatasecContentCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<DatasecContentCont0Input<'a, 'b, 'x>> for DatasecContentCont0 {
-    type Output = RepeatN<DataCombinator>;
-
-    open spec fn requires(&self, deps: DatasecContentCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: DatasecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_datasec_content_cont0(deps@)
-    }
-
-    fn apply(&self, deps: DatasecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(data(), l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(data(), l.ex_into())
-            }
-        }
-    }
-}
                 
 
-pub struct SpecResulttype {
-    pub l: u64,
-    pub v: Seq<SpecValtype>,
+pub struct SpecGlobaltype {
+    pub t: SpecValtype,
+    pub m: SpecMutT,
 }
 
-pub type SpecResulttypeInner = (u64, Seq<SpecValtype>);
+pub type SpecGlobaltypeInner = (SpecValtype, SpecMutT);
 
 
-impl SpecFrom<SpecResulttype> for SpecResulttypeInner {
-    open spec fn spec_from(m: SpecResulttype) -> SpecResulttypeInner {
-        (m.l, m.v)
+impl SpecFrom<SpecGlobaltype> for SpecGlobaltypeInner {
+    open spec fn spec_from(m: SpecGlobaltype) -> SpecGlobaltypeInner {
+        (m.t, m.m)
     }
 }
 
-impl SpecFrom<SpecResulttypeInner> for SpecResulttype {
-    open spec fn spec_from(m: SpecResulttypeInner) -> SpecResulttype {
-        let (l, v) = m;
-        SpecResulttype { l, v }
+impl SpecFrom<SpecGlobaltypeInner> for SpecGlobaltype {
+    open spec fn spec_from(m: SpecGlobaltypeInner) -> SpecGlobaltype {
+        let (t, m) = m;
+        SpecGlobaltype { t, m }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Resulttype {
-    pub l: u64,
-    pub v: RepeatResult<Valtype>,
+pub struct Globaltype {
+    pub t: Valtype,
+    pub m: MutT,
 }
 
-impl View for Resulttype {
-    type V = SpecResulttype;
+impl View for Globaltype {
+    type V = SpecGlobaltype;
 
     open spec fn view(&self) -> Self::V {
-        SpecResulttype {
-            l: self.l@,
-            v: self.v@,
+        SpecGlobaltype {
+            t: self.t@,
+            m: self.m@,
         }
     }
 }
-pub type ResulttypeInner = (u64, RepeatResult<Valtype>);
+pub type GlobaltypeInner = (Valtype, MutT);
 
-pub type ResulttypeInnerRef<'a> = (&'a u64, &'a RepeatResult<Valtype>);
-impl<'a> From<&'a Resulttype> for ResulttypeInnerRef<'a> {
-    fn ex_from(m: &'a Resulttype) -> ResulttypeInnerRef<'a> {
-        (&m.l, &m.v)
+pub type GlobaltypeInnerRef<'a> = (&'a Valtype, &'a MutT);
+impl<'a> From<&'a Globaltype> for GlobaltypeInnerRef<'a> {
+    fn ex_from(m: &'a Globaltype) -> GlobaltypeInnerRef<'a> {
+        (&m.t, &m.m)
     }
 }
 
-impl From<ResulttypeInner> for Resulttype {
-    fn ex_from(m: ResulttypeInner) -> Resulttype {
-        let (l, v) = m;
-        Resulttype { l, v }
+impl From<GlobaltypeInner> for Globaltype {
+    fn ex_from(m: GlobaltypeInner) -> Globaltype {
+        let (t, m) = m;
+        Globaltype { t, m }
     }
 }
 
-pub struct ResulttypeMapper;
-impl View for ResulttypeMapper {
+pub struct GlobaltypeMapper;
+impl View for GlobaltypeMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ResulttypeMapper {
-    type Src = SpecResulttypeInner;
-    type Dst = SpecResulttype;
+impl SpecIso for GlobaltypeMapper {
+    type Src = SpecGlobaltypeInner;
+    type Dst = SpecGlobaltype;
 }
-impl SpecIsoProof for ResulttypeMapper {
+impl SpecIsoProof for GlobaltypeMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -15693,244 +15490,240 @@ impl SpecIsoProof for ResulttypeMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ResulttypeMapper {
-    type Src = ResulttypeInner;
-    type Dst = Resulttype;
-    type RefSrc = ResulttypeInnerRef<'a>;
+impl<'a> Iso<'a> for GlobaltypeMapper {
+    type Src = GlobaltypeInner;
+    type Dst = Globaltype;
+    type RefSrc = GlobaltypeInnerRef<'a>;
 }
+type SpecGlobaltypeCombinatorAlias1 = (SpecValtypeCombinator, SpecMutTCombinator);
+pub struct SpecGlobaltypeCombinator(pub SpecGlobaltypeCombinatorAlias);
 
-pub struct SpecResulttypeCombinator(pub SpecResulttypeCombinatorAlias);
-
-impl SpecCombinator for SpecResulttypeCombinator {
-    type Type = SpecResulttype;
+impl SpecCombinator for SpecGlobaltypeCombinator {
+    type Type = SpecGlobaltype;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecResulttypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecResulttypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecGlobaltypeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecGlobaltypeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecResulttypeCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecValtypeCombinator>>, ResulttypeMapper>;
+pub type SpecGlobaltypeCombinatorAlias = Mapped<SpecGlobaltypeCombinatorAlias1, GlobaltypeMapper>;
+type GlobaltypeCombinatorAlias1 = (ValtypeCombinator, MutTCombinator);
+pub struct GlobaltypeCombinator1(pub GlobaltypeCombinatorAlias1);
+impl View for GlobaltypeCombinator1 {
+    type V = SpecGlobaltypeCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(GlobaltypeCombinator1, GlobaltypeCombinatorAlias1);
 
-pub struct ResulttypeCombinator(pub ResulttypeCombinatorAlias);
+pub struct GlobaltypeCombinator(pub GlobaltypeCombinatorAlias);
 
-impl View for ResulttypeCombinator {
-    type V = SpecResulttypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecResulttypeCombinator(self.0@) }
+impl View for GlobaltypeCombinator {
+    type V = SpecGlobaltypeCombinator;
+    open spec fn view(&self) -> Self::V { SpecGlobaltypeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ResulttypeCombinator {
-    type Type = Resulttype;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GlobaltypeCombinator {
+    type Type = Globaltype;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ResulttypeCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ValtypeCombinator>, ResulttypeCont0>, ResulttypeMapper>;
+}
+pub type GlobaltypeCombinatorAlias = Mapped<GlobaltypeCombinator1, GlobaltypeMapper>;
 
 
-pub open spec fn spec_resulttype() -> SpecResulttypeCombinator {
-    SpecResulttypeCombinator(
+pub open spec fn spec_globaltype() -> SpecGlobaltypeCombinator {
+    SpecGlobaltypeCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_resulttype_cont0(deps)),
-        mapper: ResulttypeMapper,
+        inner: (spec_valtype(), spec_mut_t()),
+        mapper: GlobaltypeMapper,
     })
 }
 
-pub open spec fn spec_resulttype_cont0(deps: u64) -> RepeatN<SpecValtypeCombinator> {
-    let l = deps;
-    RepeatN(spec_valtype(), l.spec_into())
-}
-
-impl View for ResulttypeCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecValtypeCombinator>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_resulttype_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn resulttype<'a>() -> (o: ResulttypeCombinator)
-    ensures o@ == spec_resulttype(),
+pub fn globaltype<'a>() -> (o: GlobaltypeCombinator)
+    ensures o@ == spec_globaltype(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ResulttypeCombinator(
+    let combinator = GlobaltypeCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, ResulttypeCont0),
-        mapper: ResulttypeMapper,
-    });
-    assert({
-        &&& combinator@ == spec_resulttype()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: GlobaltypeCombinator1((valtype(), mut_t())),
+        mapper: GlobaltypeMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_globaltype()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_resulttype<'a>(input: &'a [u8]) -> (res: PResult<<ResulttypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_globaltype<'a>(input: &'a [u8]) -> (res: PResult<<GlobaltypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_resulttype().spec_parse(input@) == Some((n as int, v@)),
-        spec_resulttype().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_globaltype().spec_parse(input@) == Some((n as int, v@)),
+        spec_globaltype().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_resulttype().spec_parse(input@) is None,
-        spec_resulttype().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_globaltype().spec_parse(input@) is None,
+        spec_globaltype().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = resulttype();
+    let combinator = globaltype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_resulttype<'a>(v: <ResulttypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_globaltype<'a>(v: <GlobaltypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_resulttype().wf(v@),
+        spec_globaltype().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_resulttype().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_resulttype().spec_serialize(v@))
+            &&& n == spec_globaltype().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_globaltype().spec_serialize(v@))
         },
 {
-    let combinator = resulttype();
+    let combinator = globaltype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn resulttype_len<'a>(v: <ResulttypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn globaltype_len<'a>(v: <GlobaltypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_resulttype().wf(v@),
-        spec_resulttype().spec_serialize(v@).len() <= usize::MAX,
+        spec_globaltype().wf(v@),
+        spec_globaltype().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_resulttype().spec_serialize(v@).len(),
+        serialize_len == spec_globaltype().spec_serialize(v@).len(),
 {
-    let combinator = resulttype();
+    let combinator = globaltype();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ResulttypeCont0;
-type ResulttypeCont0Type<'a, 'b> = &'b u64;
-type ResulttypeCont0SType<'a, 'x> = &'x u64;
-type ResulttypeCont0Input<'a, 'b, 'x> = POrSType<ResulttypeCont0Type<'a, 'b>, ResulttypeCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ResulttypeCont0Input<'a, 'b, 'x>> for ResulttypeCont0 {
-    type Output = RepeatN<ValtypeCombinator>;
+                
+
+pub enum SpecImportdesc {
+    Func(SpecTypeidx),
+    Table(SpecTabletype),
+    Mem(SpecMemtype),
+    Global(SpecGlobaltype),
+}
 
-    open spec fn requires(&self, deps: ResulttypeCont0Input<'a, 'b, 'x>) -> bool { true }
+pub type SpecImportdescInner = Either<SpecTypeidx, Either<SpecTabletype, Either<SpecMemtype, SpecGlobaltype>>>;
 
-    open spec fn ensures(&self, deps: ResulttypeCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_resulttype_cont0(deps@)
+impl SpecFrom<SpecImportdesc> for SpecImportdescInner {
+    open spec fn spec_from(m: SpecImportdesc) -> SpecImportdescInner {
+        match m {
+            SpecImportdesc::Func(m) => Either::Left(m),
+            SpecImportdesc::Table(m) => Either::Right(Either::Left(m)),
+            SpecImportdesc::Mem(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecImportdesc::Global(m) => Either::Right(Either::Right(Either::Right(m))),
+        }
     }
 
-    fn apply(&self, deps: ResulttypeCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(valtype(), l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(valtype(), l.ex_into())
-            }
+}
+
+                
+impl SpecFrom<SpecImportdescInner> for SpecImportdesc {
+    open spec fn spec_from(m: SpecImportdescInner) -> SpecImportdesc {
+        match m {
+            Either::Left(m) => SpecImportdesc::Func(m),
+            Either::Right(Either::Left(m)) => SpecImportdesc::Table(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecImportdesc::Mem(m),
+            Either::Right(Either::Right(Either::Right(m))) => SpecImportdesc::Global(m),
         }
     }
-}
-                
 
-pub struct SpecFunctype {
-    pub tag: u8,
-    pub params: SpecResulttype,
-    pub results: SpecResulttype,
 }
 
-pub type SpecFunctypeInner = (u8, (SpecResulttype, SpecResulttype));
 
 
-impl SpecFrom<SpecFunctype> for SpecFunctypeInner {
-    open spec fn spec_from(m: SpecFunctype) -> SpecFunctypeInner {
-        (m.tag, (m.params, m.results))
-    }
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Importdesc {
+    Func(Typeidx),
+    Table(Tabletype),
+    Mem(Memtype),
+    Global(Globaltype),
 }
 
-impl SpecFrom<SpecFunctypeInner> for SpecFunctype {
-    open spec fn spec_from(m: SpecFunctypeInner) -> SpecFunctype {
-        let (tag, (params, results)) = m;
-        SpecFunctype { tag, params, results }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
+pub type ImportdescInner = Either<Typeidx, Either<Tabletype, Either<Memtype, Globaltype>>>;
 
-pub struct Functype {
-    pub tag: u8,
-    pub params: Resulttype,
-    pub results: Resulttype,
-}
+pub type ImportdescInnerRef<'a> = Either<&'a Typeidx, Either<&'a Tabletype, Either<&'a Memtype, &'a Globaltype>>>;
 
-impl View for Functype {
-    type V = SpecFunctype;
 
+impl View for Importdesc {
+    type V = SpecImportdesc;
     open spec fn view(&self) -> Self::V {
-        SpecFunctype {
-            tag: self.tag@,
-            params: self.params@,
-            results: self.results@,
+        match self {
+            Importdesc::Func(m) => SpecImportdesc::Func(m@),
+            Importdesc::Table(m) => SpecImportdesc::Table(m@),
+            Importdesc::Mem(m) => SpecImportdesc::Mem(m@),
+            Importdesc::Global(m) => SpecImportdesc::Global(m@),
         }
     }
 }
-pub type FunctypeInner = (u8, (Resulttype, Resulttype));
 
-pub type FunctypeInnerRef<'a> = (&'a u8, (&'a Resulttype, &'a Resulttype));
-impl<'a> From<&'a Functype> for FunctypeInnerRef<'a> {
-    fn ex_from(m: &'a Functype) -> FunctypeInnerRef<'a> {
-        (&m.tag, (&m.params, &m.results))
+
+impl<'a> From<&'a Importdesc> for ImportdescInnerRef<'a> {
+    fn ex_from(m: &'a Importdesc) -> ImportdescInnerRef<'a> {
+        match m {
+            Importdesc::Func(m) => Either::Left(m),
+            Importdesc::Table(m) => Either::Right(Either::Left(m)),
+            Importdesc::Mem(m) => Either::Right(Either::Right(Either::Left(m))),
+            Importdesc::Global(m) => Either::Right(Either::Right(Either::Right(m))),
+        }
     }
+
 }
 
-impl From<FunctypeInner> for Functype {
-    fn ex_from(m: FunctypeInner) -> Functype {
-        let (tag, (params, results)) = m;
-        Functype { tag, params, results }
+impl From<ImportdescInner> for Importdesc {
+    fn ex_from(m: ImportdescInner) -> Importdesc {
+        match m {
+            Either::Left(m) => Importdesc::Func(m),
+            Either::Right(Either::Left(m)) => Importdesc::Table(m),
+            Either::Right(Either::Right(Either::Left(m))) => Importdesc::Mem(m),
+            Either::Right(Either::Right(Either::Right(m))) => Importdesc::Global(m),
+        }
     }
+    
 }
 
-pub struct FunctypeMapper;
-impl View for FunctypeMapper {
+
+pub struct ImportdescMapper;
+impl View for ImportdescMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for FunctypeMapper {
-    type Src = SpecFunctypeInner;
-    type Dst = SpecFunctype;
+impl SpecIso for ImportdescMapper {
+    type Src = SpecImportdescInner;
+    type Dst = SpecImportdesc;
 }
-impl SpecIsoProof for FunctypeMapper {
+impl SpecIsoProof for ImportdescMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -15938,368 +15731,448 @@ impl SpecIsoProof for FunctypeMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for FunctypeMapper {
-    type Src = FunctypeInner;
-    type Dst = Functype;
-    type RefSrc = FunctypeInnerRef<'a>;
+impl<'a> Iso<'a> for ImportdescMapper {
+    type Src = ImportdescInner;
+    type Dst = Importdesc;
+    type RefSrc = ImportdescInnerRef<'a>;
 }
-pub const FUNCTYPETAG_CONST: u8 = 96;
-type SpecFunctypeCombinatorAlias1 = (SpecResulttypeCombinator, SpecResulttypeCombinator);
-type SpecFunctypeCombinatorAlias2 = (Refined<U8, TagPred<u8>>, SpecFunctypeCombinatorAlias1);
-pub struct SpecFunctypeCombinator(pub SpecFunctypeCombinatorAlias);
 
-impl SpecCombinator for SpecFunctypeCombinator {
-    type Type = SpecFunctype;
+pub const IMPORTDESCFUNC_0_FRONT_CONST: u8 = 0;
+
+pub const IMPORTDESCTABLE_0_FRONT_CONST: u8 = 1;
+
+pub const IMPORTDESCMEM_0_FRONT_CONST: u8 = 2;
+
+pub const IMPORTDESCGLOBAL_0_FRONT_CONST: u8 = 3;
+
+type SpecImportdescCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, SpecMemtypeCombinator>, Preceded<Tag<U8, u8>, SpecGlobaltypeCombinator>>;
+type SpecImportdescCombinatorAlias2 = Choice<Preceded<Tag<U8, u8>, SpecTabletypeCombinator>, SpecImportdescCombinatorAlias1>;
+type SpecImportdescCombinatorAlias3 = Choice<Preceded<Tag<U8, u8>, SpecTypeidxCombinator>, SpecImportdescCombinatorAlias2>;
+pub struct SpecImportdescCombinator(pub SpecImportdescCombinatorAlias);
+
+impl SpecCombinator for SpecImportdescCombinator {
+    type Type = SpecImportdesc;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecFunctypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecFunctypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecImportdescCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecImportdescCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecFunctypeCombinatorAlias = Mapped<SpecFunctypeCombinatorAlias2, FunctypeMapper>;
-type FunctypeCombinatorAlias1 = (ResulttypeCombinator, ResulttypeCombinator);
-type FunctypeCombinatorAlias2 = (Refined<U8, TagPred<u8>>, FunctypeCombinator1);
-pub struct FunctypeCombinator1(pub FunctypeCombinatorAlias1);
-impl View for FunctypeCombinator1 {
-    type V = SpecFunctypeCombinatorAlias1;
+pub type SpecImportdescCombinatorAlias = Mapped<SpecImportdescCombinatorAlias3, ImportdescMapper>;
+
+
+
+
+type ImportdescCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, MemtypeCombinator>, Preceded<Tag<U8, u8>, GlobaltypeCombinator>>;
+type ImportdescCombinatorAlias2 = Choice<Preceded<Tag<U8, u8>, TabletypeCombinator>, ImportdescCombinator1>;
+type ImportdescCombinatorAlias3 = Choice<Preceded<Tag<U8, u8>, TypeidxCombinator>, ImportdescCombinator2>;
+pub struct ImportdescCombinator1(pub ImportdescCombinatorAlias1);
+impl View for ImportdescCombinator1 {
+    type V = SpecImportdescCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(FunctypeCombinator1, FunctypeCombinatorAlias1);
+impl_wrapper_combinator!(ImportdescCombinator1, ImportdescCombinatorAlias1);
 
-pub struct FunctypeCombinator2(pub FunctypeCombinatorAlias2);
-impl View for FunctypeCombinator2 {
-    type V = SpecFunctypeCombinatorAlias2;
+pub struct ImportdescCombinator2(pub ImportdescCombinatorAlias2);
+impl View for ImportdescCombinator2 {
+    type V = SpecImportdescCombinatorAlias2;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(FunctypeCombinator2, FunctypeCombinatorAlias2);
+impl_wrapper_combinator!(ImportdescCombinator2, ImportdescCombinatorAlias2);
 
-pub struct FunctypeCombinator(pub FunctypeCombinatorAlias);
+pub struct ImportdescCombinator3(pub ImportdescCombinatorAlias3);
+impl View for ImportdescCombinator3 {
+    type V = SpecImportdescCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ImportdescCombinator3, ImportdescCombinatorAlias3);
 
-impl View for FunctypeCombinator {
-    type V = SpecFunctypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecFunctypeCombinator(self.0@) }
+pub struct ImportdescCombinator(pub ImportdescCombinatorAlias);
+
+impl View for ImportdescCombinator {
+    type V = SpecImportdescCombinator;
+    open spec fn view(&self) -> Self::V { SpecImportdescCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FunctypeCombinator {
-    type Type = Functype;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ImportdescCombinator {
+    type Type = Importdesc;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type FunctypeCombinatorAlias = Mapped<FunctypeCombinator2, FunctypeMapper>;
+}
+pub type ImportdescCombinatorAlias = Mapped<ImportdescCombinator3, ImportdescMapper>;
 
 
-pub open spec fn spec_functype() -> SpecFunctypeCombinator {
-    SpecFunctypeCombinator(
-    Mapped {
-        inner: (Refined { inner: U8, predicate: TagPred(FUNCTYPETAG_CONST) }, (spec_resulttype(), spec_resulttype())),
-        mapper: FunctypeMapper,
-    })
+pub open spec fn spec_importdesc() -> SpecImportdescCombinator {
+    SpecImportdescCombinator(Mapped { inner: Choice(Preceded(Tag::spec_new(U8, IMPORTDESCFUNC_0_FRONT_CONST), spec_typeidx()), Choice(Preceded(Tag::spec_new(U8, IMPORTDESCTABLE_0_FRONT_CONST), spec_tabletype()), Choice(Preceded(Tag::spec_new(U8, IMPORTDESCMEM_0_FRONT_CONST), spec_memtype()), Preceded(Tag::spec_new(U8, IMPORTDESCGLOBAL_0_FRONT_CONST), spec_globaltype())))), mapper: ImportdescMapper })
 }
 
                 
-pub fn functype<'a>() -> (o: FunctypeCombinator)
-    ensures o@ == spec_functype(),
+pub fn importdesc<'a>() -> (o: ImportdescCombinator)
+    ensures o@ == spec_importdesc(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = FunctypeCombinator(
-    Mapped {
-        inner: FunctypeCombinator2((Refined { inner: U8, predicate: TagPred(FUNCTYPETAG_CONST) }, FunctypeCombinator1((resulttype(), resulttype())))),
-        mapper: FunctypeMapper,
-    });
-    assert({
-        &&& combinator@ == spec_functype()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ImportdescCombinator(Mapped { inner: ImportdescCombinator3(Choice::new(Preceded(Tag::new(U8, IMPORTDESCFUNC_0_FRONT_CONST), typeidx()), ImportdescCombinator2(Choice::new(Preceded(Tag::new(U8, IMPORTDESCTABLE_0_FRONT_CONST), tabletype()), ImportdescCombinator1(Choice::new(Preceded(Tag::new(U8, IMPORTDESCMEM_0_FRONT_CONST), memtype()), Preceded(Tag::new(U8, IMPORTDESCGLOBAL_0_FRONT_CONST), globaltype()))))))), mapper: ImportdescMapper });
+    // assert({
+    //     &&& combinator@ == spec_importdesc()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_functype<'a>(input: &'a [u8]) -> (res: PResult<<FunctypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_importdesc<'a>(input: &'a [u8]) -> (res: PResult<<ImportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_functype().spec_parse(input@) == Some((n as int, v@)),
-        spec_functype().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_importdesc().spec_parse(input@) == Some((n as int, v@)),
+        spec_importdesc().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_functype().spec_parse(input@) is None,
-        spec_functype().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_importdesc().spec_parse(input@) is None,
+        spec_importdesc().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = functype();
+    let combinator = importdesc();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_functype<'a>(v: <FunctypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_functype().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_functype().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_functype().spec_serialize(v@))
-        },
-{
-    let combinator = functype();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
-}
+pub fn serialize_importdesc<'a>(v: <ImportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_importdesc().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_importdesc().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_importdesc().spec_serialize(v@))
+        },
+{
+    let combinator = importdesc();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn importdesc_len<'a>(v: <ImportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_importdesc().wf(v@),
+        spec_importdesc().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_importdesc().spec_serialize(v@).len(),
+{
+    let combinator = importdesc();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+                
+
+pub struct SpecImport {
+    pub module: SpecName,
+    pub name: SpecName,
+    pub desc: SpecImportdesc,
+}
+
+pub type SpecImportInner = (SpecName, (SpecName, SpecImportdesc));
+
+
+impl SpecFrom<SpecImport> for SpecImportInner {
+    open spec fn spec_from(m: SpecImport) -> SpecImportInner {
+        (m.module, (m.name, m.desc))
+    }
+}
+
+impl SpecFrom<SpecImportInner> for SpecImport {
+    open spec fn spec_from(m: SpecImportInner) -> SpecImport {
+        let (module, (name, desc)) = m;
+        SpecImport { module, name, desc }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Import {
+    pub module: Name,
+    pub name: Name,
+    pub desc: Importdesc,
+}
+
+impl View for Import {
+    type V = SpecImport;
 
-pub fn functype_len<'a>(v: <FunctypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_functype().wf(v@),
-        spec_functype().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_functype().spec_serialize(v@).len(),
-{
-    let combinator = functype();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+    open spec fn view(&self) -> Self::V {
+        SpecImport {
+            module: self.module@,
+            name: self.name@,
+            desc: self.desc@,
+        }
+    }
 }
+pub type ImportInner = (Name, (Name, Importdesc));
 
-                
-pub type SpecName = SpecByteVec;
-pub type Name = ByteVec;
-pub type NameRef<'a> = &'a ByteVec;
+pub type ImportInnerRef<'a> = (&'a Name, (&'a Name, &'a Importdesc));
+impl<'a> From<&'a Import> for ImportInnerRef<'a> {
+    fn ex_from(m: &'a Import) -> ImportInnerRef<'a> {
+        (&m.module, (&m.name, &m.desc))
+    }
+}
 
+impl From<ImportInner> for Import {
+    fn ex_from(m: ImportInner) -> Import {
+        let (module, (name, desc)) = m;
+        Import { module, name, desc }
+    }
+}
 
-pub struct SpecNameCombinator(pub SpecNameCombinatorAlias);
+pub struct ImportMapper;
+impl View for ImportMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ImportMapper {
+    type Src = SpecImportInner;
+    type Dst = SpecImport;
+}
+impl SpecIsoProof for ImportMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ImportMapper {
+    type Src = ImportInner;
+    type Dst = Import;
+    type RefSrc = ImportInnerRef<'a>;
+}
+type SpecImportCombinatorAlias1 = (SpecNameCombinator, SpecImportdescCombinator);
+type SpecImportCombinatorAlias2 = (SpecNameCombinator, SpecImportCombinatorAlias1);
+pub struct SpecImportCombinator(pub SpecImportCombinatorAlias);
 
-impl SpecCombinator for SpecNameCombinator {
-    type Type = SpecName;
+impl SpecCombinator for SpecImportCombinator {
+    type Type = SpecImport;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecNameCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecNameCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecImportCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecImportCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecNameCombinatorAlias = SpecByteVecCombinator;
+pub type SpecImportCombinatorAlias = Mapped<SpecImportCombinatorAlias2, ImportMapper>;
+type ImportCombinatorAlias1 = (NameCombinator, ImportdescCombinator);
+type ImportCombinatorAlias2 = (NameCombinator, ImportCombinator1);
+pub struct ImportCombinator1(pub ImportCombinatorAlias1);
+impl View for ImportCombinator1 {
+    type V = SpecImportCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ImportCombinator1, ImportCombinatorAlias1);
 
-pub struct NameCombinator(pub NameCombinatorAlias);
+pub struct ImportCombinator2(pub ImportCombinatorAlias2);
+impl View for ImportCombinator2 {
+    type V = SpecImportCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ImportCombinator2, ImportCombinatorAlias2);
 
-impl View for NameCombinator {
-    type V = SpecNameCombinator;
-    open spec fn view(&self) -> Self::V { SpecNameCombinator(self.0@) }
+pub struct ImportCombinator(pub ImportCombinatorAlias);
+
+impl View for ImportCombinator {
+    type V = SpecImportCombinator;
+    open spec fn view(&self) -> Self::V { SpecImportCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for NameCombinator {
-    type Type = Name;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ImportCombinator {
+    type Type = Import;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type NameCombinatorAlias = ByteVecCombinator;
+}
+pub type ImportCombinatorAlias = Mapped<ImportCombinator2, ImportMapper>;
 
 
-pub open spec fn spec_name() -> SpecNameCombinator {
-    SpecNameCombinator(spec_byte_vec())
+pub open spec fn spec_import() -> SpecImportCombinator {
+    SpecImportCombinator(
+    Mapped {
+        inner: (spec_name(), (spec_name(), spec_importdesc())),
+        mapper: ImportMapper,
+    })
 }
 
                 
-pub fn name<'a>() -> (o: NameCombinator)
-    ensures o@ == spec_name(),
+pub fn import<'a>() -> (o: ImportCombinator)
+    ensures o@ == spec_import(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = NameCombinator(byte_vec());
-    assert({
-        &&& combinator@ == spec_name()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ImportCombinator(
+    Mapped {
+        inner: ImportCombinator2((name(), ImportCombinator1((name(), importdesc())))),
+        mapper: ImportMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_import()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_name<'a>(input: &'a [u8]) -> (res: PResult<<NameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_import<'a>(input: &'a [u8]) -> (res: PResult<<ImportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_name().spec_parse(input@) == Some((n as int, v@)),
-        spec_name().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_import().spec_parse(input@) == Some((n as int, v@)),
+        spec_import().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_name().spec_parse(input@) is None,
-        spec_name().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_import().spec_parse(input@) is None,
+        spec_import().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = name();
+    let combinator = import();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_name<'a>(v: <NameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_import<'a>(v: <ImportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_name().wf(v@),
+        spec_import().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& 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@))
+            &&& n == spec_import().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_import().spec_serialize(v@))
         },
 {
-    let combinator = name();
+    let combinator = import();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn name_len<'a>(v: <NameCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn import_len<'a>(v: <ImportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_name().wf(v@),
-        spec_name().spec_serialize(v@).len() <= usize::MAX,
+        spec_import().wf(v@),
+        spec_import().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_name().spec_serialize(v@).len(),
+        serialize_len == spec_import().spec_serialize(v@).len(),
 {
-    let combinator = name();
+    let combinator = import();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub enum SpecExportdesc {
-    Func(SpecFuncidx),
-    Table(SpecTableidx),
-    Mem(SpecMemidx),
-    Global(SpecGlobalidx),
+pub struct SpecImports {
+    pub l: u64,
+    pub v: Seq<SpecImport>,
 }
 
-pub type SpecExportdescInner = Either<SpecFuncidx, Either<SpecTableidx, Either<SpecMemidx, SpecGlobalidx>>>;
+pub type SpecImportsInner = (u64, Seq<SpecImport>);
 
-impl SpecFrom<SpecExportdesc> for SpecExportdescInner {
-    open spec fn spec_from(m: SpecExportdesc) -> SpecExportdescInner {
-        match m {
-            SpecExportdesc::Func(m) => Either::Left(m),
-            SpecExportdesc::Table(m) => Either::Right(Either::Left(m)),
-            SpecExportdesc::Mem(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecExportdesc::Global(m) => Either::Right(Either::Right(Either::Right(m))),
-        }
-    }
 
+impl SpecFrom<SpecImports> for SpecImportsInner {
+    open spec fn spec_from(m: SpecImports) -> SpecImportsInner {
+        (m.l, m.v)
+    }
 }
 
-                
-impl SpecFrom<SpecExportdescInner> for SpecExportdesc {
-    open spec fn spec_from(m: SpecExportdescInner) -> SpecExportdesc {
-        match m {
-            Either::Left(m) => SpecExportdesc::Func(m),
-            Either::Right(Either::Left(m)) => SpecExportdesc::Table(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecExportdesc::Mem(m),
-            Either::Right(Either::Right(Either::Right(m))) => SpecExportdesc::Global(m),
-        }
+impl SpecFrom<SpecImportsInner> for SpecImports {
+    open spec fn spec_from(m: SpecImportsInner) -> SpecImports {
+        let (l, v) = m;
+        SpecImports { l, v }
     }
-
 }
-
-
-
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Exportdesc {
-    Func(Funcidx),
-    Table(Tableidx),
-    Mem(Memidx),
-    Global(Globalidx),
-}
-
-pub type ExportdescInner = Either<Funcidx, Either<Tableidx, Either<Memidx, Globalidx>>>;
-
-pub type ExportdescInnerRef<'a> = Either<&'a Funcidx, Either<&'a Tableidx, Either<&'a Memidx, &'a Globalidx>>>;
-
 
-impl View for Exportdesc {
-    type V = SpecExportdesc;
-    open spec fn view(&self) -> Self::V {
-        match self {
-            Exportdesc::Func(m) => SpecExportdesc::Func(m@),
-            Exportdesc::Table(m) => SpecExportdesc::Table(m@),
-            Exportdesc::Mem(m) => SpecExportdesc::Mem(m@),
-            Exportdesc::Global(m) => SpecExportdesc::Global(m@),
-        }
-    }
+pub struct Imports {
+    pub l: u64,
+    pub v: RepeatResult<Import>,
 }
 
+impl View for Imports {
+    type V = SpecImports;
 
-impl<'a> From<&'a Exportdesc> for ExportdescInnerRef<'a> {
-    fn ex_from(m: &'a Exportdesc) -> ExportdescInnerRef<'a> {
-        match m {
-            Exportdesc::Func(m) => Either::Left(m),
-            Exportdesc::Table(m) => Either::Right(Either::Left(m)),
-            Exportdesc::Mem(m) => Either::Right(Either::Right(Either::Left(m))),
-            Exportdesc::Global(m) => Either::Right(Either::Right(Either::Right(m))),
+    open spec fn view(&self) -> Self::V {
+        SpecImports {
+            l: self.l@,
+            v: self.v@,
         }
     }
-
 }
+pub type ImportsInner = (u64, RepeatResult<Import>);
 
-impl From<ExportdescInner> for Exportdesc {
-    fn ex_from(m: ExportdescInner) -> Exportdesc {
-        match m {
-            Either::Left(m) => Exportdesc::Func(m),
-            Either::Right(Either::Left(m)) => Exportdesc::Table(m),
-            Either::Right(Either::Right(Either::Left(m))) => Exportdesc::Mem(m),
-            Either::Right(Either::Right(Either::Right(m))) => Exportdesc::Global(m),
-        }
+pub type ImportsInnerRef<'a> = (&'a u64, &'a RepeatResult<Import>);
+impl<'a> From<&'a Imports> for ImportsInnerRef<'a> {
+    fn ex_from(m: &'a Imports) -> ImportsInnerRef<'a> {
+        (&m.l, &m.v)
     }
-    
 }
 
+impl From<ImportsInner> for Imports {
+    fn ex_from(m: ImportsInner) -> Imports {
+        let (l, v) = m;
+        Imports { l, v }
+    }
+}
 
-pub struct ExportdescMapper;
-impl View for ExportdescMapper {
+pub struct ImportsMapper;
+impl View for ImportsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ExportdescMapper {
-    type Src = SpecExportdescInner;
-    type Dst = SpecExportdesc;
+impl SpecIso for ImportsMapper {
+    type Src = SpecImportsInner;
+    type Dst = SpecImports;
 }
-impl SpecIsoProof for ExportdescMapper {
+impl SpecIsoProof for ImportsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -16307,229 +16180,245 @@ impl SpecIsoProof for ExportdescMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ExportdescMapper {
-    type Src = ExportdescInner;
-    type Dst = Exportdesc;
-    type RefSrc = ExportdescInnerRef<'a>;
+impl<'a> Iso<'a> for ImportsMapper {
+    type Src = ImportsInner;
+    type Dst = Imports;
+    type RefSrc = ImportsInnerRef<'a>;
 }
 
-pub const EXPORTDESCFUNC_0_FRONT_CONST: u8 = 0;
-
-pub const EXPORTDESCTABLE_0_FRONT_CONST: u8 = 1;
-
-pub const EXPORTDESCMEM_0_FRONT_CONST: u8 = 2;
-
-pub const EXPORTDESCGLOBAL_0_FRONT_CONST: u8 = 3;
-
-type SpecExportdescCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, SpecMemidxCombinator>, Preceded<Tag<U8, u8>, SpecGlobalidxCombinator>>;
-type SpecExportdescCombinatorAlias2 = Choice<Preceded<Tag<U8, u8>, SpecTableidxCombinator>, SpecExportdescCombinatorAlias1>;
-type SpecExportdescCombinatorAlias3 = Choice<Preceded<Tag<U8, u8>, SpecFuncidxCombinator>, SpecExportdescCombinatorAlias2>;
-pub struct SpecExportdescCombinator(pub SpecExportdescCombinatorAlias);
+pub struct SpecImportsCombinator(pub SpecImportsCombinatorAlias);
 
-impl SpecCombinator for SpecExportdescCombinator {
-    type Type = SpecExportdesc;
+impl SpecCombinator for SpecImportsCombinator {
+    type Type = SpecImports;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecExportdescCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecExportdescCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecImportsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecImportsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecExportdescCombinatorAlias = Mapped<SpecExportdescCombinatorAlias3, ExportdescMapper>;
-
-
-
-
-type ExportdescCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, MemidxCombinator>, Preceded<Tag<U8, u8>, GlobalidxCombinator>>;
-type ExportdescCombinatorAlias2 = Choice<Preceded<Tag<U8, u8>, TableidxCombinator>, ExportdescCombinator1>;
-type ExportdescCombinatorAlias3 = Choice<Preceded<Tag<U8, u8>, FuncidxCombinator>, ExportdescCombinator2>;
-pub struct ExportdescCombinator1(pub ExportdescCombinatorAlias1);
-impl View for ExportdescCombinator1 {
-    type V = SpecExportdescCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ExportdescCombinator1, ExportdescCombinatorAlias1);
-
-pub struct ExportdescCombinator2(pub ExportdescCombinatorAlias2);
-impl View for ExportdescCombinator2 {
-    type V = SpecExportdescCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ExportdescCombinator2, ExportdescCombinatorAlias2);
-
-pub struct ExportdescCombinator3(pub ExportdescCombinatorAlias3);
-impl View for ExportdescCombinator3 {
-    type V = SpecExportdescCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ExportdescCombinator3, ExportdescCombinatorAlias3);
+pub type SpecImportsCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecImportCombinator>>, ImportsMapper>;
 
-pub struct ExportdescCombinator(pub ExportdescCombinatorAlias);
+pub struct ImportsCombinator(pub ImportsCombinatorAlias);
 
-impl View for ExportdescCombinator {
-    type V = SpecExportdescCombinator;
-    open spec fn view(&self) -> Self::V { SpecExportdescCombinator(self.0@) }
+impl View for ImportsCombinator {
+    type V = SpecImportsCombinator;
+    open spec fn view(&self) -> Self::V { SpecImportsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExportdescCombinator {
-    type Type = Exportdesc;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ImportsCombinator {
+    type Type = Imports;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ExportdescCombinatorAlias = Mapped<ExportdescCombinator3, ExportdescMapper>;
+}
+pub type ImportsCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ImportCombinator>, ImportsCont0>, ImportsMapper>;
 
 
-pub open spec fn spec_exportdesc() -> SpecExportdescCombinator {
-    SpecExportdescCombinator(Mapped { inner: Choice(Preceded(Tag::spec_new(U8, EXPORTDESCFUNC_0_FRONT_CONST), spec_funcidx()), Choice(Preceded(Tag::spec_new(U8, EXPORTDESCTABLE_0_FRONT_CONST), spec_tableidx()), Choice(Preceded(Tag::spec_new(U8, EXPORTDESCMEM_0_FRONT_CONST), spec_memidx()), Preceded(Tag::spec_new(U8, EXPORTDESCGLOBAL_0_FRONT_CONST), spec_globalidx())))), mapper: ExportdescMapper })
+pub open spec fn spec_imports() -> SpecImportsCombinator {
+    SpecImportsCombinator(
+    Mapped {
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_imports_cont0(deps)),
+        mapper: ImportsMapper,
+    })
+}
+
+pub open spec fn spec_imports_cont0(deps: u64) -> RepeatN<SpecImportCombinator> {
+    let l = deps;
+    RepeatN(spec_import(), (usize::spec_from(l)) as usize)
+}
+
+impl View for ImportsCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecImportCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_imports_cont0(deps)
+        }
+    }
 }
 
                 
-pub fn exportdesc<'a>() -> (o: ExportdescCombinator)
-    ensures o@ == spec_exportdesc(),
+pub fn imports<'a>() -> (o: ImportsCombinator)
+    ensures o@ == spec_imports(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ExportdescCombinator(Mapped { inner: ExportdescCombinator3(Choice::new(Preceded(Tag::new(U8, EXPORTDESCFUNC_0_FRONT_CONST), funcidx()), ExportdescCombinator2(Choice::new(Preceded(Tag::new(U8, EXPORTDESCTABLE_0_FRONT_CONST), tableidx()), ExportdescCombinator1(Choice::new(Preceded(Tag::new(U8, EXPORTDESCMEM_0_FRONT_CONST), memidx()), Preceded(Tag::new(U8, EXPORTDESCGLOBAL_0_FRONT_CONST), globalidx()))))))), mapper: ExportdescMapper });
-    assert({
-        &&& combinator@ == spec_exportdesc()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ImportsCombinator(
+    Mapped {
+        inner: Pair::new(UnsignedLEB128, ImportsCont0),
+        mapper: ImportsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_imports()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_exportdesc<'a>(input: &'a [u8]) -> (res: PResult<<ExportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_imports<'a>(input: &'a [u8]) -> (res: PResult<<ImportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_exportdesc().spec_parse(input@) == Some((n as int, v@)),
-        spec_exportdesc().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_imports().spec_parse(input@) == Some((n as int, v@)),
+        spec_imports().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_exportdesc().spec_parse(input@) is None,
-        spec_exportdesc().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_imports().spec_parse(input@) is None,
+        spec_imports().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = exportdesc();
+    let combinator = imports();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_exportdesc<'a>(v: <ExportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_imports<'a>(v: <ImportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_exportdesc().wf(v@),
+        spec_imports().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_exportdesc().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_exportdesc().spec_serialize(v@))
+            &&& n == spec_imports().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_imports().spec_serialize(v@))
         },
 {
-    let combinator = exportdesc();
+    let combinator = imports();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn exportdesc_len<'a>(v: <ExportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn imports_len<'a>(v: <ImportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_exportdesc().wf(v@),
-        spec_exportdesc().spec_serialize(v@).len() <= usize::MAX,
+        spec_imports().wf(v@),
+        spec_imports().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_exportdesc().spec_serialize(v@).len(),
+        serialize_len == spec_imports().spec_serialize(v@).len(),
 {
-    let combinator = exportdesc();
+    let combinator = imports();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct ImportsCont0;
+type ImportsCont0Type<'a, 'b> = &'b u64;
+type ImportsCont0SType<'a, 'x> = &'x u64;
+type ImportsCont0Input<'a, 'b, 'x> = POrSType<ImportsCont0Type<'a, 'b>, ImportsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ImportsCont0Input<'a, 'b, 'x>> for ImportsCont0 {
+    type Output = RepeatN<ImportCombinator>;
+
+    open spec fn requires(&self, deps: ImportsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: ImportsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_imports_cont0(deps@)
+    }
+
+    fn apply(&self, deps: ImportsCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(import(), (usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(import(), (usize::ex_from(l)) as usize)
+            }
+        }
+    }
+}
                 
 
-pub struct SpecExport {
-    pub nm: SpecName,
-    pub d: SpecExportdesc,
+pub struct SpecImportsec {
+    pub size: u64,
+    pub cont: SpecImports,
 }
 
-pub type SpecExportInner = (SpecName, SpecExportdesc);
+pub type SpecImportsecInner = (u64, SpecImports);
 
 
-impl SpecFrom<SpecExport> for SpecExportInner {
-    open spec fn spec_from(m: SpecExport) -> SpecExportInner {
-        (m.nm, m.d)
+impl SpecFrom<SpecImportsec> for SpecImportsecInner {
+    open spec fn spec_from(m: SpecImportsec) -> SpecImportsecInner {
+        (m.size, m.cont)
     }
 }
 
-impl SpecFrom<SpecExportInner> for SpecExport {
-    open spec fn spec_from(m: SpecExportInner) -> SpecExport {
-        let (nm, d) = m;
-        SpecExport { nm, d }
+impl SpecFrom<SpecImportsecInner> for SpecImportsec {
+    open spec fn spec_from(m: SpecImportsecInner) -> SpecImportsec {
+        let (size, cont) = m;
+        SpecImportsec { size, cont }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Export {
-    pub nm: Name,
-    pub d: Exportdesc,
+pub struct Importsec {
+    pub size: u64,
+    pub cont: Imports,
 }
 
-impl View for Export {
-    type V = SpecExport;
+impl View for Importsec {
+    type V = SpecImportsec;
 
     open spec fn view(&self) -> Self::V {
-        SpecExport {
-            nm: self.nm@,
-            d: self.d@,
+        SpecImportsec {
+            size: self.size@,
+            cont: self.cont@,
         }
     }
 }
-pub type ExportInner = (Name, Exportdesc);
+pub type ImportsecInner = (u64, Imports);
 
-pub type ExportInnerRef<'a> = (&'a Name, &'a Exportdesc);
-impl<'a> From<&'a Export> for ExportInnerRef<'a> {
-    fn ex_from(m: &'a Export) -> ExportInnerRef<'a> {
-        (&m.nm, &m.d)
+pub type ImportsecInnerRef<'a> = (&'a u64, &'a Imports);
+impl<'a> From<&'a Importsec> for ImportsecInnerRef<'a> {
+    fn ex_from(m: &'a Importsec) -> ImportsecInnerRef<'a> {
+        (&m.size, &m.cont)
     }
 }
 
-impl From<ExportInner> for Export {
-    fn ex_from(m: ExportInner) -> Export {
-        let (nm, d) = m;
-        Export { nm, d }
+impl From<ImportsecInner> for Importsec {
+    fn ex_from(m: ImportsecInner) -> Importsec {
+        let (size, cont) = m;
+        Importsec { size, cont }
     }
 }
 
-pub struct ExportMapper;
-impl View for ExportMapper {
+pub struct ImportsecMapper;
+impl View for ImportsecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ExportMapper {
-    type Src = SpecExportInner;
-    type Dst = SpecExport;
+impl SpecIso for ImportsecMapper {
+    type Src = SpecImportsecInner;
+    type Dst = SpecImportsec;
 }
-impl SpecIsoProof for ExportMapper {
+impl SpecIsoProof for ImportsecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -16537,206 +16426,245 @@ impl SpecIsoProof for ExportMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ExportMapper {
-    type Src = ExportInner;
-    type Dst = Export;
-    type RefSrc = ExportInnerRef<'a>;
+impl<'a> Iso<'a> for ImportsecMapper {
+    type Src = ImportsecInner;
+    type Dst = Importsec;
+    type RefSrc = ImportsecInnerRef<'a>;
 }
-type SpecExportCombinatorAlias1 = (SpecNameCombinator, SpecExportdescCombinator);
-pub struct SpecExportCombinator(pub SpecExportCombinatorAlias);
 
-impl SpecCombinator for SpecExportCombinator {
-    type Type = SpecExport;
+pub struct SpecImportsecCombinator(pub SpecImportsecCombinatorAlias);
+
+impl SpecCombinator for SpecImportsecCombinator {
+    type Type = SpecImportsec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecExportCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecExportCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecImportsecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecImportsecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecExportCombinatorAlias = Mapped<SpecExportCombinatorAlias1, ExportMapper>;
-type ExportCombinatorAlias1 = (NameCombinator, ExportdescCombinator);
-pub struct ExportCombinator1(pub ExportCombinatorAlias1);
-impl View for ExportCombinator1 {
-    type V = SpecExportCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ExportCombinator1, ExportCombinatorAlias1);
+pub type SpecImportsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecImportsCombinator>>, ImportsecMapper>;
 
-pub struct ExportCombinator(pub ExportCombinatorAlias);
+pub struct ImportsecCombinator(pub ImportsecCombinatorAlias);
 
-impl View for ExportCombinator {
-    type V = SpecExportCombinator;
-    open spec fn view(&self) -> Self::V { SpecExportCombinator(self.0@) }
+impl View for ImportsecCombinator {
+    type V = SpecImportsecCombinator;
+    open spec fn view(&self) -> Self::V { SpecImportsecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExportCombinator {
-    type Type = Export;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ImportsecCombinator {
+    type Type = Importsec;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ExportCombinatorAlias = Mapped<ExportCombinator1, ExportMapper>;
+}
+pub type ImportsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, ImportsCombinator>, ImportsecCont0>, ImportsecMapper>;
 
 
-pub open spec fn spec_export() -> SpecExportCombinator {
-    SpecExportCombinator(
+pub open spec fn spec_importsec() -> SpecImportsecCombinator {
+    SpecImportsecCombinator(
     Mapped {
-        inner: (spec_name(), spec_exportdesc()),
-        mapper: ExportMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_importsec_cont0(deps)),
+        mapper: ImportsecMapper,
     })
 }
 
+pub open spec fn spec_importsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecImportsCombinator> {
+    let size = deps;
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_imports())
+}
+
+impl View for ImportsecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecImportsCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_importsec_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn export<'a>() -> (o: ExportCombinator)
-    ensures o@ == spec_export(),
+pub fn importsec<'a>() -> (o: ImportsecCombinator)
+    ensures o@ == spec_importsec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ExportCombinator(
+    let combinator = ImportsecCombinator(
     Mapped {
-        inner: ExportCombinator1((name(), exportdesc())),
-        mapper: ExportMapper,
-    });
-    assert({
-        &&& combinator@ == spec_export()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, ImportsecCont0),
+        mapper: ImportsecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_importsec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_export<'a>(input: &'a [u8]) -> (res: PResult<<ExportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_importsec<'a>(input: &'a [u8]) -> (res: PResult<<ImportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_export().spec_parse(input@) == Some((n as int, v@)),
-        spec_export().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_importsec().spec_parse(input@) == Some((n as int, v@)),
+        spec_importsec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_export().spec_parse(input@) is None,
-        spec_export().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_importsec().spec_parse(input@) is None,
+        spec_importsec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = export();
+    let combinator = importsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_export<'a>(v: <ExportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_importsec<'a>(v: <ImportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_export().wf(v@),
+        spec_importsec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_export().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_export().spec_serialize(v@))
+            &&& n == spec_importsec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_importsec().spec_serialize(v@))
         },
 {
-    let combinator = export();
+    let combinator = importsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn export_len<'a>(v: <ExportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn importsec_len<'a>(v: <ImportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_export().wf(v@),
-        spec_export().spec_serialize(v@).len() <= usize::MAX,
+        spec_importsec().wf(v@),
+        spec_importsec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_export().spec_serialize(v@).len(),
+        serialize_len == spec_importsec().spec_serialize(v@).len(),
 {
-    let combinator = export();
+    let combinator = importsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct ImportsecCont0;
+type ImportsecCont0Type<'a, 'b> = &'b u64;
+type ImportsecCont0SType<'a, 'x> = &'x u64;
+type ImportsecCont0Input<'a, 'b, 'x> = POrSType<ImportsecCont0Type<'a, 'b>, ImportsecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ImportsecCont0Input<'a, 'b, 'x>> for ImportsecCont0 {
+    type Output = AndThen<bytes::Variable, ImportsCombinator>;
+
+    open spec fn requires(&self, deps: ImportsecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: ImportsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_importsec_cont0(deps@)
+    }
+
+    fn apply(&self, deps: ImportsecCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), imports())
+            }
+            POrSType::S(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), imports())
+            }
+        }
+    }
+}
                 
 
-pub struct SpecExports {
+pub struct SpecFuncsecContent {
     pub l: u64,
-    pub v: Seq<SpecExport>,
+    pub v: Seq<SpecTypeidx>,
 }
 
-pub type SpecExportsInner = (u64, Seq<SpecExport>);
+pub type SpecFuncsecContentInner = (u64, Seq<SpecTypeidx>);
 
 
-impl SpecFrom<SpecExports> for SpecExportsInner {
-    open spec fn spec_from(m: SpecExports) -> SpecExportsInner {
+impl SpecFrom<SpecFuncsecContent> for SpecFuncsecContentInner {
+    open spec fn spec_from(m: SpecFuncsecContent) -> SpecFuncsecContentInner {
         (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecExportsInner> for SpecExports {
-    open spec fn spec_from(m: SpecExportsInner) -> SpecExports {
+impl SpecFrom<SpecFuncsecContentInner> for SpecFuncsecContent {
+    open spec fn spec_from(m: SpecFuncsecContentInner) -> SpecFuncsecContent {
         let (l, v) = m;
-        SpecExports { l, v }
+        SpecFuncsecContent { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Exports {
+pub struct FuncsecContent {
     pub l: u64,
-    pub v: RepeatResult<Export>,
+    pub v: RepeatResult<Typeidx>,
 }
 
-impl View for Exports {
-    type V = SpecExports;
+impl View for FuncsecContent {
+    type V = SpecFuncsecContent;
 
     open spec fn view(&self) -> Self::V {
-        SpecExports {
+        SpecFuncsecContent {
             l: self.l@,
             v: self.v@,
         }
     }
 }
-pub type ExportsInner = (u64, RepeatResult<Export>);
+pub type FuncsecContentInner = (u64, RepeatResult<Typeidx>);
 
-pub type ExportsInnerRef<'a> = (&'a u64, &'a RepeatResult<Export>);
-impl<'a> From<&'a Exports> for ExportsInnerRef<'a> {
-    fn ex_from(m: &'a Exports) -> ExportsInnerRef<'a> {
+pub type FuncsecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Typeidx>);
+impl<'a> From<&'a FuncsecContent> for FuncsecContentInnerRef<'a> {
+    fn ex_from(m: &'a FuncsecContent) -> FuncsecContentInnerRef<'a> {
         (&m.l, &m.v)
     }
 }
 
-impl From<ExportsInner> for Exports {
-    fn ex_from(m: ExportsInner) -> Exports {
+impl From<FuncsecContentInner> for FuncsecContent {
+    fn ex_from(m: FuncsecContentInner) -> FuncsecContent {
         let (l, v) = m;
-        Exports { l, v }
+        FuncsecContent { l, v }
     }
 }
 
-pub struct ExportsMapper;
-impl View for ExportsMapper {
+pub struct FuncsecContentMapper;
+impl View for FuncsecContentMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ExportsMapper {
-    type Src = SpecExportsInner;
-    type Dst = SpecExports;
+impl SpecIso for FuncsecContentMapper {
+    type Src = SpecFuncsecContentInner;
+    type Dst = SpecFuncsecContent;
 }
-impl SpecIsoProof for ExportsMapper {
+impl SpecIsoProof for FuncsecContentMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -16744,241 +16672,245 @@ impl SpecIsoProof for ExportsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ExportsMapper {
-    type Src = ExportsInner;
-    type Dst = Exports;
-    type RefSrc = ExportsInnerRef<'a>;
+impl<'a> Iso<'a> for FuncsecContentMapper {
+    type Src = FuncsecContentInner;
+    type Dst = FuncsecContent;
+    type RefSrc = FuncsecContentInnerRef<'a>;
 }
 
-pub struct SpecExportsCombinator(pub SpecExportsCombinatorAlias);
+pub struct SpecFuncsecContentCombinator(pub SpecFuncsecContentCombinatorAlias);
 
-impl SpecCombinator for SpecExportsCombinator {
-    type Type = SpecExports;
+impl SpecCombinator for SpecFuncsecContentCombinator {
+    type Type = SpecFuncsecContent;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecExportsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecExportsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecFuncsecContentCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecFuncsecContentCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecExportsCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecExportCombinator>>, ExportsMapper>;
+pub type SpecFuncsecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecTypeidxCombinator>>, FuncsecContentMapper>;
 
-pub struct ExportsCombinator(pub ExportsCombinatorAlias);
+pub struct FuncsecContentCombinator(pub FuncsecContentCombinatorAlias);
 
-impl View for ExportsCombinator {
-    type V = SpecExportsCombinator;
-    open spec fn view(&self) -> Self::V { SpecExportsCombinator(self.0@) }
+impl View for FuncsecContentCombinator {
+    type V = SpecFuncsecContentCombinator;
+    open spec fn view(&self) -> Self::V { SpecFuncsecContentCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExportsCombinator {
-    type Type = Exports;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FuncsecContentCombinator {
+    type Type = FuncsecContent;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ExportsCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ExportCombinator>, ExportsCont0>, ExportsMapper>;
+}
+pub type FuncsecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<TypeidxCombinator>, FuncsecContentCont0>, FuncsecContentMapper>;
 
 
-pub open spec fn spec_exports() -> SpecExportsCombinator {
-    SpecExportsCombinator(
+pub open spec fn spec_funcsec_content() -> SpecFuncsecContentCombinator {
+    SpecFuncsecContentCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_exports_cont0(deps)),
-        mapper: ExportsMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_funcsec_content_cont0(deps)),
+        mapper: FuncsecContentMapper,
     })
 }
 
-pub open spec fn spec_exports_cont0(deps: u64) -> RepeatN<SpecExportCombinator> {
+pub open spec fn spec_funcsec_content_cont0(deps: u64) -> RepeatN<SpecTypeidxCombinator> {
     let l = deps;
-    RepeatN(spec_export(), l.spec_into())
+    RepeatN(spec_typeidx(), (usize::spec_from(l)) as usize)
 }
 
-impl View for ExportsCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecExportCombinator>;
+impl View for FuncsecContentCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecTypeidxCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_exports_cont0(deps)
+            spec_funcsec_content_cont0(deps)
         }
     }
 }
 
                 
-pub fn exports<'a>() -> (o: ExportsCombinator)
-    ensures o@ == spec_exports(),
+pub fn funcsec_content<'a>() -> (o: FuncsecContentCombinator)
+    ensures o@ == spec_funcsec_content(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ExportsCombinator(
+    let combinator = FuncsecContentCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, ExportsCont0),
-        mapper: ExportsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_exports()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, FuncsecContentCont0),
+        mapper: FuncsecContentMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_funcsec_content()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_exports<'a>(input: &'a [u8]) -> (res: PResult<<ExportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_funcsec_content<'a>(input: &'a [u8]) -> (res: PResult<<FuncsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_exports().spec_parse(input@) == Some((n as int, v@)),
-        spec_exports().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_funcsec_content().spec_parse(input@) == Some((n as int, v@)),
+        spec_funcsec_content().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_exports().spec_parse(input@) is None,
-        spec_exports().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_funcsec_content().spec_parse(input@) is None,
+        spec_funcsec_content().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = exports();
+    let combinator = funcsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_exports<'a>(v: <ExportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_funcsec_content<'a>(v: <FuncsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_exports().wf(v@),
+        spec_funcsec_content().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_exports().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_exports().spec_serialize(v@))
+            &&& n == spec_funcsec_content().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_funcsec_content().spec_serialize(v@))
         },
 {
-    let combinator = exports();
+    let combinator = funcsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn exports_len<'a>(v: <ExportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn funcsec_content_len<'a>(v: <FuncsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_exports().wf(v@),
-        spec_exports().spec_serialize(v@).len() <= usize::MAX,
+        spec_funcsec_content().wf(v@),
+        spec_funcsec_content().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_exports().spec_serialize(v@).len(),
+        serialize_len == spec_funcsec_content().spec_serialize(v@).len(),
 {
-    let combinator = exports();
+    let combinator = funcsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ExportsCont0;
-type ExportsCont0Type<'a, 'b> = &'b u64;
-type ExportsCont0SType<'a, 'x> = &'x u64;
-type ExportsCont0Input<'a, 'b, 'x> = POrSType<ExportsCont0Type<'a, 'b>, ExportsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ExportsCont0Input<'a, 'b, 'x>> for ExportsCont0 {
-    type Output = RepeatN<ExportCombinator>;
+pub struct FuncsecContentCont0;
+type FuncsecContentCont0Type<'a, 'b> = &'b u64;
+type FuncsecContentCont0SType<'a, 'x> = &'x u64;
+type FuncsecContentCont0Input<'a, 'b, 'x> = POrSType<FuncsecContentCont0Type<'a, 'b>, FuncsecContentCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<FuncsecContentCont0Input<'a, 'b, 'x>> for FuncsecContentCont0 {
+    type Output = RepeatN<TypeidxCombinator>;
 
-    open spec fn requires(&self, deps: ExportsCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: FuncsecContentCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: ExportsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_exports_cont0(deps@)
+    open spec fn ensures(&self, deps: FuncsecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_funcsec_content_cont0(deps@)
     }
 
-    fn apply(&self, deps: ExportsCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: FuncsecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(export(), l.ex_into())
+                let l = deps;
+                let l = *l;
+                RepeatN(typeidx(), (usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                RepeatN(export(), l.ex_into())
+                RepeatN(typeidx(), (usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
 
-pub struct SpecExportsec {
+pub struct SpecFuncsec {
     pub size: u64,
-    pub cont: SpecExports,
+    pub cont: SpecFuncsecContent,
 }
 
-pub type SpecExportsecInner = (u64, SpecExports);
+pub type SpecFuncsecInner = (u64, SpecFuncsecContent);
 
 
-impl SpecFrom<SpecExportsec> for SpecExportsecInner {
-    open spec fn spec_from(m: SpecExportsec) -> SpecExportsecInner {
+impl SpecFrom<SpecFuncsec> for SpecFuncsecInner {
+    open spec fn spec_from(m: SpecFuncsec) -> SpecFuncsecInner {
         (m.size, m.cont)
     }
 }
 
-impl SpecFrom<SpecExportsecInner> for SpecExportsec {
-    open spec fn spec_from(m: SpecExportsecInner) -> SpecExportsec {
+impl SpecFrom<SpecFuncsecInner> for SpecFuncsec {
+    open spec fn spec_from(m: SpecFuncsecInner) -> SpecFuncsec {
         let (size, cont) = m;
-        SpecExportsec { size, cont }
+        SpecFuncsec { size, cont }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Exportsec {
+pub struct Funcsec {
     pub size: u64,
-    pub cont: Exports,
+    pub cont: FuncsecContent,
 }
 
-impl View for Exportsec {
-    type V = SpecExportsec;
+impl View for Funcsec {
+    type V = SpecFuncsec;
 
     open spec fn view(&self) -> Self::V {
-        SpecExportsec {
+        SpecFuncsec {
             size: self.size@,
             cont: self.cont@,
         }
     }
 }
-pub type ExportsecInner = (u64, Exports);
+pub type FuncsecInner = (u64, FuncsecContent);
 
-pub type ExportsecInnerRef<'a> = (&'a u64, &'a Exports);
-impl<'a> From<&'a Exportsec> for ExportsecInnerRef<'a> {
-    fn ex_from(m: &'a Exportsec) -> ExportsecInnerRef<'a> {
+pub type FuncsecInnerRef<'a> = (&'a u64, &'a FuncsecContent);
+impl<'a> From<&'a Funcsec> for FuncsecInnerRef<'a> {
+    fn ex_from(m: &'a Funcsec) -> FuncsecInnerRef<'a> {
         (&m.size, &m.cont)
     }
 }
 
-impl From<ExportsecInner> for Exportsec {
-    fn ex_from(m: ExportsecInner) -> Exportsec {
+impl From<FuncsecInner> for Funcsec {
+    fn ex_from(m: FuncsecInner) -> Funcsec {
         let (size, cont) = m;
-        Exportsec { size, cont }
+        Funcsec { size, cont }
     }
 }
 
-pub struct ExportsecMapper;
-impl View for ExportsecMapper {
+pub struct FuncsecMapper;
+impl View for FuncsecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ExportsecMapper {
-    type Src = SpecExportsecInner;
-    type Dst = SpecExportsec;
+impl SpecIso for FuncsecMapper {
+    type Src = SpecFuncsecInner;
+    type Dst = SpecFuncsec;
 }
-impl SpecIsoProof for ExportsecMapper {
+impl SpecIsoProof for FuncsecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -16986,238 +16918,242 @@ impl SpecIsoProof for ExportsecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ExportsecMapper {
-    type Src = ExportsecInner;
-    type Dst = Exportsec;
-    type RefSrc = ExportsecInnerRef<'a>;
+impl<'a> Iso<'a> for FuncsecMapper {
+    type Src = FuncsecInner;
+    type Dst = Funcsec;
+    type RefSrc = FuncsecInnerRef<'a>;
 }
 
-pub struct SpecExportsecCombinator(pub SpecExportsecCombinatorAlias);
+pub struct SpecFuncsecCombinator(pub SpecFuncsecCombinatorAlias);
 
-impl SpecCombinator for SpecExportsecCombinator {
-    type Type = SpecExportsec;
+impl SpecCombinator for SpecFuncsecCombinator {
+    type Type = SpecFuncsec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecExportsecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecExportsecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecFuncsecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecFuncsecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecExportsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecExportsCombinator>>, ExportsecMapper>;
+pub type SpecFuncsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecFuncsecContentCombinator>>, FuncsecMapper>;
 
-pub struct ExportsecCombinator(pub ExportsecCombinatorAlias);
+pub struct FuncsecCombinator(pub FuncsecCombinatorAlias);
 
-impl View for ExportsecCombinator {
-    type V = SpecExportsecCombinator;
-    open spec fn view(&self) -> Self::V { SpecExportsecCombinator(self.0@) }
+impl View for FuncsecCombinator {
+    type V = SpecFuncsecCombinator;
+    open spec fn view(&self) -> Self::V { SpecFuncsecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExportsecCombinator {
-    type Type = Exportsec;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FuncsecCombinator {
+    type Type = Funcsec;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ExportsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, ExportsCombinator>, ExportsecCont0>, ExportsecMapper>;
+}
+pub type FuncsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, FuncsecContentCombinator>, FuncsecCont0>, FuncsecMapper>;
 
 
-pub open spec fn spec_exportsec() -> SpecExportsecCombinator {
-    SpecExportsecCombinator(
+pub open spec fn spec_funcsec() -> SpecFuncsecCombinator {
+    SpecFuncsecCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_exportsec_cont0(deps)),
-        mapper: ExportsecMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_funcsec_cont0(deps)),
+        mapper: FuncsecMapper,
     })
 }
 
-pub open spec fn spec_exportsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecExportsCombinator> {
+pub open spec fn spec_funcsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecFuncsecContentCombinator> {
     let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_exports())
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_funcsec_content())
 }
 
-impl View for ExportsecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecExportsCombinator>;
+impl View for FuncsecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecFuncsecContentCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_exportsec_cont0(deps)
+            spec_funcsec_cont0(deps)
         }
     }
 }
 
                 
-pub fn exportsec<'a>() -> (o: ExportsecCombinator)
-    ensures o@ == spec_exportsec(),
+pub fn funcsec<'a>() -> (o: FuncsecCombinator)
+    ensures o@ == spec_funcsec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ExportsecCombinator(
+    let combinator = FuncsecCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, ExportsecCont0),
-        mapper: ExportsecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_exportsec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, FuncsecCont0),
+        mapper: FuncsecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_funcsec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_exportsec<'a>(input: &'a [u8]) -> (res: PResult<<ExportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_funcsec<'a>(input: &'a [u8]) -> (res: PResult<<FuncsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_exportsec().spec_parse(input@) == Some((n as int, v@)),
-        spec_exportsec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_funcsec().spec_parse(input@) == Some((n as int, v@)),
+        spec_funcsec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_exportsec().spec_parse(input@) is None,
-        spec_exportsec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_funcsec().spec_parse(input@) is None,
+        spec_funcsec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = exportsec();
+    let combinator = funcsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_exportsec<'a>(v: <ExportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_funcsec<'a>(v: <FuncsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_exportsec().wf(v@),
+        spec_funcsec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_exportsec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_exportsec().spec_serialize(v@))
+            &&& n == spec_funcsec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_funcsec().spec_serialize(v@))
         },
 {
-    let combinator = exportsec();
+    let combinator = funcsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn exportsec_len<'a>(v: <ExportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn funcsec_len<'a>(v: <FuncsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_exportsec().wf(v@),
-        spec_exportsec().spec_serialize(v@).len() <= usize::MAX,
+        spec_funcsec().wf(v@),
+        spec_funcsec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_exportsec().spec_serialize(v@).len(),
+        serialize_len == spec_funcsec().spec_serialize(v@).len(),
 {
-    let combinator = exportsec();
+    let combinator = funcsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ExportsecCont0;
-type ExportsecCont0Type<'a, 'b> = &'b u64;
-type ExportsecCont0SType<'a, 'x> = &'x u64;
-type ExportsecCont0Input<'a, 'b, 'x> = POrSType<ExportsecCont0Type<'a, 'b>, ExportsecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ExportsecCont0Input<'a, 'b, 'x>> for ExportsecCont0 {
-    type Output = AndThen<bytes::Variable, ExportsCombinator>;
+pub struct FuncsecCont0;
+type FuncsecCont0Type<'a, 'b> = &'b u64;
+type FuncsecCont0SType<'a, 'x> = &'x u64;
+type FuncsecCont0Input<'a, 'b, 'x> = POrSType<FuncsecCont0Type<'a, 'b>, FuncsecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<FuncsecCont0Input<'a, 'b, 'x>> for FuncsecCont0 {
+    type Output = AndThen<bytes::Variable, FuncsecContentCombinator>;
 
-    open spec fn requires(&self, deps: ExportsecCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: FuncsecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: ExportsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_exportsec_cont0(deps@)
+    open spec fn ensures(&self, deps: FuncsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_funcsec_cont0(deps@)
     }
 
-    fn apply(&self, deps: ExportsecCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: FuncsecCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), exports())
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), funcsec_content())
             }
             POrSType::S(deps) => {
                 let size = deps;
                 let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), exports())
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), funcsec_content())
             }
         }
     }
 }
                 
 
-pub struct SpecLimitMin {
-    pub min: u64,
+pub struct SpecTable {
+    pub ty: SpecTabletype,
 }
 
-pub type SpecLimitMinInner = u64;
+pub type SpecTableInner = SpecTabletype;
 
 
-impl SpecFrom<SpecLimitMin> for SpecLimitMinInner {
-    open spec fn spec_from(m: SpecLimitMin) -> SpecLimitMinInner {
-        m.min
+impl SpecFrom<SpecTable> for SpecTableInner {
+    open spec fn spec_from(m: SpecTable) -> SpecTableInner {
+        m.ty
     }
 }
 
-impl SpecFrom<SpecLimitMinInner> for SpecLimitMin {
-    open spec fn spec_from(m: SpecLimitMinInner) -> SpecLimitMin {
-        let min = m;
-        SpecLimitMin { min }
+impl SpecFrom<SpecTableInner> for SpecTable {
+    open spec fn spec_from(m: SpecTableInner) -> SpecTable {
+        let ty = m;
+        SpecTable { ty }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct LimitMin {
-    pub min: u64,
+pub struct Table {
+    pub ty: Tabletype,
 }
 
-impl View for LimitMin {
-    type V = SpecLimitMin;
+impl View for Table {
+    type V = SpecTable;
 
     open spec fn view(&self) -> Self::V {
-        SpecLimitMin {
-            min: self.min@,
+        SpecTable {
+            ty: self.ty@,
         }
     }
 }
-pub type LimitMinInner = u64;
+pub type TableInner = Tabletype;
 
-pub type LimitMinInnerRef<'a> = &'a u64;
-impl<'a> From<&'a LimitMin> for LimitMinInnerRef<'a> {
-    fn ex_from(m: &'a LimitMin) -> LimitMinInnerRef<'a> {
-        &m.min
+pub type TableInnerRef<'a> = &'a Tabletype;
+impl<'a> From<&'a Table> for TableInnerRef<'a> {
+    fn ex_from(m: &'a Table) -> TableInnerRef<'a> {
+        &m.ty
     }
 }
 
-impl From<LimitMinInner> for LimitMin {
-    fn ex_from(m: LimitMinInner) -> LimitMin {
-        let min = m;
-        LimitMin { min }
+impl From<TableInner> for Table {
+    fn ex_from(m: TableInner) -> Table {
+        let ty = m;
+        Table { ty }
     }
 }
 
-pub struct LimitMinMapper;
-impl View for LimitMinMapper {
+pub struct TableMapper;
+impl View for TableMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for LimitMinMapper {
-    type Src = SpecLimitMinInner;
-    type Dst = SpecLimitMin;
+impl SpecIso for TableMapper {
+    type Src = SpecTableInner;
+    type Dst = SpecTable;
 }
-impl SpecIsoProof for LimitMinMapper {
+impl SpecIsoProof for TableMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -17225,199 +17161,199 @@ impl SpecIsoProof for LimitMinMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for LimitMinMapper {
-    type Src = LimitMinInner;
-    type Dst = LimitMin;
-    type RefSrc = LimitMinInnerRef<'a>;
+impl<'a> Iso<'a> for TableMapper {
+    type Src = TableInner;
+    type Dst = Table;
+    type RefSrc = TableInnerRef<'a>;
 }
 
-pub struct SpecLimitMinCombinator(pub SpecLimitMinCombinatorAlias);
+pub struct SpecTableCombinator(pub SpecTableCombinatorAlias);
 
-impl SpecCombinator for SpecLimitMinCombinator {
-    type Type = SpecLimitMin;
+impl SpecCombinator for SpecTableCombinator {
+    type Type = SpecTable;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecLimitMinCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecLimitMinCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTableCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTableCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecLimitMinCombinatorAlias = Mapped<UnsignedLEB128, LimitMinMapper>;
+pub type SpecTableCombinatorAlias = Mapped<SpecTabletypeCombinator, TableMapper>;
 
-pub struct LimitMinCombinator(pub LimitMinCombinatorAlias);
+pub struct TableCombinator(pub TableCombinatorAlias);
 
-impl View for LimitMinCombinator {
-    type V = SpecLimitMinCombinator;
-    open spec fn view(&self) -> Self::V { SpecLimitMinCombinator(self.0@) }
+impl View for TableCombinator {
+    type V = SpecTableCombinator;
+    open spec fn view(&self) -> Self::V { SpecTableCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LimitMinCombinator {
-    type Type = LimitMin;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TableCombinator {
+    type Type = Table;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type LimitMinCombinatorAlias = Mapped<UnsignedLEB128, LimitMinMapper>;
+}
+pub type TableCombinatorAlias = Mapped<TabletypeCombinator, TableMapper>;
 
 
-pub open spec fn spec_limit_min() -> SpecLimitMinCombinator {
-    SpecLimitMinCombinator(
+pub open spec fn spec_table() -> SpecTableCombinator {
+    SpecTableCombinator(
     Mapped {
-        inner: UnsignedLEB128,
-        mapper: LimitMinMapper,
+        inner: spec_tabletype(),
+        mapper: TableMapper,
     })
 }
 
                 
-pub fn limit_min<'a>() -> (o: LimitMinCombinator)
-    ensures o@ == spec_limit_min(),
+pub fn table<'a>() -> (o: TableCombinator)
+    ensures o@ == spec_table(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = LimitMinCombinator(
+    let combinator = TableCombinator(
     Mapped {
-        inner: UnsignedLEB128,
-        mapper: LimitMinMapper,
-    });
-    assert({
-        &&& combinator@ == spec_limit_min()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: tabletype(),
+        mapper: TableMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_table()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_limit_min<'a>(input: &'a [u8]) -> (res: PResult<<LimitMinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_table<'a>(input: &'a [u8]) -> (res: PResult<<TableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_limit_min().spec_parse(input@) == Some((n as int, v@)),
-        spec_limit_min().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_table().spec_parse(input@) == Some((n as int, v@)),
+        spec_table().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_limit_min().spec_parse(input@) is None,
-        spec_limit_min().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_table().spec_parse(input@) is None,
+        spec_table().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = limit_min();
+    let combinator = table();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_limit_min<'a>(v: <LimitMinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_table<'a>(v: <TableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_limit_min().wf(v@),
+        spec_table().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_limit_min().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_limit_min().spec_serialize(v@))
+            &&& n == spec_table().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_table().spec_serialize(v@))
         },
 {
-    let combinator = limit_min();
+    let combinator = table();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn limit_min_len<'a>(v: <LimitMinCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn table_len<'a>(v: <TableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_limit_min().wf(v@),
-        spec_limit_min().spec_serialize(v@).len() <= usize::MAX,
+        spec_table().wf(v@),
+        spec_table().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_limit_min().spec_serialize(v@).len(),
+        serialize_len == spec_table().spec_serialize(v@).len(),
 {
-    let combinator = limit_min();
+    let combinator = table();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecLocalCompressed {
-    pub count: u64,
-    pub vt: SpecValtype,
+pub struct SpecTablesecContent {
+    pub l: u64,
+    pub v: Seq<SpecTable>,
 }
 
-pub type SpecLocalCompressedInner = (u64, SpecValtype);
+pub type SpecTablesecContentInner = (u64, Seq<SpecTable>);
 
 
-impl SpecFrom<SpecLocalCompressed> for SpecLocalCompressedInner {
-    open spec fn spec_from(m: SpecLocalCompressed) -> SpecLocalCompressedInner {
-        (m.count, m.vt)
+impl SpecFrom<SpecTablesecContent> for SpecTablesecContentInner {
+    open spec fn spec_from(m: SpecTablesecContent) -> SpecTablesecContentInner {
+        (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecLocalCompressedInner> for SpecLocalCompressed {
-    open spec fn spec_from(m: SpecLocalCompressedInner) -> SpecLocalCompressed {
-        let (count, vt) = m;
-        SpecLocalCompressed { count, vt }
+impl SpecFrom<SpecTablesecContentInner> for SpecTablesecContent {
+    open spec fn spec_from(m: SpecTablesecContentInner) -> SpecTablesecContent {
+        let (l, v) = m;
+        SpecTablesecContent { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct LocalCompressed {
-    pub count: u64,
-    pub vt: Valtype,
+pub struct TablesecContent {
+    pub l: u64,
+    pub v: RepeatResult<Table>,
 }
 
-impl View for LocalCompressed {
-    type V = SpecLocalCompressed;
+impl View for TablesecContent {
+    type V = SpecTablesecContent;
 
     open spec fn view(&self) -> Self::V {
-        SpecLocalCompressed {
-            count: self.count@,
-            vt: self.vt@,
+        SpecTablesecContent {
+            l: self.l@,
+            v: self.v@,
         }
     }
 }
-pub type LocalCompressedInner = (u64, Valtype);
+pub type TablesecContentInner = (u64, RepeatResult<Table>);
 
-pub type LocalCompressedInnerRef<'a> = (&'a u64, &'a Valtype);
-impl<'a> From<&'a LocalCompressed> for LocalCompressedInnerRef<'a> {
-    fn ex_from(m: &'a LocalCompressed) -> LocalCompressedInnerRef<'a> {
-        (&m.count, &m.vt)
+pub type TablesecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Table>);
+impl<'a> From<&'a TablesecContent> for TablesecContentInnerRef<'a> {
+    fn ex_from(m: &'a TablesecContent) -> TablesecContentInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-impl From<LocalCompressedInner> for LocalCompressed {
-    fn ex_from(m: LocalCompressedInner) -> LocalCompressed {
-        let (count, vt) = m;
-        LocalCompressed { count, vt }
+impl From<TablesecContentInner> for TablesecContent {
+    fn ex_from(m: TablesecContentInner) -> TablesecContent {
+        let (l, v) = m;
+        TablesecContent { l, v }
     }
 }
 
-pub struct LocalCompressedMapper;
-impl View for LocalCompressedMapper {
+pub struct TablesecContentMapper;
+impl View for TablesecContentMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for LocalCompressedMapper {
-    type Src = SpecLocalCompressedInner;
-    type Dst = SpecLocalCompressed;
+impl SpecIso for TablesecContentMapper {
+    type Src = SpecTablesecContentInner;
+    type Dst = SpecTablesecContent;
 }
-impl SpecIsoProof for LocalCompressedMapper {
+impl SpecIsoProof for TablesecContentMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -17425,206 +17361,245 @@ impl SpecIsoProof for LocalCompressedMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for LocalCompressedMapper {
-    type Src = LocalCompressedInner;
-    type Dst = LocalCompressed;
-    type RefSrc = LocalCompressedInnerRef<'a>;
+impl<'a> Iso<'a> for TablesecContentMapper {
+    type Src = TablesecContentInner;
+    type Dst = TablesecContent;
+    type RefSrc = TablesecContentInnerRef<'a>;
 }
-type SpecLocalCompressedCombinatorAlias1 = (UnsignedLEB128, SpecValtypeCombinator);
-pub struct SpecLocalCompressedCombinator(pub SpecLocalCompressedCombinatorAlias);
 
-impl SpecCombinator for SpecLocalCompressedCombinator {
-    type Type = SpecLocalCompressed;
+pub struct SpecTablesecContentCombinator(pub SpecTablesecContentCombinatorAlias);
+
+impl SpecCombinator for SpecTablesecContentCombinator {
+    type Type = SpecTablesecContent;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecLocalCompressedCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecLocalCompressedCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTablesecContentCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTablesecContentCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecLocalCompressedCombinatorAlias = Mapped<SpecLocalCompressedCombinatorAlias1, LocalCompressedMapper>;
-type LocalCompressedCombinatorAlias1 = (UnsignedLEB128, ValtypeCombinator);
-pub struct LocalCompressedCombinator1(pub LocalCompressedCombinatorAlias1);
-impl View for LocalCompressedCombinator1 {
-    type V = SpecLocalCompressedCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(LocalCompressedCombinator1, LocalCompressedCombinatorAlias1);
+pub type SpecTablesecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecTableCombinator>>, TablesecContentMapper>;
 
-pub struct LocalCompressedCombinator(pub LocalCompressedCombinatorAlias);
+pub struct TablesecContentCombinator(pub TablesecContentCombinatorAlias);
 
-impl View for LocalCompressedCombinator {
-    type V = SpecLocalCompressedCombinator;
-    open spec fn view(&self) -> Self::V { SpecLocalCompressedCombinator(self.0@) }
+impl View for TablesecContentCombinator {
+    type V = SpecTablesecContentCombinator;
+    open spec fn view(&self) -> Self::V { SpecTablesecContentCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LocalCompressedCombinator {
-    type Type = LocalCompressed;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TablesecContentCombinator {
+    type Type = TablesecContent;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type LocalCompressedCombinatorAlias = Mapped<LocalCompressedCombinator1, LocalCompressedMapper>;
+}
+pub type TablesecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<TableCombinator>, TablesecContentCont0>, TablesecContentMapper>;
 
 
-pub open spec fn spec_local_compressed() -> SpecLocalCompressedCombinator {
-    SpecLocalCompressedCombinator(
+pub open spec fn spec_tablesec_content() -> SpecTablesecContentCombinator {
+    SpecTablesecContentCombinator(
     Mapped {
-        inner: (UnsignedLEB128, spec_valtype()),
-        mapper: LocalCompressedMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_tablesec_content_cont0(deps)),
+        mapper: TablesecContentMapper,
     })
 }
 
+pub open spec fn spec_tablesec_content_cont0(deps: u64) -> RepeatN<SpecTableCombinator> {
+    let l = deps;
+    RepeatN(spec_table(), (usize::spec_from(l)) as usize)
+}
+
+impl View for TablesecContentCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecTableCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_tablesec_content_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn local_compressed<'a>() -> (o: LocalCompressedCombinator)
-    ensures o@ == spec_local_compressed(),
+pub fn tablesec_content<'a>() -> (o: TablesecContentCombinator)
+    ensures o@ == spec_tablesec_content(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = LocalCompressedCombinator(
+    let combinator = TablesecContentCombinator(
     Mapped {
-        inner: LocalCompressedCombinator1((UnsignedLEB128, valtype())),
-        mapper: LocalCompressedMapper,
-    });
-    assert({
-        &&& combinator@ == spec_local_compressed()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, TablesecContentCont0),
+        mapper: TablesecContentMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_tablesec_content()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_local_compressed<'a>(input: &'a [u8]) -> (res: PResult<<LocalCompressedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_tablesec_content<'a>(input: &'a [u8]) -> (res: PResult<<TablesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_local_compressed().spec_parse(input@) == Some((n as int, v@)),
-        spec_local_compressed().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_tablesec_content().spec_parse(input@) == Some((n as int, v@)),
+        spec_tablesec_content().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_local_compressed().spec_parse(input@) is None,
-        spec_local_compressed().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_tablesec_content().spec_parse(input@) is None,
+        spec_tablesec_content().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = local_compressed();
+    let combinator = tablesec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_local_compressed<'a>(v: <LocalCompressedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_tablesec_content<'a>(v: <TablesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_local_compressed().wf(v@),
+        spec_tablesec_content().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_local_compressed().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_local_compressed().spec_serialize(v@))
+            &&& n == spec_tablesec_content().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_tablesec_content().spec_serialize(v@))
         },
 {
-    let combinator = local_compressed();
+    let combinator = tablesec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn local_compressed_len<'a>(v: <LocalCompressedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn tablesec_content_len<'a>(v: <TablesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_local_compressed().wf(v@),
-        spec_local_compressed().spec_serialize(v@).len() <= usize::MAX,
+        spec_tablesec_content().wf(v@),
+        spec_tablesec_content().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_local_compressed().spec_serialize(v@).len(),
+        serialize_len == spec_tablesec_content().spec_serialize(v@).len(),
 {
-    let combinator = local_compressed();
+    let combinator = tablesec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct TablesecContentCont0;
+type TablesecContentCont0Type<'a, 'b> = &'b u64;
+type TablesecContentCont0SType<'a, 'x> = &'x u64;
+type TablesecContentCont0Input<'a, 'b, 'x> = POrSType<TablesecContentCont0Type<'a, 'b>, TablesecContentCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TablesecContentCont0Input<'a, 'b, 'x>> for TablesecContentCont0 {
+    type Output = RepeatN<TableCombinator>;
+
+    open spec fn requires(&self, deps: TablesecContentCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: TablesecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_tablesec_content_cont0(deps@)
+    }
+
+    fn apply(&self, deps: TablesecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(table(), (usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(table(), (usize::ex_from(l)) as usize)
+            }
+        }
+    }
+}
                 
 
-pub struct SpecLocals {
-    pub l: u64,
-    pub v: Seq<SpecLocalCompressed>,
+pub struct SpecTablesec {
+    pub size: u64,
+    pub cont: SpecTablesecContent,
 }
 
-pub type SpecLocalsInner = (u64, Seq<SpecLocalCompressed>);
+pub type SpecTablesecInner = (u64, SpecTablesecContent);
 
 
-impl SpecFrom<SpecLocals> for SpecLocalsInner {
-    open spec fn spec_from(m: SpecLocals) -> SpecLocalsInner {
-        (m.l, m.v)
+impl SpecFrom<SpecTablesec> for SpecTablesecInner {
+    open spec fn spec_from(m: SpecTablesec) -> SpecTablesecInner {
+        (m.size, m.cont)
     }
 }
 
-impl SpecFrom<SpecLocalsInner> for SpecLocals {
-    open spec fn spec_from(m: SpecLocalsInner) -> SpecLocals {
-        let (l, v) = m;
-        SpecLocals { l, v }
+impl SpecFrom<SpecTablesecInner> for SpecTablesec {
+    open spec fn spec_from(m: SpecTablesecInner) -> SpecTablesec {
+        let (size, cont) = m;
+        SpecTablesec { size, cont }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Locals {
-    pub l: u64,
-    pub v: RepeatResult<LocalCompressed>,
+pub struct Tablesec {
+    pub size: u64,
+    pub cont: TablesecContent,
 }
 
-impl View for Locals {
-    type V = SpecLocals;
+impl View for Tablesec {
+    type V = SpecTablesec;
 
     open spec fn view(&self) -> Self::V {
-        SpecLocals {
-            l: self.l@,
-            v: self.v@,
+        SpecTablesec {
+            size: self.size@,
+            cont: self.cont@,
         }
     }
 }
-pub type LocalsInner = (u64, RepeatResult<LocalCompressed>);
+pub type TablesecInner = (u64, TablesecContent);
 
-pub type LocalsInnerRef<'a> = (&'a u64, &'a RepeatResult<LocalCompressed>);
-impl<'a> From<&'a Locals> for LocalsInnerRef<'a> {
-    fn ex_from(m: &'a Locals) -> LocalsInnerRef<'a> {
-        (&m.l, &m.v)
+pub type TablesecInnerRef<'a> = (&'a u64, &'a TablesecContent);
+impl<'a> From<&'a Tablesec> for TablesecInnerRef<'a> {
+    fn ex_from(m: &'a Tablesec) -> TablesecInnerRef<'a> {
+        (&m.size, &m.cont)
     }
 }
 
-impl From<LocalsInner> for Locals {
-    fn ex_from(m: LocalsInner) -> Locals {
-        let (l, v) = m;
-        Locals { l, v }
+impl From<TablesecInner> for Tablesec {
+    fn ex_from(m: TablesecInner) -> Tablesec {
+        let (size, cont) = m;
+        Tablesec { size, cont }
     }
 }
 
-pub struct LocalsMapper;
-impl View for LocalsMapper {
+pub struct TablesecMapper;
+impl View for TablesecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for LocalsMapper {
-    type Src = SpecLocalsInner;
-    type Dst = SpecLocals;
+impl SpecIso for TablesecMapper {
+    type Src = SpecTablesecInner;
+    type Dst = SpecTablesec;
 }
-impl SpecIsoProof for LocalsMapper {
+impl SpecIsoProof for TablesecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -17632,241 +17607,245 @@ impl SpecIsoProof for LocalsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for LocalsMapper {
-    type Src = LocalsInner;
-    type Dst = Locals;
-    type RefSrc = LocalsInnerRef<'a>;
+impl<'a> Iso<'a> for TablesecMapper {
+    type Src = TablesecInner;
+    type Dst = Tablesec;
+    type RefSrc = TablesecInnerRef<'a>;
 }
 
-pub struct SpecLocalsCombinator(pub SpecLocalsCombinatorAlias);
+pub struct SpecTablesecCombinator(pub SpecTablesecCombinatorAlias);
 
-impl SpecCombinator for SpecLocalsCombinator {
-    type Type = SpecLocals;
+impl SpecCombinator for SpecTablesecCombinator {
+    type Type = SpecTablesec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecLocalsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecLocalsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecTablesecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecTablesecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecLocalsCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecLocalCompressedCombinator>>, LocalsMapper>;
+pub type SpecTablesecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecTablesecContentCombinator>>, TablesecMapper>;
 
-pub struct LocalsCombinator(pub LocalsCombinatorAlias);
+pub struct TablesecCombinator(pub TablesecCombinatorAlias);
 
-impl View for LocalsCombinator {
-    type V = SpecLocalsCombinator;
-    open spec fn view(&self) -> Self::V { SpecLocalsCombinator(self.0@) }
+impl View for TablesecCombinator {
+    type V = SpecTablesecCombinator;
+    open spec fn view(&self) -> Self::V { SpecTablesecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LocalsCombinator {
-    type Type = Locals;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TablesecCombinator {
+    type Type = Tablesec;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type LocalsCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<LocalCompressedCombinator>, LocalsCont0>, LocalsMapper>;
+}
+pub type TablesecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, TablesecContentCombinator>, TablesecCont0>, TablesecMapper>;
 
 
-pub open spec fn spec_locals() -> SpecLocalsCombinator {
-    SpecLocalsCombinator(
+pub open spec fn spec_tablesec() -> SpecTablesecCombinator {
+    SpecTablesecCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_locals_cont0(deps)),
-        mapper: LocalsMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_tablesec_cont0(deps)),
+        mapper: TablesecMapper,
     })
 }
 
-pub open spec fn spec_locals_cont0(deps: u64) -> RepeatN<SpecLocalCompressedCombinator> {
-    let l = deps;
-    RepeatN(spec_local_compressed(), l.spec_into())
+pub open spec fn spec_tablesec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecTablesecContentCombinator> {
+    let size = deps;
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_tablesec_content())
 }
 
-impl View for LocalsCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecLocalCompressedCombinator>;
+impl View for TablesecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecTablesecContentCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_locals_cont0(deps)
+            spec_tablesec_cont0(deps)
         }
     }
 }
 
                 
-pub fn locals<'a>() -> (o: LocalsCombinator)
-    ensures o@ == spec_locals(),
+pub fn tablesec<'a>() -> (o: TablesecCombinator)
+    ensures o@ == spec_tablesec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = LocalsCombinator(
+    let combinator = TablesecCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, LocalsCont0),
-        mapper: LocalsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_locals()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, TablesecCont0),
+        mapper: TablesecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_tablesec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_locals<'a>(input: &'a [u8]) -> (res: PResult<<LocalsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_tablesec<'a>(input: &'a [u8]) -> (res: PResult<<TablesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_locals().spec_parse(input@) == Some((n as int, v@)),
-        spec_locals().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_tablesec().spec_parse(input@) == Some((n as int, v@)),
+        spec_tablesec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_locals().spec_parse(input@) is None,
-        spec_locals().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_tablesec().spec_parse(input@) is None,
+        spec_tablesec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = locals();
+    let combinator = tablesec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_locals<'a>(v: <LocalsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_tablesec<'a>(v: <TablesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_locals().wf(v@),
+        spec_tablesec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_locals().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_locals().spec_serialize(v@))
+            &&& n == spec_tablesec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_tablesec().spec_serialize(v@))
         },
 {
-    let combinator = locals();
+    let combinator = tablesec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn locals_len<'a>(v: <LocalsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn tablesec_len<'a>(v: <TablesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_locals().wf(v@),
-        spec_locals().spec_serialize(v@).len() <= usize::MAX,
+        spec_tablesec().wf(v@),
+        spec_tablesec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_locals().spec_serialize(v@).len(),
+        serialize_len == spec_tablesec().spec_serialize(v@).len(),
 {
-    let combinator = locals();
+    let combinator = tablesec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct LocalsCont0;
-type LocalsCont0Type<'a, 'b> = &'b u64;
-type LocalsCont0SType<'a, 'x> = &'x u64;
-type LocalsCont0Input<'a, 'b, 'x> = POrSType<LocalsCont0Type<'a, 'b>, LocalsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<LocalsCont0Input<'a, 'b, 'x>> for LocalsCont0 {
-    type Output = RepeatN<LocalCompressedCombinator>;
+pub struct TablesecCont0;
+type TablesecCont0Type<'a, 'b> = &'b u64;
+type TablesecCont0SType<'a, 'x> = &'x u64;
+type TablesecCont0Input<'a, 'b, 'x> = POrSType<TablesecCont0Type<'a, 'b>, TablesecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<TablesecCont0Input<'a, 'b, 'x>> for TablesecCont0 {
+    type Output = AndThen<bytes::Variable, TablesecContentCombinator>;
 
-    open spec fn requires(&self, deps: LocalsCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: TablesecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: LocalsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_locals_cont0(deps@)
+    open spec fn ensures(&self, deps: TablesecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_tablesec_cont0(deps@)
     }
 
-    fn apply(&self, deps: LocalsCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: TablesecCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(local_compressed(), l.ex_into())
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), tablesec_content())
             }
             POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(local_compressed(), l.ex_into())
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), tablesec_content())
             }
         }
     }
 }
                 
 
-pub struct SpecFunc {
-    pub locals: SpecLocals,
-    pub body: SpecExpr,
+pub struct SpecGlobal {
+    pub gt: SpecGlobaltype,
+    pub init: SpecExpr,
 }
 
-pub type SpecFuncInner = (SpecLocals, SpecExpr);
+pub type SpecGlobalInner = (SpecGlobaltype, SpecExpr);
 
 
-impl SpecFrom<SpecFunc> for SpecFuncInner {
-    open spec fn spec_from(m: SpecFunc) -> SpecFuncInner {
-        (m.locals, m.body)
+impl SpecFrom<SpecGlobal> for SpecGlobalInner {
+    open spec fn spec_from(m: SpecGlobal) -> SpecGlobalInner {
+        (m.gt, m.init)
     }
 }
 
-impl SpecFrom<SpecFuncInner> for SpecFunc {
-    open spec fn spec_from(m: SpecFuncInner) -> SpecFunc {
-        let (locals, body) = m;
-        SpecFunc { locals, body }
+impl SpecFrom<SpecGlobalInner> for SpecGlobal {
+    open spec fn spec_from(m: SpecGlobalInner) -> SpecGlobal {
+        let (gt, init) = m;
+        SpecGlobal { gt, init }
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct Func<'a> {
-    pub locals: Locals,
-    pub body: Expr<'a>,
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Global<'a> {
+    pub gt: Globaltype,
+    pub init: Expr<'a>,
 }
 
-impl View for Func<'_> {
-    type V = SpecFunc;
+impl View for Global<'_> {
+    type V = SpecGlobal;
 
     open spec fn view(&self) -> Self::V {
-        SpecFunc {
-            locals: self.locals@,
-            body: self.body@,
+        SpecGlobal {
+            gt: self.gt@,
+            init: self.init@,
         }
     }
 }
-pub type FuncInner<'a> = (Locals, Expr<'a>);
+pub type GlobalInner<'a> = (Globaltype, Expr<'a>);
 
-pub type FuncInnerRef<'a> = (&'a Locals, &'a Expr<'a>);
-impl<'a> From<&'a Func<'a>> for FuncInnerRef<'a> {
-    fn ex_from(m: &'a Func) -> FuncInnerRef<'a> {
-        (&m.locals, &m.body)
+pub type GlobalInnerRef<'a> = (&'a Globaltype, &'a Expr<'a>);
+impl<'a> From<&'a Global<'a>> for GlobalInnerRef<'a> {
+    fn ex_from(m: &'a Global) -> GlobalInnerRef<'a> {
+        (&m.gt, &m.init)
     }
 }
 
-impl<'a> From<FuncInner<'a>> for Func<'a> {
-    fn ex_from(m: FuncInner) -> Func {
-        let (locals, body) = m;
-        Func { locals, body }
+impl<'a> From<GlobalInner<'a>> for Global<'a> {
+    fn ex_from(m: GlobalInner) -> Global {
+        let (gt, init) = m;
+        Global { gt, init }
     }
 }
 
-pub struct FuncMapper;
-impl View for FuncMapper {
+pub struct GlobalMapper;
+impl View for GlobalMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for FuncMapper {
-    type Src = SpecFuncInner;
-    type Dst = SpecFunc;
+impl SpecIso for GlobalMapper {
+    type Src = SpecGlobalInner;
+    type Dst = SpecGlobal;
 }
-impl SpecIsoProof for FuncMapper {
+impl SpecIsoProof for GlobalMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -17874,206 +17853,206 @@ impl SpecIsoProof for FuncMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for FuncMapper {
-    type Src = FuncInner<'a>;
-    type Dst = Func<'a>;
-    type RefSrc = FuncInnerRef<'a>;
+impl<'a> Iso<'a> for GlobalMapper {
+    type Src = GlobalInner<'a>;
+    type Dst = Global<'a>;
+    type RefSrc = GlobalInnerRef<'a>;
 }
-type SpecFuncCombinatorAlias1 = (SpecLocalsCombinator, SpecExprCombinator);
-pub struct SpecFuncCombinator(pub SpecFuncCombinatorAlias);
+type SpecGlobalCombinatorAlias1 = (SpecGlobaltypeCombinator, SpecExprCombinator);
+pub struct SpecGlobalCombinator(pub SpecGlobalCombinatorAlias);
 
-impl SpecCombinator for SpecFuncCombinator {
-    type Type = SpecFunc;
+impl SpecCombinator for SpecGlobalCombinator {
+    type Type = SpecGlobal;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecFuncCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecFuncCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecGlobalCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecGlobalCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecFuncCombinatorAlias = Mapped<SpecFuncCombinatorAlias1, FuncMapper>;
-type FuncCombinatorAlias1 = (LocalsCombinator, ExprCombinator);
-pub struct FuncCombinator1(pub FuncCombinatorAlias1);
-impl View for FuncCombinator1 {
-    type V = SpecFuncCombinatorAlias1;
+pub type SpecGlobalCombinatorAlias = Mapped<SpecGlobalCombinatorAlias1, GlobalMapper>;
+type GlobalCombinatorAlias1 = (GlobaltypeCombinator, ExprCombinator);
+pub struct GlobalCombinator1(pub GlobalCombinatorAlias1);
+impl View for GlobalCombinator1 {
+    type V = SpecGlobalCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(FuncCombinator1, FuncCombinatorAlias1);
+impl_wrapper_combinator!(GlobalCombinator1, GlobalCombinatorAlias1);
 
-pub struct FuncCombinator(pub FuncCombinatorAlias);
+pub struct GlobalCombinator(pub GlobalCombinatorAlias);
 
-impl View for FuncCombinator {
-    type V = SpecFuncCombinator;
-    open spec fn view(&self) -> Self::V { SpecFuncCombinator(self.0@) }
+impl View for GlobalCombinator {
+    type V = SpecGlobalCombinator;
+    open spec fn view(&self) -> Self::V { SpecGlobalCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FuncCombinator {
-    type Type = Func<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GlobalCombinator {
+    type Type = Global<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type FuncCombinatorAlias = Mapped<FuncCombinator1, FuncMapper>;
+}
+pub type GlobalCombinatorAlias = Mapped<GlobalCombinator1, GlobalMapper>;
 
 
-pub open spec fn spec_func() -> SpecFuncCombinator {
-    SpecFuncCombinator(
+pub open spec fn spec_global() -> SpecGlobalCombinator {
+    SpecGlobalCombinator(
     Mapped {
-        inner: (spec_locals(), spec_expr()),
-        mapper: FuncMapper,
+        inner: (spec_globaltype(), spec_expr()),
+        mapper: GlobalMapper,
     })
 }
 
                 
-pub fn func<'a>() -> (o: FuncCombinator)
-    ensures o@ == spec_func(),
+pub fn global<'a>() -> (o: GlobalCombinator)
+    ensures o@ == spec_global(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = FuncCombinator(
+    let combinator = GlobalCombinator(
     Mapped {
-        inner: FuncCombinator1((locals(), expr())),
-        mapper: FuncMapper,
-    });
-    assert({
-        &&& combinator@ == spec_func()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: GlobalCombinator1((globaltype(), expr())),
+        mapper: GlobalMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_global()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_func<'a>(input: &'a [u8]) -> (res: PResult<<FuncCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_global<'a>(input: &'a [u8]) -> (res: PResult<<GlobalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_func().spec_parse(input@) == Some((n as int, v@)),
-        spec_func().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_global().spec_parse(input@) == Some((n as int, v@)),
+        spec_global().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_func().spec_parse(input@) is None,
-        spec_func().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_global().spec_parse(input@) is None,
+        spec_global().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = func();
+    let combinator = global();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_func<'a>(v: <FuncCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_global<'a>(v: <GlobalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_func().wf(v@),
+        spec_global().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_func().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_func().spec_serialize(v@))
+            &&& n == spec_global().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_global().spec_serialize(v@))
         },
 {
-    let combinator = func();
+    let combinator = global();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn func_len<'a>(v: <FuncCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn global_len<'a>(v: <GlobalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_func().wf(v@),
-        spec_func().spec_serialize(v@).len() <= usize::MAX,
+        spec_global().wf(v@),
+        spec_global().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_func().spec_serialize(v@).len(),
+        serialize_len == spec_global().spec_serialize(v@).len(),
 {
-    let combinator = func();
+    let combinator = global();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecFuncsecContent {
+pub struct SpecGlobalsecContent {
     pub l: u64,
-    pub v: Seq<SpecTypeidx>,
+    pub v: Seq<SpecGlobal>,
 }
 
-pub type SpecFuncsecContentInner = (u64, Seq<SpecTypeidx>);
+pub type SpecGlobalsecContentInner = (u64, Seq<SpecGlobal>);
 
 
-impl SpecFrom<SpecFuncsecContent> for SpecFuncsecContentInner {
-    open spec fn spec_from(m: SpecFuncsecContent) -> SpecFuncsecContentInner {
+impl SpecFrom<SpecGlobalsecContent> for SpecGlobalsecContentInner {
+    open spec fn spec_from(m: SpecGlobalsecContent) -> SpecGlobalsecContentInner {
         (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecFuncsecContentInner> for SpecFuncsecContent {
-    open spec fn spec_from(m: SpecFuncsecContentInner) -> SpecFuncsecContent {
+impl SpecFrom<SpecGlobalsecContentInner> for SpecGlobalsecContent {
+    open spec fn spec_from(m: SpecGlobalsecContentInner) -> SpecGlobalsecContent {
         let (l, v) = m;
-        SpecFuncsecContent { l, v }
+        SpecGlobalsecContent { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct FuncsecContent {
+pub struct GlobalsecContent<'a> {
     pub l: u64,
-    pub v: RepeatResult<Typeidx>,
+    pub v: RepeatResult<Global<'a>>,
 }
 
-impl View for FuncsecContent {
-    type V = SpecFuncsecContent;
+impl View for GlobalsecContent<'_> {
+    type V = SpecGlobalsecContent;
 
     open spec fn view(&self) -> Self::V {
-        SpecFuncsecContent {
+        SpecGlobalsecContent {
             l: self.l@,
             v: self.v@,
         }
     }
 }
-pub type FuncsecContentInner = (u64, RepeatResult<Typeidx>);
+pub type GlobalsecContentInner<'a> = (u64, RepeatResult<Global<'a>>);
 
-pub type FuncsecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Typeidx>);
-impl<'a> From<&'a FuncsecContent> for FuncsecContentInnerRef<'a> {
-    fn ex_from(m: &'a FuncsecContent) -> FuncsecContentInnerRef<'a> {
+pub type GlobalsecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Global<'a>>);
+impl<'a> From<&'a GlobalsecContent<'a>> for GlobalsecContentInnerRef<'a> {
+    fn ex_from(m: &'a GlobalsecContent) -> GlobalsecContentInnerRef<'a> {
         (&m.l, &m.v)
     }
 }
 
-impl From<FuncsecContentInner> for FuncsecContent {
-    fn ex_from(m: FuncsecContentInner) -> FuncsecContent {
+impl<'a> From<GlobalsecContentInner<'a>> for GlobalsecContent<'a> {
+    fn ex_from(m: GlobalsecContentInner) -> GlobalsecContent {
         let (l, v) = m;
-        FuncsecContent { l, v }
+        GlobalsecContent { l, v }
     }
 }
 
-pub struct FuncsecContentMapper;
-impl View for FuncsecContentMapper {
+pub struct GlobalsecContentMapper;
+impl View for GlobalsecContentMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for FuncsecContentMapper {
-    type Src = SpecFuncsecContentInner;
-    type Dst = SpecFuncsecContent;
+impl SpecIso for GlobalsecContentMapper {
+    type Src = SpecGlobalsecContentInner;
+    type Dst = SpecGlobalsecContent;
 }
-impl SpecIsoProof for FuncsecContentMapper {
+impl SpecIsoProof for GlobalsecContentMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -18081,241 +18060,245 @@ impl SpecIsoProof for FuncsecContentMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for FuncsecContentMapper {
-    type Src = FuncsecContentInner;
-    type Dst = FuncsecContent;
-    type RefSrc = FuncsecContentInnerRef<'a>;
+impl<'a> Iso<'a> for GlobalsecContentMapper {
+    type Src = GlobalsecContentInner<'a>;
+    type Dst = GlobalsecContent<'a>;
+    type RefSrc = GlobalsecContentInnerRef<'a>;
 }
 
-pub struct SpecFuncsecContentCombinator(pub SpecFuncsecContentCombinatorAlias);
+pub struct SpecGlobalsecContentCombinator(pub SpecGlobalsecContentCombinatorAlias);
 
-impl SpecCombinator for SpecFuncsecContentCombinator {
-    type Type = SpecFuncsecContent;
+impl SpecCombinator for SpecGlobalsecContentCombinator {
+    type Type = SpecGlobalsecContent;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecFuncsecContentCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecFuncsecContentCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecGlobalsecContentCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecGlobalsecContentCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecFuncsecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecTypeidxCombinator>>, FuncsecContentMapper>;
+pub type SpecGlobalsecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecGlobalCombinator>>, GlobalsecContentMapper>;
 
-pub struct FuncsecContentCombinator(pub FuncsecContentCombinatorAlias);
+pub struct GlobalsecContentCombinator(pub GlobalsecContentCombinatorAlias);
 
-impl View for FuncsecContentCombinator {
-    type V = SpecFuncsecContentCombinator;
-    open spec fn view(&self) -> Self::V { SpecFuncsecContentCombinator(self.0@) }
+impl View for GlobalsecContentCombinator {
+    type V = SpecGlobalsecContentCombinator;
+    open spec fn view(&self) -> Self::V { SpecGlobalsecContentCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FuncsecContentCombinator {
-    type Type = FuncsecContent;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GlobalsecContentCombinator {
+    type Type = GlobalsecContent<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type FuncsecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<TypeidxCombinator>, FuncsecContentCont0>, FuncsecContentMapper>;
+}
+pub type GlobalsecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<GlobalCombinator>, GlobalsecContentCont0>, GlobalsecContentMapper>;
 
 
-pub open spec fn spec_funcsec_content() -> SpecFuncsecContentCombinator {
-    SpecFuncsecContentCombinator(
+pub open spec fn spec_globalsec_content() -> SpecGlobalsecContentCombinator {
+    SpecGlobalsecContentCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_funcsec_content_cont0(deps)),
-        mapper: FuncsecContentMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_globalsec_content_cont0(deps)),
+        mapper: GlobalsecContentMapper,
     })
 }
 
-pub open spec fn spec_funcsec_content_cont0(deps: u64) -> RepeatN<SpecTypeidxCombinator> {
+pub open spec fn spec_globalsec_content_cont0(deps: u64) -> RepeatN<SpecGlobalCombinator> {
     let l = deps;
-    RepeatN(spec_typeidx(), l.spec_into())
+    RepeatN(spec_global(), (usize::spec_from(l)) as usize)
 }
 
-impl View for FuncsecContentCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecTypeidxCombinator>;
+impl View for GlobalsecContentCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecGlobalCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_funcsec_content_cont0(deps)
+            spec_globalsec_content_cont0(deps)
         }
     }
 }
 
                 
-pub fn funcsec_content<'a>() -> (o: FuncsecContentCombinator)
-    ensures o@ == spec_funcsec_content(),
+pub fn globalsec_content<'a>() -> (o: GlobalsecContentCombinator)
+    ensures o@ == spec_globalsec_content(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = FuncsecContentCombinator(
-    Mapped {
-        inner: Pair::new(UnsignedLEB128, FuncsecContentCont0),
-        mapper: FuncsecContentMapper,
-    });
-    assert({
-        &&& combinator@ == spec_funcsec_content()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = GlobalsecContentCombinator(
+    Mapped {
+        inner: Pair::new(UnsignedLEB128, GlobalsecContentCont0),
+        mapper: GlobalsecContentMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_globalsec_content()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_funcsec_content<'a>(input: &'a [u8]) -> (res: PResult<<FuncsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_globalsec_content<'a>(input: &'a [u8]) -> (res: PResult<<GlobalsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_funcsec_content().spec_parse(input@) == Some((n as int, v@)),
-        spec_funcsec_content().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_globalsec_content().spec_parse(input@) == Some((n as int, v@)),
+        spec_globalsec_content().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_funcsec_content().spec_parse(input@) is None,
-        spec_funcsec_content().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_globalsec_content().spec_parse(input@) is None,
+        spec_globalsec_content().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = funcsec_content();
+    let combinator = globalsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_funcsec_content<'a>(v: <FuncsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_globalsec_content<'a>(v: <GlobalsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_funcsec_content().wf(v@),
+        spec_globalsec_content().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_funcsec_content().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_funcsec_content().spec_serialize(v@))
+            &&& n == spec_globalsec_content().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_globalsec_content().spec_serialize(v@))
         },
 {
-    let combinator = funcsec_content();
+    let combinator = globalsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn funcsec_content_len<'a>(v: <FuncsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn globalsec_content_len<'a>(v: <GlobalsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_funcsec_content().wf(v@),
-        spec_funcsec_content().spec_serialize(v@).len() <= usize::MAX,
+        spec_globalsec_content().wf(v@),
+        spec_globalsec_content().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_funcsec_content().spec_serialize(v@).len(),
+        serialize_len == spec_globalsec_content().spec_serialize(v@).len(),
 {
-    let combinator = funcsec_content();
+    let combinator = globalsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct FuncsecContentCont0;
-type FuncsecContentCont0Type<'a, 'b> = &'b u64;
-type FuncsecContentCont0SType<'a, 'x> = &'x u64;
-type FuncsecContentCont0Input<'a, 'b, 'x> = POrSType<FuncsecContentCont0Type<'a, 'b>, FuncsecContentCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<FuncsecContentCont0Input<'a, 'b, 'x>> for FuncsecContentCont0 {
-    type Output = RepeatN<TypeidxCombinator>;
+pub struct GlobalsecContentCont0;
+type GlobalsecContentCont0Type<'a, 'b> = &'b u64;
+type GlobalsecContentCont0SType<'a, 'x> = &'x u64;
+type GlobalsecContentCont0Input<'a, 'b, 'x> = POrSType<GlobalsecContentCont0Type<'a, 'b>, GlobalsecContentCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<GlobalsecContentCont0Input<'a, 'b, 'x>> for GlobalsecContentCont0 {
+    type Output = RepeatN<GlobalCombinator>;
 
-    open spec fn requires(&self, deps: FuncsecContentCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: GlobalsecContentCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: FuncsecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_funcsec_content_cont0(deps@)
+    open spec fn ensures(&self, deps: GlobalsecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_globalsec_content_cont0(deps@)
     }
 
-    fn apply(&self, deps: FuncsecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: GlobalsecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(typeidx(), l.ex_into())
+                let l = deps;
+                let l = *l;
+                RepeatN(global(), (usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                RepeatN(typeidx(), l.ex_into())
+                RepeatN(global(), (usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
 
-pub struct SpecFuncsec {
+pub struct SpecGlobalsec {
     pub size: u64,
-    pub cont: SpecFuncsecContent,
+    pub cont: SpecGlobalsecContent,
 }
 
-pub type SpecFuncsecInner = (u64, SpecFuncsecContent);
+pub type SpecGlobalsecInner = (u64, SpecGlobalsecContent);
 
 
-impl SpecFrom<SpecFuncsec> for SpecFuncsecInner {
-    open spec fn spec_from(m: SpecFuncsec) -> SpecFuncsecInner {
+impl SpecFrom<SpecGlobalsec> for SpecGlobalsecInner {
+    open spec fn spec_from(m: SpecGlobalsec) -> SpecGlobalsecInner {
         (m.size, m.cont)
     }
 }
 
-impl SpecFrom<SpecFuncsecInner> for SpecFuncsec {
-    open spec fn spec_from(m: SpecFuncsecInner) -> SpecFuncsec {
+impl SpecFrom<SpecGlobalsecInner> for SpecGlobalsec {
+    open spec fn spec_from(m: SpecGlobalsecInner) -> SpecGlobalsec {
         let (size, cont) = m;
-        SpecFuncsec { size, cont }
+        SpecGlobalsec { size, cont }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Funcsec {
+pub struct Globalsec<'a> {
     pub size: u64,
-    pub cont: FuncsecContent,
+    pub cont: GlobalsecContent<'a>,
 }
 
-impl View for Funcsec {
-    type V = SpecFuncsec;
+impl View for Globalsec<'_> {
+    type V = SpecGlobalsec;
 
     open spec fn view(&self) -> Self::V {
-        SpecFuncsec {
+        SpecGlobalsec {
             size: self.size@,
             cont: self.cont@,
         }
     }
 }
-pub type FuncsecInner = (u64, FuncsecContent);
+pub type GlobalsecInner<'a> = (u64, GlobalsecContent<'a>);
 
-pub type FuncsecInnerRef<'a> = (&'a u64, &'a FuncsecContent);
-impl<'a> From<&'a Funcsec> for FuncsecInnerRef<'a> {
-    fn ex_from(m: &'a Funcsec) -> FuncsecInnerRef<'a> {
+pub type GlobalsecInnerRef<'a> = (&'a u64, &'a GlobalsecContent<'a>);
+impl<'a> From<&'a Globalsec<'a>> for GlobalsecInnerRef<'a> {
+    fn ex_from(m: &'a Globalsec) -> GlobalsecInnerRef<'a> {
         (&m.size, &m.cont)
     }
 }
 
-impl From<FuncsecInner> for Funcsec {
-    fn ex_from(m: FuncsecInner) -> Funcsec {
+impl<'a> From<GlobalsecInner<'a>> for Globalsec<'a> {
+    fn ex_from(m: GlobalsecInner) -> Globalsec {
         let (size, cont) = m;
-        Funcsec { size, cont }
+        Globalsec { size, cont }
     }
 }
 
-pub struct FuncsecMapper;
-impl View for FuncsecMapper {
+pub struct GlobalsecMapper;
+impl View for GlobalsecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for FuncsecMapper {
-    type Src = SpecFuncsecInner;
-    type Dst = SpecFuncsec;
+impl SpecIso for GlobalsecMapper {
+    type Src = SpecGlobalsecInner;
+    type Dst = SpecGlobalsec;
 }
-impl SpecIsoProof for FuncsecMapper {
+impl SpecIsoProof for GlobalsecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -18323,241 +18306,245 @@ impl SpecIsoProof for FuncsecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for FuncsecMapper {
-    type Src = FuncsecInner;
-    type Dst = Funcsec;
-    type RefSrc = FuncsecInnerRef<'a>;
+impl<'a> Iso<'a> for GlobalsecMapper {
+    type Src = GlobalsecInner<'a>;
+    type Dst = Globalsec<'a>;
+    type RefSrc = GlobalsecInnerRef<'a>;
 }
 
-pub struct SpecFuncsecCombinator(pub SpecFuncsecCombinatorAlias);
+pub struct SpecGlobalsecCombinator(pub SpecGlobalsecCombinatorAlias);
 
-impl SpecCombinator for SpecFuncsecCombinator {
-    type Type = SpecFuncsec;
+impl SpecCombinator for SpecGlobalsecCombinator {
+    type Type = SpecGlobalsec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecFuncsecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecFuncsecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecGlobalsecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecGlobalsecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecFuncsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecFuncsecContentCombinator>>, FuncsecMapper>;
+pub type SpecGlobalsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecGlobalsecContentCombinator>>, GlobalsecMapper>;
 
-pub struct FuncsecCombinator(pub FuncsecCombinatorAlias);
+pub struct GlobalsecCombinator(pub GlobalsecCombinatorAlias);
 
-impl View for FuncsecCombinator {
-    type V = SpecFuncsecCombinator;
-    open spec fn view(&self) -> Self::V { SpecFuncsecCombinator(self.0@) }
+impl View for GlobalsecCombinator {
+    type V = SpecGlobalsecCombinator;
+    open spec fn view(&self) -> Self::V { SpecGlobalsecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FuncsecCombinator {
-    type Type = Funcsec;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GlobalsecCombinator {
+    type Type = Globalsec<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type FuncsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, FuncsecContentCombinator>, FuncsecCont0>, FuncsecMapper>;
+}
+pub type GlobalsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, GlobalsecContentCombinator>, GlobalsecCont0>, GlobalsecMapper>;
 
 
-pub open spec fn spec_funcsec() -> SpecFuncsecCombinator {
-    SpecFuncsecCombinator(
+pub open spec fn spec_globalsec() -> SpecGlobalsecCombinator {
+    SpecGlobalsecCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_funcsec_cont0(deps)),
-        mapper: FuncsecMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_globalsec_cont0(deps)),
+        mapper: GlobalsecMapper,
     })
 }
 
-pub open spec fn spec_funcsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecFuncsecContentCombinator> {
+pub open spec fn spec_globalsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecGlobalsecContentCombinator> {
     let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_funcsec_content())
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_globalsec_content())
 }
 
-impl View for FuncsecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecFuncsecContentCombinator>;
+impl View for GlobalsecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecGlobalsecContentCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_funcsec_cont0(deps)
+            spec_globalsec_cont0(deps)
         }
     }
 }
 
                 
-pub fn funcsec<'a>() -> (o: FuncsecCombinator)
-    ensures o@ == spec_funcsec(),
+pub fn globalsec<'a>() -> (o: GlobalsecCombinator)
+    ensures o@ == spec_globalsec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = FuncsecCombinator(
+    let combinator = GlobalsecCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, FuncsecCont0),
-        mapper: FuncsecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_funcsec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, GlobalsecCont0),
+        mapper: GlobalsecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_globalsec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_funcsec<'a>(input: &'a [u8]) -> (res: PResult<<FuncsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_globalsec<'a>(input: &'a [u8]) -> (res: PResult<<GlobalsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_funcsec().spec_parse(input@) == Some((n as int, v@)),
-        spec_funcsec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_globalsec().spec_parse(input@) == Some((n as int, v@)),
+        spec_globalsec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_funcsec().spec_parse(input@) is None,
-        spec_funcsec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_globalsec().spec_parse(input@) is None,
+        spec_globalsec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = funcsec();
+    let combinator = globalsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_funcsec<'a>(v: <FuncsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_globalsec<'a>(v: <GlobalsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_funcsec().wf(v@),
+        spec_globalsec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_funcsec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_funcsec().spec_serialize(v@))
+            &&& n == spec_globalsec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_globalsec().spec_serialize(v@))
         },
 {
-    let combinator = funcsec();
+    let combinator = globalsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn funcsec_len<'a>(v: <FuncsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn globalsec_len<'a>(v: <GlobalsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_funcsec().wf(v@),
-        spec_funcsec().spec_serialize(v@).len() <= usize::MAX,
+        spec_globalsec().wf(v@),
+        spec_globalsec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_funcsec().spec_serialize(v@).len(),
+        serialize_len == spec_globalsec().spec_serialize(v@).len(),
 {
-    let combinator = funcsec();
+    let combinator = globalsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct FuncsecCont0;
-type FuncsecCont0Type<'a, 'b> = &'b u64;
-type FuncsecCont0SType<'a, 'x> = &'x u64;
-type FuncsecCont0Input<'a, 'b, 'x> = POrSType<FuncsecCont0Type<'a, 'b>, FuncsecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<FuncsecCont0Input<'a, 'b, 'x>> for FuncsecCont0 {
-    type Output = AndThen<bytes::Variable, FuncsecContentCombinator>;
+pub struct GlobalsecCont0;
+type GlobalsecCont0Type<'a, 'b> = &'b u64;
+type GlobalsecCont0SType<'a, 'x> = &'x u64;
+type GlobalsecCont0Input<'a, 'b, 'x> = POrSType<GlobalsecCont0Type<'a, 'b>, GlobalsecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<GlobalsecCont0Input<'a, 'b, 'x>> for GlobalsecCont0 {
+    type Output = AndThen<bytes::Variable, GlobalsecContentCombinator>;
 
-    open spec fn requires(&self, deps: FuncsecCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: GlobalsecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: FuncsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_funcsec_cont0(deps@)
+    open spec fn ensures(&self, deps: GlobalsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_globalsec_cont0(deps@)
     }
 
-    fn apply(&self, deps: FuncsecCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: GlobalsecCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), funcsec_content())
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), globalsec_content())
             }
             POrSType::S(deps) => {
                 let size = deps;
                 let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), funcsec_content())
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), globalsec_content())
             }
         }
     }
 }
                 
 
-pub struct SpecDatasec {
-    pub size: u64,
-    pub cont: SpecDatasecContent,
+pub struct SpecExports {
+    pub l: u64,
+    pub v: Seq<SpecExport>,
 }
 
-pub type SpecDatasecInner = (u64, SpecDatasecContent);
+pub type SpecExportsInner = (u64, Seq<SpecExport>);
 
 
-impl SpecFrom<SpecDatasec> for SpecDatasecInner {
-    open spec fn spec_from(m: SpecDatasec) -> SpecDatasecInner {
-        (m.size, m.cont)
+impl SpecFrom<SpecExports> for SpecExportsInner {
+    open spec fn spec_from(m: SpecExports) -> SpecExportsInner {
+        (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecDatasecInner> for SpecDatasec {
-    open spec fn spec_from(m: SpecDatasecInner) -> SpecDatasec {
-        let (size, cont) = m;
-        SpecDatasec { size, cont }
+impl SpecFrom<SpecExportsInner> for SpecExports {
+    open spec fn spec_from(m: SpecExportsInner) -> SpecExports {
+        let (l, v) = m;
+        SpecExports { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Datasec<'a> {
-    pub size: u64,
-    pub cont: DatasecContent<'a>,
+pub struct Exports {
+    pub l: u64,
+    pub v: RepeatResult<Export>,
 }
 
-impl View for Datasec<'_> {
-    type V = SpecDatasec;
-
-    open spec fn view(&self) -> Self::V {
-        SpecDatasec {
-            size: self.size@,
-            cont: self.cont@,
+impl View for Exports {
+    type V = SpecExports;
+
+    open spec fn view(&self) -> Self::V {
+        SpecExports {
+            l: self.l@,
+            v: self.v@,
         }
     }
 }
-pub type DatasecInner<'a> = (u64, DatasecContent<'a>);
+pub type ExportsInner = (u64, RepeatResult<Export>);
 
-pub type DatasecInnerRef<'a> = (&'a u64, &'a DatasecContent<'a>);
-impl<'a> From<&'a Datasec<'a>> for DatasecInnerRef<'a> {
-    fn ex_from(m: &'a Datasec) -> DatasecInnerRef<'a> {
-        (&m.size, &m.cont)
+pub type ExportsInnerRef<'a> = (&'a u64, &'a RepeatResult<Export>);
+impl<'a> From<&'a Exports> for ExportsInnerRef<'a> {
+    fn ex_from(m: &'a Exports) -> ExportsInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-impl<'a> From<DatasecInner<'a>> for Datasec<'a> {
-    fn ex_from(m: DatasecInner) -> Datasec {
-        let (size, cont) = m;
-        Datasec { size, cont }
+impl From<ExportsInner> for Exports {
+    fn ex_from(m: ExportsInner) -> Exports {
+        let (l, v) = m;
+        Exports { l, v }
     }
 }
 
-pub struct DatasecMapper;
-impl View for DatasecMapper {
+pub struct ExportsMapper;
+impl View for ExportsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for DatasecMapper {
-    type Src = SpecDatasecInner;
-    type Dst = SpecDatasec;
+impl SpecIso for ExportsMapper {
+    type Src = SpecExportsInner;
+    type Dst = SpecExports;
 }
-impl SpecIsoProof for DatasecMapper {
+impl SpecIsoProof for ExportsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -18565,241 +18552,245 @@ impl SpecIsoProof for DatasecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for DatasecMapper {
-    type Src = DatasecInner<'a>;
-    type Dst = Datasec<'a>;
-    type RefSrc = DatasecInnerRef<'a>;
+impl<'a> Iso<'a> for ExportsMapper {
+    type Src = ExportsInner;
+    type Dst = Exports;
+    type RefSrc = ExportsInnerRef<'a>;
 }
 
-pub struct SpecDatasecCombinator(pub SpecDatasecCombinatorAlias);
+pub struct SpecExportsCombinator(pub SpecExportsCombinatorAlias);
 
-impl SpecCombinator for SpecDatasecCombinator {
-    type Type = SpecDatasec;
+impl SpecCombinator for SpecExportsCombinator {
+    type Type = SpecExports;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecDatasecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecDatasecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecExportsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecExportsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecDatasecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecDatasecContentCombinator>>, DatasecMapper>;
+pub type SpecExportsCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecExportCombinator>>, ExportsMapper>;
 
-pub struct DatasecCombinator(pub DatasecCombinatorAlias);
+pub struct ExportsCombinator(pub ExportsCombinatorAlias);
 
-impl View for DatasecCombinator {
-    type V = SpecDatasecCombinator;
-    open spec fn view(&self) -> Self::V { SpecDatasecCombinator(self.0@) }
+impl View for ExportsCombinator {
+    type V = SpecExportsCombinator;
+    open spec fn view(&self) -> Self::V { SpecExportsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DatasecCombinator {
-    type Type = Datasec<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExportsCombinator {
+    type Type = Exports;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type DatasecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, DatasecContentCombinator>, DatasecCont0>, DatasecMapper>;
+}
+pub type ExportsCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ExportCombinator>, ExportsCont0>, ExportsMapper>;
 
 
-pub open spec fn spec_datasec() -> SpecDatasecCombinator {
-    SpecDatasecCombinator(
+pub open spec fn spec_exports() -> SpecExportsCombinator {
+    SpecExportsCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_datasec_cont0(deps)),
-        mapper: DatasecMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_exports_cont0(deps)),
+        mapper: ExportsMapper,
     })
 }
 
-pub open spec fn spec_datasec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecDatasecContentCombinator> {
-    let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_datasec_content())
+pub open spec fn spec_exports_cont0(deps: u64) -> RepeatN<SpecExportCombinator> {
+    let l = deps;
+    RepeatN(spec_export(), (usize::spec_from(l)) as usize)
 }
 
-impl View for DatasecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecDatasecContentCombinator>;
+impl View for ExportsCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecExportCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_datasec_cont0(deps)
+            spec_exports_cont0(deps)
         }
     }
 }
 
                 
-pub fn datasec<'a>() -> (o: DatasecCombinator)
-    ensures o@ == spec_datasec(),
+pub fn exports<'a>() -> (o: ExportsCombinator)
+    ensures o@ == spec_exports(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = DatasecCombinator(
+    let combinator = ExportsCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, DatasecCont0),
-        mapper: DatasecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_datasec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, ExportsCont0),
+        mapper: ExportsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_exports()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_datasec<'a>(input: &'a [u8]) -> (res: PResult<<DatasecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_exports<'a>(input: &'a [u8]) -> (res: PResult<<ExportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_datasec().spec_parse(input@) == Some((n as int, v@)),
-        spec_datasec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_exports().spec_parse(input@) == Some((n as int, v@)),
+        spec_exports().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_datasec().spec_parse(input@) is None,
-        spec_datasec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_exports().spec_parse(input@) is None,
+        spec_exports().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = datasec();
+    let combinator = exports();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_datasec<'a>(v: <DatasecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_exports<'a>(v: <ExportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_datasec().wf(v@),
+        spec_exports().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_datasec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_datasec().spec_serialize(v@))
+            &&& n == spec_exports().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_exports().spec_serialize(v@))
         },
 {
-    let combinator = datasec();
+    let combinator = exports();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn datasec_len<'a>(v: <DatasecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn exports_len<'a>(v: <ExportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_datasec().wf(v@),
-        spec_datasec().spec_serialize(v@).len() <= usize::MAX,
+        spec_exports().wf(v@),
+        spec_exports().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_datasec().spec_serialize(v@).len(),
+        serialize_len == spec_exports().spec_serialize(v@).len(),
 {
-    let combinator = datasec();
+    let combinator = exports();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct DatasecCont0;
-type DatasecCont0Type<'a, 'b> = &'b u64;
-type DatasecCont0SType<'a, 'x> = &'x u64;
-type DatasecCont0Input<'a, 'b, 'x> = POrSType<DatasecCont0Type<'a, 'b>, DatasecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<DatasecCont0Input<'a, 'b, 'x>> for DatasecCont0 {
-    type Output = AndThen<bytes::Variable, DatasecContentCombinator>;
+pub struct ExportsCont0;
+type ExportsCont0Type<'a, 'b> = &'b u64;
+type ExportsCont0SType<'a, 'x> = &'x u64;
+type ExportsCont0Input<'a, 'b, 'x> = POrSType<ExportsCont0Type<'a, 'b>, ExportsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ExportsCont0Input<'a, 'b, 'x>> for ExportsCont0 {
+    type Output = RepeatN<ExportCombinator>;
 
-    open spec fn requires(&self, deps: DatasecCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: ExportsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: DatasecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_datasec_cont0(deps@)
+    open spec fn ensures(&self, deps: ExportsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_exports_cont0(deps@)
     }
 
-    fn apply(&self, deps: DatasecCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: ExportsCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), datasec_content())
+                let l = deps;
+                let l = *l;
+                RepeatN(export(), (usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
-                let size = deps;
-                let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), datasec_content())
+                let l = deps;
+                let l = *l;
+                RepeatN(export(), (usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
 
-pub struct SpecLimitMinMax {
-    pub min: u64,
-    pub max: u64,
+pub struct SpecExportsec {
+    pub size: u64,
+    pub cont: SpecExports,
 }
 
-pub type SpecLimitMinMaxInner = (u64, u64);
+pub type SpecExportsecInner = (u64, SpecExports);
 
 
-impl SpecFrom<SpecLimitMinMax> for SpecLimitMinMaxInner {
-    open spec fn spec_from(m: SpecLimitMinMax) -> SpecLimitMinMaxInner {
-        (m.min, m.max)
+impl SpecFrom<SpecExportsec> for SpecExportsecInner {
+    open spec fn spec_from(m: SpecExportsec) -> SpecExportsecInner {
+        (m.size, m.cont)
     }
 }
 
-impl SpecFrom<SpecLimitMinMaxInner> for SpecLimitMinMax {
-    open spec fn spec_from(m: SpecLimitMinMaxInner) -> SpecLimitMinMax {
-        let (min, max) = m;
-        SpecLimitMinMax { min, max }
+impl SpecFrom<SpecExportsecInner> for SpecExportsec {
+    open spec fn spec_from(m: SpecExportsecInner) -> SpecExportsec {
+        let (size, cont) = m;
+        SpecExportsec { size, cont }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct LimitMinMax {
-    pub min: u64,
-    pub max: u64,
+pub struct Exportsec {
+    pub size: u64,
+    pub cont: Exports,
 }
 
-impl View for LimitMinMax {
-    type V = SpecLimitMinMax;
+impl View for Exportsec {
+    type V = SpecExportsec;
 
     open spec fn view(&self) -> Self::V {
-        SpecLimitMinMax {
-            min: self.min@,
-            max: self.max@,
+        SpecExportsec {
+            size: self.size@,
+            cont: self.cont@,
         }
     }
 }
-pub type LimitMinMaxInner = (u64, u64);
+pub type ExportsecInner = (u64, Exports);
 
-pub type LimitMinMaxInnerRef<'a> = (&'a u64, &'a u64);
-impl<'a> From<&'a LimitMinMax> for LimitMinMaxInnerRef<'a> {
-    fn ex_from(m: &'a LimitMinMax) -> LimitMinMaxInnerRef<'a> {
-        (&m.min, &m.max)
+pub type ExportsecInnerRef<'a> = (&'a u64, &'a Exports);
+impl<'a> From<&'a Exportsec> for ExportsecInnerRef<'a> {
+    fn ex_from(m: &'a Exportsec) -> ExportsecInnerRef<'a> {
+        (&m.size, &m.cont)
     }
 }
 
-impl From<LimitMinMaxInner> for LimitMinMax {
-    fn ex_from(m: LimitMinMaxInner) -> LimitMinMax {
-        let (min, max) = m;
-        LimitMinMax { min, max }
+impl From<ExportsecInner> for Exportsec {
+    fn ex_from(m: ExportsecInner) -> Exportsec {
+        let (size, cont) = m;
+        Exportsec { size, cont }
     }
 }
 
-pub struct LimitMinMaxMapper;
-impl View for LimitMinMaxMapper {
+pub struct ExportsecMapper;
+impl View for ExportsecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for LimitMinMaxMapper {
-    type Src = SpecLimitMinMaxInner;
-    type Dst = SpecLimitMinMax;
+impl SpecIso for ExportsecMapper {
+    type Src = SpecExportsecInner;
+    type Dst = SpecExportsec;
 }
-impl SpecIsoProof for LimitMinMaxMapper {
+impl SpecIsoProof for ExportsecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -18807,226 +18798,242 @@ impl SpecIsoProof for LimitMinMaxMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for LimitMinMaxMapper {
-    type Src = LimitMinMaxInner;
-    type Dst = LimitMinMax;
-    type RefSrc = LimitMinMaxInnerRef<'a>;
+impl<'a> Iso<'a> for ExportsecMapper {
+    type Src = ExportsecInner;
+    type Dst = Exportsec;
+    type RefSrc = ExportsecInnerRef<'a>;
 }
-type SpecLimitMinMaxCombinatorAlias1 = (UnsignedLEB128, UnsignedLEB128);
-pub struct SpecLimitMinMaxCombinator(pub SpecLimitMinMaxCombinatorAlias);
 
-impl SpecCombinator for SpecLimitMinMaxCombinator {
-    type Type = SpecLimitMinMax;
+pub struct SpecExportsecCombinator(pub SpecExportsecCombinatorAlias);
+
+impl SpecCombinator for SpecExportsecCombinator {
+    type Type = SpecExportsec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecLimitMinMaxCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecLimitMinMaxCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecExportsecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecExportsecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecLimitMinMaxCombinatorAlias = Mapped<SpecLimitMinMaxCombinatorAlias1, LimitMinMaxMapper>;
-type LimitMinMaxCombinatorAlias1 = (UnsignedLEB128, UnsignedLEB128);
-pub struct LimitMinMaxCombinator1(pub LimitMinMaxCombinatorAlias1);
-impl View for LimitMinMaxCombinator1 {
-    type V = SpecLimitMinMaxCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(LimitMinMaxCombinator1, LimitMinMaxCombinatorAlias1);
-
-pub struct LimitMinMaxCombinator(pub LimitMinMaxCombinatorAlias);
+pub type SpecExportsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecExportsCombinator>>, ExportsecMapper>;
 
-impl View for LimitMinMaxCombinator {
-    type V = SpecLimitMinMaxCombinator;
-    open spec fn view(&self) -> Self::V { SpecLimitMinMaxCombinator(self.0@) }
+pub struct ExportsecCombinator(pub ExportsecCombinatorAlias);
+
+impl View for ExportsecCombinator {
+    type V = SpecExportsecCombinator;
+    open spec fn view(&self) -> Self::V { SpecExportsecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LimitMinMaxCombinator {
-    type Type = LimitMinMax;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExportsecCombinator {
+    type Type = Exportsec;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type LimitMinMaxCombinatorAlias = Mapped<LimitMinMaxCombinator1, LimitMinMaxMapper>;
+}
+pub type ExportsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, ExportsCombinator>, ExportsecCont0>, ExportsecMapper>;
 
 
-pub open spec fn spec_limit_min_max() -> SpecLimitMinMaxCombinator {
-    SpecLimitMinMaxCombinator(
+pub open spec fn spec_exportsec() -> SpecExportsecCombinator {
+    SpecExportsecCombinator(
     Mapped {
-        inner: (UnsignedLEB128, UnsignedLEB128),
-        mapper: LimitMinMaxMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_exportsec_cont0(deps)),
+        mapper: ExportsecMapper,
     })
 }
 
+pub open spec fn spec_exportsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecExportsCombinator> {
+    let size = deps;
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_exports())
+}
+
+impl View for ExportsecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecExportsCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_exportsec_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn limit_min_max<'a>() -> (o: LimitMinMaxCombinator)
-    ensures o@ == spec_limit_min_max(),
+pub fn exportsec<'a>() -> (o: ExportsecCombinator)
+    ensures o@ == spec_exportsec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = LimitMinMaxCombinator(
+    let combinator = ExportsecCombinator(
     Mapped {
-        inner: LimitMinMaxCombinator1((UnsignedLEB128, UnsignedLEB128)),
-        mapper: LimitMinMaxMapper,
-    });
-    assert({
-        &&& combinator@ == spec_limit_min_max()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, ExportsecCont0),
+        mapper: ExportsecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_exportsec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_limit_min_max<'a>(input: &'a [u8]) -> (res: PResult<<LimitMinMaxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_exportsec<'a>(input: &'a [u8]) -> (res: PResult<<ExportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_limit_min_max().spec_parse(input@) == Some((n as int, v@)),
-        spec_limit_min_max().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_exportsec().spec_parse(input@) == Some((n as int, v@)),
+        spec_exportsec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_limit_min_max().spec_parse(input@) is None,
-        spec_limit_min_max().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_exportsec().spec_parse(input@) is None,
+        spec_exportsec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = limit_min_max();
+    let combinator = exportsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_limit_min_max<'a>(v: <LimitMinMaxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_exportsec<'a>(v: <ExportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_limit_min_max().wf(v@),
+        spec_exportsec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_limit_min_max().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_limit_min_max().spec_serialize(v@))
+            &&& n == spec_exportsec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_exportsec().spec_serialize(v@))
         },
 {
-    let combinator = limit_min_max();
+    let combinator = exportsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn limit_min_max_len<'a>(v: <LimitMinMaxCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn exportsec_len<'a>(v: <ExportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_limit_min_max().wf(v@),
-        spec_limit_min_max().spec_serialize(v@).len() <= usize::MAX,
+        spec_exportsec().wf(v@),
+        spec_exportsec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_limit_min_max().spec_serialize(v@).len(),
+        serialize_len == spec_exportsec().spec_serialize(v@).len(),
 {
-    let combinator = limit_min_max();
+    let combinator = exportsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
+pub struct ExportsecCont0;
+type ExportsecCont0Type<'a, 'b> = &'b u64;
+type ExportsecCont0SType<'a, 'x> = &'x u64;
+type ExportsecCont0Input<'a, 'b, 'x> = POrSType<ExportsecCont0Type<'a, 'b>, ExportsecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ExportsecCont0Input<'a, 'b, 'x>> for ExportsecCont0 {
+    type Output = AndThen<bytes::Variable, ExportsCombinator>;
 
-pub enum SpecLimits {
-    NoMax(SpecLimitMin),
-    Max(SpecLimitMinMax),
-}
+    open spec fn requires(&self, deps: ExportsecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-pub type SpecLimitsInner = Either<SpecLimitMin, SpecLimitMinMax>;
+    open spec fn ensures(&self, deps: ExportsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_exportsec_cont0(deps@)
+    }
 
-impl SpecFrom<SpecLimits> for SpecLimitsInner {
-    open spec fn spec_from(m: SpecLimits) -> SpecLimitsInner {
-        match m {
-            SpecLimits::NoMax(m) => Either::Left(m),
-            SpecLimits::Max(m) => Either::Right(m),
+    fn apply(&self, deps: ExportsecCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), exports())
+            }
+            POrSType::S(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), exports())
+            }
         }
     }
-
 }
-
                 
-impl SpecFrom<SpecLimitsInner> for SpecLimits {
-    open spec fn spec_from(m: SpecLimitsInner) -> SpecLimits {
-        match m {
-            Either::Left(m) => SpecLimits::NoMax(m),
-            Either::Right(m) => SpecLimits::Max(m),
-        }
-    }
 
+pub struct SpecStart {
+    pub func: SpecFuncidx,
 }
 
+pub type SpecStartInner = SpecFuncidx;
 
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Limits {
-    NoMax(LimitMin),
-    Max(LimitMinMax),
+impl SpecFrom<SpecStart> for SpecStartInner {
+    open spec fn spec_from(m: SpecStart) -> SpecStartInner {
+        m.func
+    }
 }
 
-pub type LimitsInner = Either<LimitMin, LimitMinMax>;
+impl SpecFrom<SpecStartInner> for SpecStart {
+    open spec fn spec_from(m: SpecStartInner) -> SpecStart {
+        let func = m;
+        SpecStart { func }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub type LimitsInnerRef<'a> = Either<&'a LimitMin, &'a LimitMinMax>;
+pub struct Start {
+    pub func: Funcidx,
+}
 
+impl View for Start {
+    type V = SpecStart;
 
-impl View for Limits {
-    type V = SpecLimits;
     open spec fn view(&self) -> Self::V {
-        match self {
-            Limits::NoMax(m) => SpecLimits::NoMax(m@),
-            Limits::Max(m) => SpecLimits::Max(m@),
+        SpecStart {
+            func: self.func@,
         }
     }
 }
+pub type StartInner = Funcidx;
 
-
-impl<'a> From<&'a Limits> for LimitsInnerRef<'a> {
-    fn ex_from(m: &'a Limits) -> LimitsInnerRef<'a> {
-        match m {
-            Limits::NoMax(m) => Either::Left(m),
-            Limits::Max(m) => Either::Right(m),
-        }
+pub type StartInnerRef<'a> = &'a Funcidx;
+impl<'a> From<&'a Start> for StartInnerRef<'a> {
+    fn ex_from(m: &'a Start) -> StartInnerRef<'a> {
+        &m.func
     }
-
 }
 
-impl From<LimitsInner> for Limits {
-    fn ex_from(m: LimitsInner) -> Limits {
-        match m {
-            Either::Left(m) => Limits::NoMax(m),
-            Either::Right(m) => Limits::Max(m),
-        }
+impl From<StartInner> for Start {
+    fn ex_from(m: StartInner) -> Start {
+        let func = m;
+        Start { func }
     }
-    
 }
 
-
-pub struct LimitsMapper;
-impl View for LimitsMapper {
+pub struct StartMapper;
+impl View for StartMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for LimitsMapper {
-    type Src = SpecLimitsInner;
-    type Dst = SpecLimits;
+impl SpecIso for StartMapper {
+    type Src = SpecStartInner;
+    type Dst = SpecStart;
 }
-impl SpecIsoProof for LimitsMapper {
+impl SpecIsoProof for StartMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -19034,205 +19041,199 @@ impl SpecIsoProof for LimitsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for LimitsMapper {
-    type Src = LimitsInner;
-    type Dst = Limits;
-    type RefSrc = LimitsInnerRef<'a>;
+impl<'a> Iso<'a> for StartMapper {
+    type Src = StartInner;
+    type Dst = Start;
+    type RefSrc = StartInnerRef<'a>;
 }
 
-pub const LIMITSNOMAX_0_FRONT_CONST: u8 = 0;
-
-pub const LIMITSMAX_0_FRONT_CONST: u8 = 1;
-
-type SpecLimitsCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, SpecLimitMinCombinator>, Preceded<Tag<U8, u8>, SpecLimitMinMaxCombinator>>;
-pub struct SpecLimitsCombinator(pub SpecLimitsCombinatorAlias);
+pub struct SpecStartCombinator(pub SpecStartCombinatorAlias);
 
-impl SpecCombinator for SpecLimitsCombinator {
-    type Type = SpecLimits;
+impl SpecCombinator for SpecStartCombinator {
+    type Type = SpecStart;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecLimitsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecLimitsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecStartCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecStartCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecLimitsCombinatorAlias = Mapped<SpecLimitsCombinatorAlias1, LimitsMapper>;
-
-
-type LimitsCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, LimitMinCombinator>, Preceded<Tag<U8, u8>, LimitMinMaxCombinator>>;
-pub struct LimitsCombinator1(pub LimitsCombinatorAlias1);
-impl View for LimitsCombinator1 {
-    type V = SpecLimitsCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(LimitsCombinator1, LimitsCombinatorAlias1);
+pub type SpecStartCombinatorAlias = Mapped<SpecFuncidxCombinator, StartMapper>;
 
-pub struct LimitsCombinator(pub LimitsCombinatorAlias);
+pub struct StartCombinator(pub StartCombinatorAlias);
 
-impl View for LimitsCombinator {
-    type V = SpecLimitsCombinator;
-    open spec fn view(&self) -> Self::V { SpecLimitsCombinator(self.0@) }
+impl View for StartCombinator {
+    type V = SpecStartCombinator;
+    open spec fn view(&self) -> Self::V { SpecStartCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LimitsCombinator {
-    type Type = Limits;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for StartCombinator {
+    type Type = Start;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type LimitsCombinatorAlias = Mapped<LimitsCombinator1, LimitsMapper>;
+}
+pub type StartCombinatorAlias = Mapped<FuncidxCombinator, StartMapper>;
 
 
-pub open spec fn spec_limits() -> SpecLimitsCombinator {
-    SpecLimitsCombinator(Mapped { inner: Choice(Preceded(Tag::spec_new(U8, LIMITSNOMAX_0_FRONT_CONST), spec_limit_min()), Preceded(Tag::spec_new(U8, LIMITSMAX_0_FRONT_CONST), spec_limit_min_max())), mapper: LimitsMapper })
+pub open spec fn spec_start() -> SpecStartCombinator {
+    SpecStartCombinator(
+    Mapped {
+        inner: spec_funcidx(),
+        mapper: StartMapper,
+    })
 }
 
                 
-pub fn limits<'a>() -> (o: LimitsCombinator)
-    ensures o@ == spec_limits(),
+pub fn start<'a>() -> (o: StartCombinator)
+    ensures o@ == spec_start(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = LimitsCombinator(Mapped { inner: LimitsCombinator1(Choice::new(Preceded(Tag::new(U8, LIMITSNOMAX_0_FRONT_CONST), limit_min()), Preceded(Tag::new(U8, LIMITSMAX_0_FRONT_CONST), limit_min_max()))), mapper: LimitsMapper });
-    assert({
-        &&& combinator@ == spec_limits()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = StartCombinator(
+    Mapped {
+        inner: funcidx(),
+        mapper: StartMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_start()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_limits<'a>(input: &'a [u8]) -> (res: PResult<<LimitsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_start<'a>(input: &'a [u8]) -> (res: PResult<<StartCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_limits().spec_parse(input@) == Some((n as int, v@)),
-        spec_limits().spec_parse(input@) matches Some((n, v))
+    ensures
+        res matches Ok((n, v)) ==> spec_start().spec_parse(input@) == Some((n as int, v@)),
+        spec_start().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_limits().spec_parse(input@) is None,
-        spec_limits().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_start().spec_parse(input@) is None,
+        spec_start().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = limits();
+    let combinator = start();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_limits<'a>(v: <LimitsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_start<'a>(v: <StartCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_limits().wf(v@),
+        spec_start().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_limits().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_limits().spec_serialize(v@))
+            &&& n == spec_start().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_start().spec_serialize(v@))
         },
 {
-    let combinator = limits();
+    let combinator = start();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn limits_len<'a>(v: <LimitsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn start_len<'a>(v: <StartCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_limits().wf(v@),
-        spec_limits().spec_serialize(v@).len() <= usize::MAX,
+        spec_start().wf(v@),
+        spec_start().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_limits().spec_serialize(v@).len(),
+        serialize_len == spec_start().spec_serialize(v@).len(),
 {
-    let combinator = limits();
+    let combinator = start();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecTabletype {
-    pub elemtype: SpecReftype,
-    pub limits: SpecLimits,
+pub struct SpecStartsec {
+    pub size: u64,
+    pub cont: SpecStart,
 }
 
-pub type SpecTabletypeInner = (SpecReftype, SpecLimits);
+pub type SpecStartsecInner = (u64, SpecStart);
 
 
-impl SpecFrom<SpecTabletype> for SpecTabletypeInner {
-    open spec fn spec_from(m: SpecTabletype) -> SpecTabletypeInner {
-        (m.elemtype, m.limits)
+impl SpecFrom<SpecStartsec> for SpecStartsecInner {
+    open spec fn spec_from(m: SpecStartsec) -> SpecStartsecInner {
+        (m.size, m.cont)
     }
 }
 
-impl SpecFrom<SpecTabletypeInner> for SpecTabletype {
-    open spec fn spec_from(m: SpecTabletypeInner) -> SpecTabletype {
-        let (elemtype, limits) = m;
-        SpecTabletype { elemtype, limits }
+impl SpecFrom<SpecStartsecInner> for SpecStartsec {
+    open spec fn spec_from(m: SpecStartsecInner) -> SpecStartsec {
+        let (size, cont) = m;
+        SpecStartsec { size, cont }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Tabletype {
-    pub elemtype: Reftype,
-    pub limits: Limits,
+pub struct Startsec {
+    pub size: u64,
+    pub cont: Start,
 }
 
-impl View for Tabletype {
-    type V = SpecTabletype;
+impl View for Startsec {
+    type V = SpecStartsec;
 
     open spec fn view(&self) -> Self::V {
-        SpecTabletype {
-            elemtype: self.elemtype@,
-            limits: self.limits@,
+        SpecStartsec {
+            size: self.size@,
+            cont: self.cont@,
         }
     }
 }
-pub type TabletypeInner = (Reftype, Limits);
+pub type StartsecInner = (u64, Start);
 
-pub type TabletypeInnerRef<'a> = (&'a Reftype, &'a Limits);
-impl<'a> From<&'a Tabletype> for TabletypeInnerRef<'a> {
-    fn ex_from(m: &'a Tabletype) -> TabletypeInnerRef<'a> {
-        (&m.elemtype, &m.limits)
+pub type StartsecInnerRef<'a> = (&'a u64, &'a Start);
+impl<'a> From<&'a Startsec> for StartsecInnerRef<'a> {
+    fn ex_from(m: &'a Startsec) -> StartsecInnerRef<'a> {
+        (&m.size, &m.cont)
     }
 }
 
-impl From<TabletypeInner> for Tabletype {
-    fn ex_from(m: TabletypeInner) -> Tabletype {
-        let (elemtype, limits) = m;
-        Tabletype { elemtype, limits }
+impl From<StartsecInner> for Startsec {
+    fn ex_from(m: StartsecInner) -> Startsec {
+        let (size, cont) = m;
+        Startsec { size, cont }
     }
 }
 
-pub struct TabletypeMapper;
-impl View for TabletypeMapper {
+pub struct StartsecMapper;
+impl View for StartsecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for TabletypeMapper {
-    type Src = SpecTabletypeInner;
-    type Dst = SpecTabletype;
+impl SpecIso for StartsecMapper {
+    type Src = SpecStartsecInner;
+    type Dst = SpecStartsec;
 }
-impl SpecIsoProof for TabletypeMapper {
+impl SpecIsoProof for StartsecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -19240,548 +19241,698 @@ impl SpecIsoProof for TabletypeMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for TabletypeMapper {
-    type Src = TabletypeInner;
-    type Dst = Tabletype;
-    type RefSrc = TabletypeInnerRef<'a>;
+impl<'a> Iso<'a> for StartsecMapper {
+    type Src = StartsecInner;
+    type Dst = Startsec;
+    type RefSrc = StartsecInnerRef<'a>;
 }
-type SpecTabletypeCombinatorAlias1 = (SpecReftypeCombinator, SpecLimitsCombinator);
-pub struct SpecTabletypeCombinator(pub SpecTabletypeCombinatorAlias);
 
-impl SpecCombinator for SpecTabletypeCombinator {
-    type Type = SpecTabletype;
+pub struct SpecStartsecCombinator(pub SpecStartsecCombinatorAlias);
+
+impl SpecCombinator for SpecStartsecCombinator {
+    type Type = SpecStartsec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTabletypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTabletypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecStartsecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecStartsecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTabletypeCombinatorAlias = Mapped<SpecTabletypeCombinatorAlias1, TabletypeMapper>;
-type TabletypeCombinatorAlias1 = (ReftypeCombinator, LimitsCombinator);
-pub struct TabletypeCombinator1(pub TabletypeCombinatorAlias1);
-impl View for TabletypeCombinator1 {
-    type V = SpecTabletypeCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(TabletypeCombinator1, TabletypeCombinatorAlias1);
+pub type SpecStartsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecStartCombinator>>, StartsecMapper>;
 
-pub struct TabletypeCombinator(pub TabletypeCombinatorAlias);
+pub struct StartsecCombinator(pub StartsecCombinatorAlias);
 
-impl View for TabletypeCombinator {
-    type V = SpecTabletypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecTabletypeCombinator(self.0@) }
+impl View for StartsecCombinator {
+    type V = SpecStartsecCombinator;
+    open spec fn view(&self) -> Self::V { SpecStartsecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TabletypeCombinator {
-    type Type = Tabletype;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for StartsecCombinator {
+    type Type = Startsec;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TabletypeCombinatorAlias = Mapped<TabletypeCombinator1, TabletypeMapper>;
+}
+pub type StartsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, StartCombinator>, StartsecCont0>, StartsecMapper>;
 
 
-pub open spec fn spec_tabletype() -> SpecTabletypeCombinator {
-    SpecTabletypeCombinator(
+pub open spec fn spec_startsec() -> SpecStartsecCombinator {
+    SpecStartsecCombinator(
     Mapped {
-        inner: (spec_reftype(), spec_limits()),
-        mapper: TabletypeMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_startsec_cont0(deps)),
+        mapper: StartsecMapper,
     })
 }
 
-                
-pub fn tabletype<'a>() -> (o: TabletypeCombinator)
-    ensures o@ == spec_tabletype(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = TabletypeCombinator(
-    Mapped {
-        inner: TabletypeCombinator1((reftype(), limits())),
-        mapper: TabletypeMapper,
-    });
-    assert({
-        &&& combinator@ == spec_tabletype()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
+pub open spec fn spec_startsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecStartCombinator> {
+    let size = deps;
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_start())
+}
+
+impl View for StartsecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecStartCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_startsec_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn startsec<'a>() -> (o: StartsecCombinator)
+    ensures o@ == spec_startsec(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = StartsecCombinator(
+    Mapped {
+        inner: Pair::new(UnsignedLEB128, StartsecCont0),
+        mapper: StartsecMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_startsec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_startsec<'a>(input: &'a [u8]) -> (res: PResult<<StartsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_startsec().spec_parse(input@) == Some((n as int, v@)),
+        spec_startsec().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_startsec().spec_parse(input@) is None,
+        spec_startsec().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = startsec();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_startsec<'a>(v: <StartsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_startsec().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_startsec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_startsec().spec_serialize(v@))
+        },
+{
+    let combinator = startsec();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn startsec_len<'a>(v: <StartsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_startsec().wf(v@),
+        spec_startsec().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_startsec().spec_serialize(v@).len(),
+{
+    let combinator = startsec();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct StartsecCont0;
+type StartsecCont0Type<'a, 'b> = &'b u64;
+type StartsecCont0SType<'a, 'x> = &'x u64;
+type StartsecCont0Input<'a, 'b, 'x> = POrSType<StartsecCont0Type<'a, 'b>, StartsecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<StartsecCont0Input<'a, 'b, 'x>> for StartsecCont0 {
+    type Output = AndThen<bytes::Variable, StartCombinator>;
+
+    open spec fn requires(&self, deps: StartsecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: StartsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_startsec_cont0(deps@)
+    }
+
+    fn apply(&self, deps: StartsecCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), start())
+            }
+            POrSType::S(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), start())
+            }
+        }
+    }
+}
+                
+
+pub struct SpecFuncidxs {
+    pub l: u64,
+    pub v: Seq<SpecFuncidx>,
+}
+
+pub type SpecFuncidxsInner = (u64, Seq<SpecFuncidx>);
+
+
+impl SpecFrom<SpecFuncidxs> for SpecFuncidxsInner {
+    open spec fn spec_from(m: SpecFuncidxs) -> SpecFuncidxsInner {
+        (m.l, m.v)
+    }
+}
+
+impl SpecFrom<SpecFuncidxsInner> for SpecFuncidxs {
+    open spec fn spec_from(m: SpecFuncidxsInner) -> SpecFuncidxs {
+        let (l, v) = m;
+        SpecFuncidxs { l, v }
+    }
 }
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub fn parse_tabletype<'a>(input: &'a [u8]) -> (res: PResult<<TabletypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_tabletype().spec_parse(input@) == Some((n as int, v@)),
-        spec_tabletype().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_tabletype().spec_parse(input@) is None,
-        spec_tabletype().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = tabletype();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+pub struct Funcidxs {
+    pub l: u64,
+    pub v: RepeatResult<Funcidx>,
 }
 
-pub fn serialize_tabletype<'a>(v: <TabletypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_tabletype().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_tabletype().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_tabletype().spec_serialize(v@))
-        },
-{
-    let combinator = tabletype();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+impl View for Funcidxs {
+    type V = SpecFuncidxs;
+
+    open spec fn view(&self) -> Self::V {
+        SpecFuncidxs {
+            l: self.l@,
+            v: self.v@,
+        }
+    }
 }
+pub type FuncidxsInner = (u64, RepeatResult<Funcidx>);
 
-pub fn tabletype_len<'a>(v: <TabletypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_tabletype().wf(v@),
-        spec_tabletype().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_tabletype().spec_serialize(v@).len(),
-{
-    let combinator = tabletype();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+pub type FuncidxsInnerRef<'a> = (&'a u64, &'a RepeatResult<Funcidx>);
+impl<'a> From<&'a Funcidxs> for FuncidxsInnerRef<'a> {
+    fn ex_from(m: &'a Funcidxs) -> FuncidxsInnerRef<'a> {
+        (&m.l, &m.v)
+    }
 }
 
-                
-pub type SpecMemtype = SpecLimits;
-pub type Memtype = Limits;
-pub type MemtypeRef<'a> = &'a Limits;
+impl From<FuncidxsInner> for Funcidxs {
+    fn ex_from(m: FuncidxsInner) -> Funcidxs {
+        let (l, v) = m;
+        Funcidxs { l, v }
+    }
+}
 
+pub struct FuncidxsMapper;
+impl View for FuncidxsMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for FuncidxsMapper {
+    type Src = SpecFuncidxsInner;
+    type Dst = SpecFuncidxs;
+}
+impl SpecIsoProof for FuncidxsMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for FuncidxsMapper {
+    type Src = FuncidxsInner;
+    type Dst = Funcidxs;
+    type RefSrc = FuncidxsInnerRef<'a>;
+}
 
-pub struct SpecMemtypeCombinator(pub SpecMemtypeCombinatorAlias);
+pub struct SpecFuncidxsCombinator(pub SpecFuncidxsCombinatorAlias);
 
-impl SpecCombinator for SpecMemtypeCombinator {
-    type Type = SpecMemtype;
+impl SpecCombinator for SpecFuncidxsCombinator {
+    type Type = SpecFuncidxs;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecMemtypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecMemtypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecFuncidxsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecFuncidxsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecMemtypeCombinatorAlias = SpecLimitsCombinator;
+pub type SpecFuncidxsCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecFuncidxCombinator>>, FuncidxsMapper>;
 
-pub struct MemtypeCombinator(pub MemtypeCombinatorAlias);
+pub struct FuncidxsCombinator(pub FuncidxsCombinatorAlias);
 
-impl View for MemtypeCombinator {
-    type V = SpecMemtypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecMemtypeCombinator(self.0@) }
+impl View for FuncidxsCombinator {
+    type V = SpecFuncidxsCombinator;
+    open spec fn view(&self) -> Self::V { SpecFuncidxsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemtypeCombinator {
-    type Type = Memtype;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FuncidxsCombinator {
+    type Type = Funcidxs;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type MemtypeCombinatorAlias = LimitsCombinator;
+}
+pub type FuncidxsCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<FuncidxCombinator>, FuncidxsCont0>, FuncidxsMapper>;
 
 
-pub open spec fn spec_memtype() -> SpecMemtypeCombinator {
-    SpecMemtypeCombinator(spec_limits())
+pub open spec fn spec_funcidxs() -> SpecFuncidxsCombinator {
+    SpecFuncidxsCombinator(
+    Mapped {
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_funcidxs_cont0(deps)),
+        mapper: FuncidxsMapper,
+    })
+}
+
+pub open spec fn spec_funcidxs_cont0(deps: u64) -> RepeatN<SpecFuncidxCombinator> {
+    let l = deps;
+    RepeatN(spec_funcidx(), (usize::spec_from(l)) as usize)
+}
+
+impl View for FuncidxsCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecFuncidxCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_funcidxs_cont0(deps)
+        }
+    }
 }
 
                 
-pub fn memtype<'a>() -> (o: MemtypeCombinator)
-    ensures o@ == spec_memtype(),
+pub fn funcidxs<'a>() -> (o: FuncidxsCombinator)
+    ensures o@ == spec_funcidxs(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = MemtypeCombinator(limits());
-    assert({
-        &&& combinator@ == spec_memtype()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = FuncidxsCombinator(
+    Mapped {
+        inner: Pair::new(UnsignedLEB128, FuncidxsCont0),
+        mapper: FuncidxsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_funcidxs()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_memtype<'a>(input: &'a [u8]) -> (res: PResult<<MemtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_funcidxs<'a>(input: &'a [u8]) -> (res: PResult<<FuncidxsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_memtype().spec_parse(input@) == Some((n as int, v@)),
-        spec_memtype().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_funcidxs().spec_parse(input@) == Some((n as int, v@)),
+        spec_funcidxs().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_memtype().spec_parse(input@) is None,
-        spec_memtype().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_funcidxs().spec_parse(input@) is None,
+        spec_funcidxs().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = memtype();
+    let combinator = funcidxs();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_memtype<'a>(v: <MemtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_funcidxs<'a>(v: <FuncidxsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_memtype().wf(v@),
+        spec_funcidxs().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_memtype().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_memtype().spec_serialize(v@))
+            &&& n == spec_funcidxs().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_funcidxs().spec_serialize(v@))
         },
 {
-    let combinator = memtype();
+    let combinator = funcidxs();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn memtype_len<'a>(v: <MemtypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn funcidxs_len<'a>(v: <FuncidxsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_memtype().wf(v@),
-        spec_memtype().spec_serialize(v@).len() <= usize::MAX,
+        spec_funcidxs().wf(v@),
+        spec_funcidxs().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_memtype().spec_serialize(v@).len(),
+        serialize_len == spec_funcidxs().spec_serialize(v@).len(),
 {
-    let combinator = memtype();
+    let combinator = funcidxs();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
-
-pub spec const SPEC_MutT_Const: u8 = 0;
-pub spec const SPEC_MutT_Var: u8 = 1;
-pub exec static EXEC_MutT_Const: u8 ensures EXEC_MutT_Const == SPEC_MutT_Const { 0 }
-pub exec static EXEC_MutT_Var: u8 ensures EXEC_MutT_Var == SPEC_MutT_Var { 1 }
-
-#[derive(Structural, Debug, Copy, Clone, PartialEq, Eq)]
-pub enum MutT {
-    Const = 0,
-Var = 1
-}
-pub type SpecMutT = MutT;
-
-pub type MutTInner = u8;
+pub struct FuncidxsCont0;
+type FuncidxsCont0Type<'a, 'b> = &'b u64;
+type FuncidxsCont0SType<'a, 'x> = &'x u64;
+type FuncidxsCont0Input<'a, 'b, 'x> = POrSType<FuncidxsCont0Type<'a, 'b>, FuncidxsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<FuncidxsCont0Input<'a, 'b, 'x>> for FuncidxsCont0 {
+    type Output = RepeatN<FuncidxCombinator>;
 
-pub type MutTInnerRef<'a> = &'a u8;
+    open spec fn requires(&self, deps: FuncidxsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-impl View for MutT {
-    type V = Self;
+    open spec fn ensures(&self, deps: FuncidxsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_funcidxs_cont0(deps@)
+    }
 
-    open spec fn view(&self) -> Self::V {
-        *self
+    fn apply(&self, deps: FuncidxsCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(funcidx(), (usize::ex_from(l)) as usize)
+            }
+            POrSType::S(deps) => {
+                let l = deps;
+                let l = *l;
+                RepeatN(funcidx(), (usize::ex_from(l)) as usize)
+            }
+        }
     }
 }
+                
+
+pub struct SpecParsedElem0 {
+    pub e: SpecExpr,
+    pub init: SpecFuncidxs,
+}
 
-impl SpecTryFrom<MutTInner> for MutT {
-    type Error = ();
+pub type SpecParsedElem0Inner = (SpecExpr, SpecFuncidxs);
 
-    open spec fn spec_try_from(v: MutTInner) -> Result<MutT, ()> {
-        match v {
-            0u8 => Ok(MutT::Const),
-            1u8 => Ok(MutT::Var),
-            _ => Err(()),
-        }
+
+impl SpecFrom<SpecParsedElem0> for SpecParsedElem0Inner {
+    open spec fn spec_from(m: SpecParsedElem0) -> SpecParsedElem0Inner {
+        (m.e, m.init)
     }
 }
 
-impl SpecTryFrom<MutT> for MutTInner {
-    type Error = ();
-
-    open spec fn spec_try_from(v: MutT) -> Result<MutTInner, ()> {
-        match v {
-            MutT::Const => Ok(SPEC_MutT_Const),
-            MutT::Var => Ok(SPEC_MutT_Var),
-        }
+impl SpecFrom<SpecParsedElem0Inner> for SpecParsedElem0 {
+    open spec fn spec_from(m: SpecParsedElem0Inner) -> SpecParsedElem0 {
+        let (e, init) = m;
+        SpecParsedElem0 { e, init }
     }
 }
+#[derive(Debug, Clone, PartialEq, Eq)]
 
-impl TryFrom<MutTInner> for MutT {
-    type Error = ();
+pub struct ParsedElem0<'a> {
+    pub e: Expr<'a>,
+    pub init: Funcidxs,
+}
 
-    fn ex_try_from(v: MutTInner) -> Result<MutT, ()> {
-        match v {
-            0u8 => Ok(MutT::Const),
-            1u8 => Ok(MutT::Var),
-            _ => Err(()),
+impl View for ParsedElem0<'_> {
+    type V = SpecParsedElem0;
+
+    open spec fn view(&self) -> Self::V {
+        SpecParsedElem0 {
+            e: self.e@,
+            init: self.init@,
         }
     }
 }
+pub type ParsedElem0Inner<'a> = (Expr<'a>, Funcidxs);
 
-impl<'a> TryFrom<&'a MutT> for MutTInnerRef<'a> {
-    type Error = ();
-
-    fn ex_try_from(v: &'a MutT) -> Result<MutTInnerRef<'a>, ()> {
-        match v {
-            MutT::Const => Ok(&EXEC_MutT_Const),
-            MutT::Var => Ok(&EXEC_MutT_Var),
-        }
+pub type ParsedElem0InnerRef<'a> = (&'a Expr<'a>, &'a Funcidxs);
+impl<'a> From<&'a ParsedElem0<'a>> for ParsedElem0InnerRef<'a> {
+    fn ex_from(m: &'a ParsedElem0) -> ParsedElem0InnerRef<'a> {
+        (&m.e, &m.init)
     }
 }
 
-pub struct MutTMapper;
+impl<'a> From<ParsedElem0Inner<'a>> for ParsedElem0<'a> {
+    fn ex_from(m: ParsedElem0Inner) -> ParsedElem0 {
+        let (e, init) = m;
+        ParsedElem0 { e, init }
+    }
+}
 
-impl View for MutTMapper {
+pub struct ParsedElem0Mapper;
+impl View for ParsedElem0Mapper {
     type V = Self;
-
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-
-impl SpecPartialIso for MutTMapper {
-    type Src = MutTInner;
-    type Dst = MutT;
+impl SpecIso for ParsedElem0Mapper {
+    type Src = SpecParsedElem0Inner;
+    type Dst = SpecParsedElem0;
 }
-
-impl SpecPartialIsoProof for MutTMapper {
-    proof fn spec_iso(s: Self::Src) { 
-        assert(
-            Self::spec_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_rev_apply(v) is Ok
-            &&& Self::spec_rev_apply(v) matches Ok(s_) && s == s_
-        });
+impl SpecIsoProof for ParsedElem0Mapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
-
-    proof fn spec_iso_rev(s: Self::Dst) { 
-        assert(
-            Self::spec_rev_apply(s) matches Ok(v) ==> {
-            &&& Self::spec_apply(v) is Ok
-            &&& Self::spec_apply(v) matches Ok(s_) && s == s_
-        });
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-
-impl<'a> PartialIso<'a> for MutTMapper {
-    type Src = MutTInner;
-    type Dst = MutT;
-    type RefSrc = MutTInnerRef<'a>;
+impl<'a> Iso<'a> for ParsedElem0Mapper {
+    type Src = ParsedElem0Inner<'a>;
+    type Dst = ParsedElem0<'a>;
+    type RefSrc = ParsedElem0InnerRef<'a>;
 }
+type SpecParsedElem0CombinatorAlias1 = (SpecExprCombinator, SpecFuncidxsCombinator);
+pub struct SpecParsedElem0Combinator(pub SpecParsedElem0CombinatorAlias);
 
-
-pub struct SpecMutTCombinator(pub SpecMutTCombinatorAlias);
-
-impl SpecCombinator for SpecMutTCombinator {
-    type Type = SpecMutT;
+impl SpecCombinator for SpecParsedElem0Combinator {
+    type Type = SpecParsedElem0;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecMutTCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecMutTCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecParsedElem0Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecParsedElem0CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecMutTCombinatorAlias = TryMap<U8, MutTMapper>;
+pub type SpecParsedElem0CombinatorAlias = Mapped<SpecParsedElem0CombinatorAlias1, ParsedElem0Mapper>;
+type ParsedElem0CombinatorAlias1 = (ExprCombinator, FuncidxsCombinator);
+pub struct ParsedElem0Combinator1(pub ParsedElem0CombinatorAlias1);
+impl View for ParsedElem0Combinator1 {
+    type V = SpecParsedElem0CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ParsedElem0Combinator1, ParsedElem0CombinatorAlias1);
 
-pub struct MutTCombinator(pub MutTCombinatorAlias);
+pub struct ParsedElem0Combinator(pub ParsedElem0CombinatorAlias);
 
-impl View for MutTCombinator {
-    type V = SpecMutTCombinator;
-    open spec fn view(&self) -> Self::V { SpecMutTCombinator(self.0@) }
+impl View for ParsedElem0Combinator {
+    type V = SpecParsedElem0Combinator;
+    open spec fn view(&self) -> Self::V { SpecParsedElem0Combinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MutTCombinator {
-    type Type = MutT;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem0Combinator {
+    type Type = ParsedElem0<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type MutTCombinatorAlias = TryMap<U8, MutTMapper>;
+}
+pub type ParsedElem0CombinatorAlias = Mapped<ParsedElem0Combinator1, ParsedElem0Mapper>;
 
 
-pub open spec fn spec_mut_t() -> SpecMutTCombinator {
-    SpecMutTCombinator(TryMap { inner: U8, mapper: MutTMapper })
+pub open spec fn spec_parsed_elem0() -> SpecParsedElem0Combinator {
+    SpecParsedElem0Combinator(
+    Mapped {
+        inner: (spec_expr(), spec_funcidxs()),
+        mapper: ParsedElem0Mapper,
+    })
 }
 
                 
-pub fn mut_t<'a>() -> (o: MutTCombinator)
-    ensures o@ == spec_mut_t(),
+pub fn parsed_elem0<'a>() -> (o: ParsedElem0Combinator)
+    ensures o@ == spec_parsed_elem0(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = MutTCombinator(TryMap { inner: U8, mapper: MutTMapper });
-    assert({
-        &&& combinator@ == spec_mut_t()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ParsedElem0Combinator(
+    Mapped {
+        inner: ParsedElem0Combinator1((expr(), funcidxs())),
+        mapper: ParsedElem0Mapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_parsed_elem0()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_mut_t<'a>(input: &'a [u8]) -> (res: PResult<<MutTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_parsed_elem0<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_mut_t().spec_parse(input@) == Some((n as int, v@)),
-        spec_mut_t().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_parsed_elem0().spec_parse(input@) == Some((n as int, v@)),
+        spec_parsed_elem0().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_mut_t().spec_parse(input@) is None,
-        spec_mut_t().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_parsed_elem0().spec_parse(input@) is None,
+        spec_parsed_elem0().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = mut_t();
+    let combinator = parsed_elem0();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_mut_t<'a>(v: <MutTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_parsed_elem0<'a>(v: <ParsedElem0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_mut_t().wf(v@),
+        spec_parsed_elem0().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_mut_t().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_mut_t().spec_serialize(v@))
+            &&& n == spec_parsed_elem0().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem0().spec_serialize(v@))
         },
 {
-    let combinator = mut_t();
+    let combinator = parsed_elem0();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn mut_t_len<'a>(v: <MutTCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn parsed_elem0_len<'a>(v: <ParsedElem0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_mut_t().wf(v@),
-        spec_mut_t().spec_serialize(v@).len() <= usize::MAX,
+        spec_parsed_elem0().wf(v@),
+        spec_parsed_elem0().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_mut_t().spec_serialize(v@).len(),
+        serialize_len == spec_parsed_elem0().spec_serialize(v@).len(),
 {
-    let combinator = mut_t();
+    let combinator = parsed_elem0();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecGlobaltype {
-    pub t: SpecValtype,
-    pub m: SpecMutT,
+pub struct SpecParsedElem1 {
+    pub et: SpecELEMKIND,
+    pub init: SpecFuncidxs,
 }
 
-pub type SpecGlobaltypeInner = (SpecValtype, SpecMutT);
+pub type SpecParsedElem1Inner = (SpecELEMKIND, SpecFuncidxs);
 
 
-impl SpecFrom<SpecGlobaltype> for SpecGlobaltypeInner {
-    open spec fn spec_from(m: SpecGlobaltype) -> SpecGlobaltypeInner {
-        (m.t, m.m)
+impl SpecFrom<SpecParsedElem1> for SpecParsedElem1Inner {
+    open spec fn spec_from(m: SpecParsedElem1) -> SpecParsedElem1Inner {
+        (m.et, m.init)
     }
 }
 
-impl SpecFrom<SpecGlobaltypeInner> for SpecGlobaltype {
-    open spec fn spec_from(m: SpecGlobaltypeInner) -> SpecGlobaltype {
-        let (t, m) = m;
-        SpecGlobaltype { t, m }
+impl SpecFrom<SpecParsedElem1Inner> for SpecParsedElem1 {
+    open spec fn spec_from(m: SpecParsedElem1Inner) -> SpecParsedElem1 {
+        let (et, init) = m;
+        SpecParsedElem1 { et, init }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Globaltype {
-    pub t: Valtype,
-    pub m: MutT,
+pub struct ParsedElem1 {
+    pub et: ELEMKIND,
+    pub init: Funcidxs,
 }
 
-impl View for Globaltype {
-    type V = SpecGlobaltype;
+impl View for ParsedElem1 {
+    type V = SpecParsedElem1;
 
     open spec fn view(&self) -> Self::V {
-        SpecGlobaltype {
-            t: self.t@,
-            m: self.m@,
+        SpecParsedElem1 {
+            et: self.et@,
+            init: self.init@,
         }
     }
 }
-pub type GlobaltypeInner = (Valtype, MutT);
+pub type ParsedElem1Inner = (ELEMKIND, Funcidxs);
 
-pub type GlobaltypeInnerRef<'a> = (&'a Valtype, &'a MutT);
-impl<'a> From<&'a Globaltype> for GlobaltypeInnerRef<'a> {
-    fn ex_from(m: &'a Globaltype) -> GlobaltypeInnerRef<'a> {
-        (&m.t, &m.m)
+pub type ParsedElem1InnerRef<'a> = (&'a ELEMKIND, &'a Funcidxs);
+impl<'a> From<&'a ParsedElem1> for ParsedElem1InnerRef<'a> {
+    fn ex_from(m: &'a ParsedElem1) -> ParsedElem1InnerRef<'a> {
+        (&m.et, &m.init)
     }
 }
 
-impl From<GlobaltypeInner> for Globaltype {
-    fn ex_from(m: GlobaltypeInner) -> Globaltype {
-        let (t, m) = m;
-        Globaltype { t, m }
+impl From<ParsedElem1Inner> for ParsedElem1 {
+    fn ex_from(m: ParsedElem1Inner) -> ParsedElem1 {
+        let (et, init) = m;
+        ParsedElem1 { et, init }
     }
 }
 
-pub struct GlobaltypeMapper;
-impl View for GlobaltypeMapper {
+pub struct ParsedElem1Mapper;
+impl View for ParsedElem1Mapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for GlobaltypeMapper {
-    type Src = SpecGlobaltypeInner;
-    type Dst = SpecGlobaltype;
+impl SpecIso for ParsedElem1Mapper {
+    type Src = SpecParsedElem1Inner;
+    type Dst = SpecParsedElem1;
 }
-impl SpecIsoProof for GlobaltypeMapper {
+impl SpecIsoProof for ParsedElem1Mapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -19789,240 +19940,212 @@ impl SpecIsoProof for GlobaltypeMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for GlobaltypeMapper {
-    type Src = GlobaltypeInner;
-    type Dst = Globaltype;
-    type RefSrc = GlobaltypeInnerRef<'a>;
+impl<'a> Iso<'a> for ParsedElem1Mapper {
+    type Src = ParsedElem1Inner;
+    type Dst = ParsedElem1;
+    type RefSrc = ParsedElem1InnerRef<'a>;
 }
-type SpecGlobaltypeCombinatorAlias1 = (SpecValtypeCombinator, SpecMutTCombinator);
-pub struct SpecGlobaltypeCombinator(pub SpecGlobaltypeCombinatorAlias);
+type SpecParsedElem1CombinatorAlias1 = (SpecELEMKINDCombinator, SpecFuncidxsCombinator);
+pub struct SpecParsedElem1Combinator(pub SpecParsedElem1CombinatorAlias);
 
-impl SpecCombinator for SpecGlobaltypeCombinator {
-    type Type = SpecGlobaltype;
+impl SpecCombinator for SpecParsedElem1Combinator {
+    type Type = SpecParsedElem1;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecGlobaltypeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecGlobaltypeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecParsedElem1Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecParsedElem1CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecGlobaltypeCombinatorAlias = Mapped<SpecGlobaltypeCombinatorAlias1, GlobaltypeMapper>;
-type GlobaltypeCombinatorAlias1 = (ValtypeCombinator, MutTCombinator);
-pub struct GlobaltypeCombinator1(pub GlobaltypeCombinatorAlias1);
-impl View for GlobaltypeCombinator1 {
-    type V = SpecGlobaltypeCombinatorAlias1;
+pub type SpecParsedElem1CombinatorAlias = Mapped<SpecParsedElem1CombinatorAlias1, ParsedElem1Mapper>;
+type ParsedElem1CombinatorAlias1 = (ELEMKINDCombinator, FuncidxsCombinator);
+pub struct ParsedElem1Combinator1(pub ParsedElem1CombinatorAlias1);
+impl View for ParsedElem1Combinator1 {
+    type V = SpecParsedElem1CombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(GlobaltypeCombinator1, GlobaltypeCombinatorAlias1);
+impl_wrapper_combinator!(ParsedElem1Combinator1, ParsedElem1CombinatorAlias1);
 
-pub struct GlobaltypeCombinator(pub GlobaltypeCombinatorAlias);
+pub struct ParsedElem1Combinator(pub ParsedElem1CombinatorAlias);
 
-impl View for GlobaltypeCombinator {
-    type V = SpecGlobaltypeCombinator;
-    open spec fn view(&self) -> Self::V { SpecGlobaltypeCombinator(self.0@) }
+impl View for ParsedElem1Combinator {
+    type V = SpecParsedElem1Combinator;
+    open spec fn view(&self) -> Self::V { SpecParsedElem1Combinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GlobaltypeCombinator {
-    type Type = Globaltype;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem1Combinator {
+    type Type = ParsedElem1;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type GlobaltypeCombinatorAlias = Mapped<GlobaltypeCombinator1, GlobaltypeMapper>;
+}
+pub type ParsedElem1CombinatorAlias = Mapped<ParsedElem1Combinator1, ParsedElem1Mapper>;
 
 
-pub open spec fn spec_globaltype() -> SpecGlobaltypeCombinator {
-    SpecGlobaltypeCombinator(
+pub open spec fn spec_parsed_elem1() -> SpecParsedElem1Combinator {
+    SpecParsedElem1Combinator(
     Mapped {
-        inner: (spec_valtype(), spec_mut_t()),
-        mapper: GlobaltypeMapper,
+        inner: (spec_ELEMKIND(), spec_funcidxs()),
+        mapper: ParsedElem1Mapper,
     })
 }
 
                 
-pub fn globaltype<'a>() -> (o: GlobaltypeCombinator)
-    ensures o@ == spec_globaltype(),
+pub fn parsed_elem1<'a>() -> (o: ParsedElem1Combinator)
+    ensures o@ == spec_parsed_elem1(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = GlobaltypeCombinator(
+    let combinator = ParsedElem1Combinator(
     Mapped {
-        inner: GlobaltypeCombinator1((valtype(), mut_t())),
-        mapper: GlobaltypeMapper,
-    });
-    assert({
-        &&& combinator@ == spec_globaltype()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: ParsedElem1Combinator1((ELEMKIND(), funcidxs())),
+        mapper: ParsedElem1Mapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_parsed_elem1()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_globaltype<'a>(input: &'a [u8]) -> (res: PResult<<GlobaltypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_parsed_elem1<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_globaltype().spec_parse(input@) == Some((n as int, v@)),
-        spec_globaltype().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_parsed_elem1().spec_parse(input@) == Some((n as int, v@)),
+        spec_parsed_elem1().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_globaltype().spec_parse(input@) is None,
-        spec_globaltype().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_parsed_elem1().spec_parse(input@) is None,
+        spec_parsed_elem1().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = globaltype();
+    let combinator = parsed_elem1();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_globaltype<'a>(v: <GlobaltypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_parsed_elem1<'a>(v: <ParsedElem1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_globaltype().wf(v@),
+        spec_parsed_elem1().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_globaltype().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_globaltype().spec_serialize(v@))
+            &&& n == spec_parsed_elem1().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem1().spec_serialize(v@))
         },
 {
-    let combinator = globaltype();
+    let combinator = parsed_elem1();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn globaltype_len<'a>(v: <GlobaltypeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn parsed_elem1_len<'a>(v: <ParsedElem1Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_globaltype().wf(v@),
-        spec_globaltype().spec_serialize(v@).len() <= usize::MAX,
+        spec_parsed_elem1().wf(v@),
+        spec_parsed_elem1().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_globaltype().spec_serialize(v@).len(),
+        serialize_len == spec_parsed_elem1().spec_serialize(v@).len(),
 {
-    let combinator = globaltype();
+    let combinator = parsed_elem1();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub enum SpecImportdesc {
-    Func(SpecTypeidx),
-    Table(SpecTabletype),
-    Mem(SpecMemtype),
-    Global(SpecGlobaltype),
+pub struct SpecParsedElem2 {
+    pub table: SpecTableidx,
+    pub offset: SpecExpr,
+    pub et: SpecELEMKIND,
+    pub init: SpecFuncidxs,
 }
 
-pub type SpecImportdescInner = Either<SpecTypeidx, Either<SpecTabletype, Either<SpecMemtype, SpecGlobaltype>>>;
+pub type SpecParsedElem2Inner = (SpecTableidx, (SpecExpr, (SpecELEMKIND, SpecFuncidxs)));
 
-impl SpecFrom<SpecImportdesc> for SpecImportdescInner {
-    open spec fn spec_from(m: SpecImportdesc) -> SpecImportdescInner {
-        match m {
-            SpecImportdesc::Func(m) => Either::Left(m),
-            SpecImportdesc::Table(m) => Either::Right(Either::Left(m)),
-            SpecImportdesc::Mem(m) => Either::Right(Either::Right(Either::Left(m))),
-            SpecImportdesc::Global(m) => Either::Right(Either::Right(Either::Right(m))),
-        }
-    }
 
+impl SpecFrom<SpecParsedElem2> for SpecParsedElem2Inner {
+    open spec fn spec_from(m: SpecParsedElem2) -> SpecParsedElem2Inner {
+        (m.table, (m.offset, (m.et, m.init)))
+    }
 }
 
-                
-impl SpecFrom<SpecImportdescInner> for SpecImportdesc {
-    open spec fn spec_from(m: SpecImportdescInner) -> SpecImportdesc {
-        match m {
-            Either::Left(m) => SpecImportdesc::Func(m),
-            Either::Right(Either::Left(m)) => SpecImportdesc::Table(m),
-            Either::Right(Either::Right(Either::Left(m))) => SpecImportdesc::Mem(m),
-            Either::Right(Either::Right(Either::Right(m))) => SpecImportdesc::Global(m),
-        }
+impl SpecFrom<SpecParsedElem2Inner> for SpecParsedElem2 {
+    open spec fn spec_from(m: SpecParsedElem2Inner) -> SpecParsedElem2 {
+        let (table, (offset, (et, init))) = m;
+        SpecParsedElem2 { table, offset, et, init }
     }
-
 }
-
-
-
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Importdesc {
-    Func(Typeidx),
-    Table(Tabletype),
-    Mem(Memtype),
-    Global(Globaltype),
-}
-
-pub type ImportdescInner = Either<Typeidx, Either<Tabletype, Either<Memtype, Globaltype>>>;
 
-pub type ImportdescInnerRef<'a> = Either<&'a Typeidx, Either<&'a Tabletype, Either<&'a Memtype, &'a Globaltype>>>;
+pub struct ParsedElem2<'a> {
+    pub table: Tableidx,
+    pub offset: Expr<'a>,
+    pub et: ELEMKIND,
+    pub init: Funcidxs,
+}
 
+impl View for ParsedElem2<'_> {
+    type V = SpecParsedElem2;
 
-impl View for Importdesc {
-    type V = SpecImportdesc;
     open spec fn view(&self) -> Self::V {
-        match self {
-            Importdesc::Func(m) => SpecImportdesc::Func(m@),
-            Importdesc::Table(m) => SpecImportdesc::Table(m@),
-            Importdesc::Mem(m) => SpecImportdesc::Mem(m@),
-            Importdesc::Global(m) => SpecImportdesc::Global(m@),
+        SpecParsedElem2 {
+            table: self.table@,
+            offset: self.offset@,
+            et: self.et@,
+            init: self.init@,
         }
     }
 }
+pub type ParsedElem2Inner<'a> = (Tableidx, (Expr<'a>, (ELEMKIND, Funcidxs)));
 
-
-impl<'a> From<&'a Importdesc> for ImportdescInnerRef<'a> {
-    fn ex_from(m: &'a Importdesc) -> ImportdescInnerRef<'a> {
-        match m {
-            Importdesc::Func(m) => Either::Left(m),
-            Importdesc::Table(m) => Either::Right(Either::Left(m)),
-            Importdesc::Mem(m) => Either::Right(Either::Right(Either::Left(m))),
-            Importdesc::Global(m) => Either::Right(Either::Right(Either::Right(m))),
-        }
+pub type ParsedElem2InnerRef<'a> = (&'a Tableidx, (&'a Expr<'a>, (&'a ELEMKIND, &'a Funcidxs)));
+impl<'a> From<&'a ParsedElem2<'a>> for ParsedElem2InnerRef<'a> {
+    fn ex_from(m: &'a ParsedElem2) -> ParsedElem2InnerRef<'a> {
+        (&m.table, (&m.offset, (&m.et, &m.init)))
     }
-
 }
 
-impl From<ImportdescInner> for Importdesc {
-    fn ex_from(m: ImportdescInner) -> Importdesc {
-        match m {
-            Either::Left(m) => Importdesc::Func(m),
-            Either::Right(Either::Left(m)) => Importdesc::Table(m),
-            Either::Right(Either::Right(Either::Left(m))) => Importdesc::Mem(m),
-            Either::Right(Either::Right(Either::Right(m))) => Importdesc::Global(m),
-        }
+impl<'a> From<ParsedElem2Inner<'a>> for ParsedElem2<'a> {
+    fn ex_from(m: ParsedElem2Inner) -> ParsedElem2 {
+        let (table, (offset, (et, init))) = m;
+        ParsedElem2 { table, offset, et, init }
     }
-    
 }
 
-
-pub struct ImportdescMapper;
-impl View for ImportdescMapper {
+pub struct ParsedElem2Mapper;
+impl View for ParsedElem2Mapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ImportdescMapper {
-    type Src = SpecImportdescInner;
-    type Dst = SpecImportdesc;
+impl SpecIso for ParsedElem2Mapper {
+    type Src = SpecParsedElem2Inner;
+    type Dst = SpecParsedElem2;
 }
-impl SpecIsoProof for ImportdescMapper {
+impl SpecIsoProof for ParsedElem2Mapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -20030,448 +20153,342 @@ impl SpecIsoProof for ImportdescMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ImportdescMapper {
-    type Src = ImportdescInner;
-    type Dst = Importdesc;
-    type RefSrc = ImportdescInnerRef<'a>;
+impl<'a> Iso<'a> for ParsedElem2Mapper {
+    type Src = ParsedElem2Inner<'a>;
+    type Dst = ParsedElem2<'a>;
+    type RefSrc = ParsedElem2InnerRef<'a>;
 }
+type SpecParsedElem2CombinatorAlias1 = (SpecELEMKINDCombinator, SpecFuncidxsCombinator);
+type SpecParsedElem2CombinatorAlias2 = (SpecExprCombinator, SpecParsedElem2CombinatorAlias1);
+type SpecParsedElem2CombinatorAlias3 = (SpecTableidxCombinator, SpecParsedElem2CombinatorAlias2);
+pub struct SpecParsedElem2Combinator(pub SpecParsedElem2CombinatorAlias);
 
-pub const IMPORTDESCFUNC_0_FRONT_CONST: u8 = 0;
-
-pub const IMPORTDESCTABLE_0_FRONT_CONST: u8 = 1;
-
-pub const IMPORTDESCMEM_0_FRONT_CONST: u8 = 2;
-
-pub const IMPORTDESCGLOBAL_0_FRONT_CONST: u8 = 3;
-
-type SpecImportdescCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, SpecMemtypeCombinator>, Preceded<Tag<U8, u8>, SpecGlobaltypeCombinator>>;
-type SpecImportdescCombinatorAlias2 = Choice<Preceded<Tag<U8, u8>, SpecTabletypeCombinator>, SpecImportdescCombinatorAlias1>;
-type SpecImportdescCombinatorAlias3 = Choice<Preceded<Tag<U8, u8>, SpecTypeidxCombinator>, SpecImportdescCombinatorAlias2>;
-pub struct SpecImportdescCombinator(pub SpecImportdescCombinatorAlias);
-
-impl SpecCombinator for SpecImportdescCombinator {
-    type Type = SpecImportdesc;
+impl SpecCombinator for SpecParsedElem2Combinator {
+    type Type = SpecParsedElem2;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecImportdescCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecImportdescCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecParsedElem2Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecParsedElem2CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecImportdescCombinatorAlias = Mapped<SpecImportdescCombinatorAlias3, ImportdescMapper>;
-
-
-
-
-type ImportdescCombinatorAlias1 = Choice<Preceded<Tag<U8, u8>, MemtypeCombinator>, Preceded<Tag<U8, u8>, GlobaltypeCombinator>>;
-type ImportdescCombinatorAlias2 = Choice<Preceded<Tag<U8, u8>, TabletypeCombinator>, ImportdescCombinator1>;
-type ImportdescCombinatorAlias3 = Choice<Preceded<Tag<U8, u8>, TypeidxCombinator>, ImportdescCombinator2>;
-pub struct ImportdescCombinator1(pub ImportdescCombinatorAlias1);
-impl View for ImportdescCombinator1 {
-    type V = SpecImportdescCombinatorAlias1;
+pub type SpecParsedElem2CombinatorAlias = Mapped<SpecParsedElem2CombinatorAlias3, ParsedElem2Mapper>;
+type ParsedElem2CombinatorAlias1 = (ELEMKINDCombinator, FuncidxsCombinator);
+type ParsedElem2CombinatorAlias2 = (ExprCombinator, ParsedElem2Combinator1);
+type ParsedElem2CombinatorAlias3 = (TableidxCombinator, ParsedElem2Combinator2);
+pub struct ParsedElem2Combinator1(pub ParsedElem2CombinatorAlias1);
+impl View for ParsedElem2Combinator1 {
+    type V = SpecParsedElem2CombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ImportdescCombinator1, ImportdescCombinatorAlias1);
-
-pub struct ImportdescCombinator2(pub ImportdescCombinatorAlias2);
-impl View for ImportdescCombinator2 {
-    type V = SpecImportdescCombinatorAlias2;
+impl_wrapper_combinator!(ParsedElem2Combinator1, ParsedElem2CombinatorAlias1);
+
+pub struct ParsedElem2Combinator2(pub ParsedElem2CombinatorAlias2);
+impl View for ParsedElem2Combinator2 {
+    type V = SpecParsedElem2CombinatorAlias2;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ImportdescCombinator2, ImportdescCombinatorAlias2);
+impl_wrapper_combinator!(ParsedElem2Combinator2, ParsedElem2CombinatorAlias2);
 
-pub struct ImportdescCombinator3(pub ImportdescCombinatorAlias3);
-impl View for ImportdescCombinator3 {
-    type V = SpecImportdescCombinatorAlias3;
+pub struct ParsedElem2Combinator3(pub ParsedElem2CombinatorAlias3);
+impl View for ParsedElem2Combinator3 {
+    type V = SpecParsedElem2CombinatorAlias3;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ImportdescCombinator3, ImportdescCombinatorAlias3);
+impl_wrapper_combinator!(ParsedElem2Combinator3, ParsedElem2CombinatorAlias3);
 
-pub struct ImportdescCombinator(pub ImportdescCombinatorAlias);
+pub struct ParsedElem2Combinator(pub ParsedElem2CombinatorAlias);
 
-impl View for ImportdescCombinator {
-    type V = SpecImportdescCombinator;
-    open spec fn view(&self) -> Self::V { SpecImportdescCombinator(self.0@) }
+impl View for ParsedElem2Combinator {
+    type V = SpecParsedElem2Combinator;
+    open spec fn view(&self) -> Self::V { SpecParsedElem2Combinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ImportdescCombinator {
-    type Type = Importdesc;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem2Combinator {
+    type Type = ParsedElem2<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ImportdescCombinatorAlias = Mapped<ImportdescCombinator3, ImportdescMapper>;
+}
+pub type ParsedElem2CombinatorAlias = Mapped<ParsedElem2Combinator3, ParsedElem2Mapper>;
 
 
-pub open spec fn spec_importdesc() -> SpecImportdescCombinator {
-    SpecImportdescCombinator(Mapped { inner: Choice(Preceded(Tag::spec_new(U8, IMPORTDESCFUNC_0_FRONT_CONST), spec_typeidx()), Choice(Preceded(Tag::spec_new(U8, IMPORTDESCTABLE_0_FRONT_CONST), spec_tabletype()), Choice(Preceded(Tag::spec_new(U8, IMPORTDESCMEM_0_FRONT_CONST), spec_memtype()), Preceded(Tag::spec_new(U8, IMPORTDESCGLOBAL_0_FRONT_CONST), spec_globaltype())))), mapper: ImportdescMapper })
+pub open spec fn spec_parsed_elem2() -> SpecParsedElem2Combinator {
+    SpecParsedElem2Combinator(
+    Mapped {
+        inner: (spec_tableidx(), (spec_expr(), (spec_ELEMKIND(), spec_funcidxs()))),
+        mapper: ParsedElem2Mapper,
+    })
 }
 
                 
-pub fn importdesc<'a>() -> (o: ImportdescCombinator)
-    ensures o@ == spec_importdesc(),
+pub fn parsed_elem2<'a>() -> (o: ParsedElem2Combinator)
+    ensures o@ == spec_parsed_elem2(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ImportdescCombinator(Mapped { inner: ImportdescCombinator3(Choice::new(Preceded(Tag::new(U8, IMPORTDESCFUNC_0_FRONT_CONST), typeidx()), ImportdescCombinator2(Choice::new(Preceded(Tag::new(U8, IMPORTDESCTABLE_0_FRONT_CONST), tabletype()), ImportdescCombinator1(Choice::new(Preceded(Tag::new(U8, IMPORTDESCMEM_0_FRONT_CONST), memtype()), Preceded(Tag::new(U8, IMPORTDESCGLOBAL_0_FRONT_CONST), globaltype()))))))), mapper: ImportdescMapper });
-    assert({
-        &&& combinator@ == spec_importdesc()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ParsedElem2Combinator(
+    Mapped {
+        inner: ParsedElem2Combinator3((tableidx(), ParsedElem2Combinator2((expr(), ParsedElem2Combinator1((ELEMKIND(), funcidxs())))))),
+        mapper: ParsedElem2Mapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_parsed_elem2()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_importdesc<'a>(input: &'a [u8]) -> (res: PResult<<ImportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_parsed_elem2<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_importdesc().spec_parse(input@) == Some((n as int, v@)),
-        spec_importdesc().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_parsed_elem2().spec_parse(input@) == Some((n as int, v@)),
+        spec_parsed_elem2().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_importdesc().spec_parse(input@) is None,
-        spec_importdesc().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_parsed_elem2().spec_parse(input@) is None,
+        spec_parsed_elem2().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = importdesc();
+    let combinator = parsed_elem2();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_importdesc<'a>(v: <ImportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_parsed_elem2<'a>(v: <ParsedElem2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_importdesc().wf(v@),
+        spec_parsed_elem2().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_importdesc().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_importdesc().spec_serialize(v@))
+            &&& n == spec_parsed_elem2().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem2().spec_serialize(v@))
         },
 {
-    let combinator = importdesc();
+    let combinator = parsed_elem2();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn importdesc_len<'a>(v: <ImportdescCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn parsed_elem2_len<'a>(v: <ParsedElem2Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_importdesc().wf(v@),
-        spec_importdesc().spec_serialize(v@).len() <= usize::MAX,
+        spec_parsed_elem2().wf(v@),
+        spec_parsed_elem2().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_importdesc().spec_serialize(v@).len(),
+        serialize_len == spec_parsed_elem2().spec_serialize(v@).len(),
 {
-    let combinator = importdesc();
+    let combinator = parsed_elem2();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
+pub type SpecParsedElem3 = SpecParsedElem1;
+pub type ParsedElem3 = ParsedElem1;
+pub type ParsedElem3Ref<'a> = &'a ParsedElem1;
 
-pub struct SpecImport {
-    pub module: SpecName,
-    pub name: SpecName,
-    pub desc: SpecImportdesc,
-}
-
-pub type SpecImportInner = (SpecName, (SpecName, SpecImportdesc));
-
-
-impl SpecFrom<SpecImport> for SpecImportInner {
-    open spec fn spec_from(m: SpecImport) -> SpecImportInner {
-        (m.module, (m.name, m.desc))
-    }
-}
-
-impl SpecFrom<SpecImportInner> for SpecImport {
-    open spec fn spec_from(m: SpecImportInner) -> SpecImport {
-        let (module, (name, desc)) = m;
-        SpecImport { module, name, desc }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct Import {
-    pub module: Name,
-    pub name: Name,
-    pub desc: Importdesc,
-}
-
-impl View for Import {
-    type V = SpecImport;
-
-    open spec fn view(&self) -> Self::V {
-        SpecImport {
-            module: self.module@,
-            name: self.name@,
-            desc: self.desc@,
-        }
-    }
-}
-pub type ImportInner = (Name, (Name, Importdesc));
-
-pub type ImportInnerRef<'a> = (&'a Name, (&'a Name, &'a Importdesc));
-impl<'a> From<&'a Import> for ImportInnerRef<'a> {
-    fn ex_from(m: &'a Import) -> ImportInnerRef<'a> {
-        (&m.module, (&m.name, &m.desc))
-    }
-}
-
-impl From<ImportInner> for Import {
-    fn ex_from(m: ImportInner) -> Import {
-        let (module, (name, desc)) = m;
-        Import { module, name, desc }
-    }
-}
 
-pub struct ImportMapper;
-impl View for ImportMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ImportMapper {
-    type Src = SpecImportInner;
-    type Dst = SpecImport;
-}
-impl SpecIsoProof for ImportMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for ImportMapper {
-    type Src = ImportInner;
-    type Dst = Import;
-    type RefSrc = ImportInnerRef<'a>;
-}
-type SpecImportCombinatorAlias1 = (SpecNameCombinator, SpecImportdescCombinator);
-type SpecImportCombinatorAlias2 = (SpecNameCombinator, SpecImportCombinatorAlias1);
-pub struct SpecImportCombinator(pub SpecImportCombinatorAlias);
+pub struct SpecParsedElem3Combinator(pub SpecParsedElem3CombinatorAlias);
 
-impl SpecCombinator for SpecImportCombinator {
-    type Type = SpecImport;
+impl SpecCombinator for SpecParsedElem3Combinator {
+    type Type = SpecParsedElem3;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecImportCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecImportCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecParsedElem3Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecParsedElem3CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecImportCombinatorAlias = Mapped<SpecImportCombinatorAlias2, ImportMapper>;
-type ImportCombinatorAlias1 = (NameCombinator, ImportdescCombinator);
-type ImportCombinatorAlias2 = (NameCombinator, ImportCombinator1);
-pub struct ImportCombinator1(pub ImportCombinatorAlias1);
-impl View for ImportCombinator1 {
-    type V = SpecImportCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ImportCombinator1, ImportCombinatorAlias1);
-
-pub struct ImportCombinator2(pub ImportCombinatorAlias2);
-impl View for ImportCombinator2 {
-    type V = SpecImportCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ImportCombinator2, ImportCombinatorAlias2);
+pub type SpecParsedElem3CombinatorAlias = SpecParsedElem1Combinator;
 
-pub struct ImportCombinator(pub ImportCombinatorAlias);
+pub struct ParsedElem3Combinator(pub ParsedElem3CombinatorAlias);
 
-impl View for ImportCombinator {
-    type V = SpecImportCombinator;
-    open spec fn view(&self) -> Self::V { SpecImportCombinator(self.0@) }
+impl View for ParsedElem3Combinator {
+    type V = SpecParsedElem3Combinator;
+    open spec fn view(&self) -> Self::V { SpecParsedElem3Combinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ImportCombinator {
-    type Type = Import;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem3Combinator {
+    type Type = ParsedElem3;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ImportCombinatorAlias = Mapped<ImportCombinator2, ImportMapper>;
+}
+pub type ParsedElem3CombinatorAlias = ParsedElem1Combinator;
 
 
-pub open spec fn spec_import() -> SpecImportCombinator {
-    SpecImportCombinator(
-    Mapped {
-        inner: (spec_name(), (spec_name(), spec_importdesc())),
-        mapper: ImportMapper,
-    })
+pub open spec fn spec_parsed_elem3() -> SpecParsedElem3Combinator {
+    SpecParsedElem3Combinator(spec_parsed_elem1())
 }
 
                 
-pub fn import<'a>() -> (o: ImportCombinator)
-    ensures o@ == spec_import(),
+pub fn parsed_elem3<'a>() -> (o: ParsedElem3Combinator)
+    ensures o@ == spec_parsed_elem3(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ImportCombinator(
-    Mapped {
-        inner: ImportCombinator2((name(), ImportCombinator1((name(), importdesc())))),
-        mapper: ImportMapper,
-    });
-    assert({
-        &&& combinator@ == spec_import()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ParsedElem3Combinator(parsed_elem1());
+    // assert({
+    //     &&& combinator@ == spec_parsed_elem3()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_import<'a>(input: &'a [u8]) -> (res: PResult<<ImportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_parsed_elem3<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem3Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_import().spec_parse(input@) == Some((n as int, v@)),
-        spec_import().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_parsed_elem3().spec_parse(input@) == Some((n as int, v@)),
+        spec_parsed_elem3().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_import().spec_parse(input@) is None,
-        spec_import().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_parsed_elem3().spec_parse(input@) is None,
+        spec_parsed_elem3().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = import();
+    let combinator = parsed_elem3();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_import<'a>(v: <ImportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_parsed_elem3<'a>(v: <ParsedElem3Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_import().wf(v@),
+        spec_parsed_elem3().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_import().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_import().spec_serialize(v@))
+            &&& n == spec_parsed_elem3().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem3().spec_serialize(v@))
         },
 {
-    let combinator = import();
+    let combinator = parsed_elem3();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn import_len<'a>(v: <ImportCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn parsed_elem3_len<'a>(v: <ParsedElem3Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_import().wf(v@),
-        spec_import().spec_serialize(v@).len() <= usize::MAX,
+        spec_parsed_elem3().wf(v@),
+        spec_parsed_elem3().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_import().spec_serialize(v@).len(),
+        serialize_len == spec_parsed_elem3().spec_serialize(v@).len(),
 {
-    let combinator = import();
+    let combinator = parsed_elem3();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecImports {
+pub struct SpecExprs {
     pub l: u64,
-    pub v: Seq<SpecImport>,
+    pub v: Seq<SpecExpr>,
 }
 
-pub type SpecImportsInner = (u64, Seq<SpecImport>);
+pub type SpecExprsInner = (u64, Seq<SpecExpr>);
 
 
-impl SpecFrom<SpecImports> for SpecImportsInner {
-    open spec fn spec_from(m: SpecImports) -> SpecImportsInner {
+impl SpecFrom<SpecExprs> for SpecExprsInner {
+    open spec fn spec_from(m: SpecExprs) -> SpecExprsInner {
         (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecImportsInner> for SpecImports {
-    open spec fn spec_from(m: SpecImportsInner) -> SpecImports {
+impl SpecFrom<SpecExprsInner> for SpecExprs {
+    open spec fn spec_from(m: SpecExprsInner) -> SpecExprs {
         let (l, v) = m;
-        SpecImports { l, v }
+        SpecExprs { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Imports {
+pub struct Exprs<'a> {
     pub l: u64,
-    pub v: RepeatResult<Import>,
+    pub v: RepeatResult<Expr<'a>>,
 }
 
-impl View for Imports {
-    type V = SpecImports;
+impl View for Exprs<'_> {
+    type V = SpecExprs;
 
     open spec fn view(&self) -> Self::V {
-        SpecImports {
+        SpecExprs {
             l: self.l@,
             v: self.v@,
         }
     }
 }
-pub type ImportsInner = (u64, RepeatResult<Import>);
+pub type ExprsInner<'a> = (u64, RepeatResult<Expr<'a>>);
 
-pub type ImportsInnerRef<'a> = (&'a u64, &'a RepeatResult<Import>);
-impl<'a> From<&'a Imports> for ImportsInnerRef<'a> {
-    fn ex_from(m: &'a Imports) -> ImportsInnerRef<'a> {
+pub type ExprsInnerRef<'a> = (&'a u64, &'a RepeatResult<Expr<'a>>);
+impl<'a> From<&'a Exprs<'a>> for ExprsInnerRef<'a> {
+    fn ex_from(m: &'a Exprs) -> ExprsInnerRef<'a> {
         (&m.l, &m.v)
     }
 }
 
-impl From<ImportsInner> for Imports {
-    fn ex_from(m: ImportsInner) -> Imports {
+impl<'a> From<ExprsInner<'a>> for Exprs<'a> {
+    fn ex_from(m: ExprsInner) -> Exprs {
         let (l, v) = m;
-        Imports { l, v }
+        Exprs { l, v }
     }
 }
 
-pub struct ImportsMapper;
-impl View for ImportsMapper {
+pub struct ExprsMapper;
+impl View for ExprsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ImportsMapper {
-    type Src = SpecImportsInner;
-    type Dst = SpecImports;
+impl SpecIso for ExprsMapper {
+    type Src = SpecExprsInner;
+    type Dst = SpecExprs;
 }
-impl SpecIsoProof for ImportsMapper {
+impl SpecIsoProof for ExprsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -20479,241 +20496,245 @@ impl SpecIsoProof for ImportsMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ImportsMapper {
-    type Src = ImportsInner;
-    type Dst = Imports;
-    type RefSrc = ImportsInnerRef<'a>;
+impl<'a> Iso<'a> for ExprsMapper {
+    type Src = ExprsInner<'a>;
+    type Dst = Exprs<'a>;
+    type RefSrc = ExprsInnerRef<'a>;
 }
 
-pub struct SpecImportsCombinator(pub SpecImportsCombinatorAlias);
+pub struct SpecExprsCombinator(pub SpecExprsCombinatorAlias);
 
-impl SpecCombinator for SpecImportsCombinator {
-    type Type = SpecImports;
+impl SpecCombinator for SpecExprsCombinator {
+    type Type = SpecExprs;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecImportsCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecImportsCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecExprsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecExprsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecImportsCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecImportCombinator>>, ImportsMapper>;
+pub type SpecExprsCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecExprCombinator>>, ExprsMapper>;
 
-pub struct ImportsCombinator(pub ImportsCombinatorAlias);
+pub struct ExprsCombinator(pub ExprsCombinatorAlias);
 
-impl View for ImportsCombinator {
-    type V = SpecImportsCombinator;
-    open spec fn view(&self) -> Self::V { SpecImportsCombinator(self.0@) }
+impl View for ExprsCombinator {
+    type V = SpecExprsCombinator;
+    open spec fn view(&self) -> Self::V { SpecExprsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ImportsCombinator {
-    type Type = Imports;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ExprsCombinator {
+    type Type = Exprs<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ImportsCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ImportCombinator>, ImportsCont0>, ImportsMapper>;
+}
+pub type ExprsCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ExprCombinator>, ExprsCont0>, ExprsMapper>;
 
 
-pub open spec fn spec_imports() -> SpecImportsCombinator {
-    SpecImportsCombinator(
+pub open spec fn spec_exprs() -> SpecExprsCombinator {
+    SpecExprsCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_imports_cont0(deps)),
-        mapper: ImportsMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_exprs_cont0(deps)),
+        mapper: ExprsMapper,
     })
 }
 
-pub open spec fn spec_imports_cont0(deps: u64) -> RepeatN<SpecImportCombinator> {
+pub open spec fn spec_exprs_cont0(deps: u64) -> RepeatN<SpecExprCombinator> {
     let l = deps;
-    RepeatN(spec_import(), l.spec_into())
+    RepeatN(spec_expr(), (usize::spec_from(l)) as usize)
 }
 
-impl View for ImportsCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecImportCombinator>;
+impl View for ExprsCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecExprCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_imports_cont0(deps)
+            spec_exprs_cont0(deps)
         }
     }
 }
 
                 
-pub fn imports<'a>() -> (o: ImportsCombinator)
-    ensures o@ == spec_imports(),
+pub fn exprs<'a>() -> (o: ExprsCombinator)
+    ensures o@ == spec_exprs(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ImportsCombinator(
+    let combinator = ExprsCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, ImportsCont0),
-        mapper: ImportsMapper,
-    });
-    assert({
-        &&& combinator@ == spec_imports()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, ExprsCont0),
+        mapper: ExprsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_exprs()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_imports<'a>(input: &'a [u8]) -> (res: PResult<<ImportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_exprs<'a>(input: &'a [u8]) -> (res: PResult<<ExprsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_imports().spec_parse(input@) == Some((n as int, v@)),
-        spec_imports().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_exprs().spec_parse(input@) == Some((n as int, v@)),
+        spec_exprs().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_imports().spec_parse(input@) is None,
-        spec_imports().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_exprs().spec_parse(input@) is None,
+        spec_exprs().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = imports();
+    let combinator = exprs();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_imports<'a>(v: <ImportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_exprs<'a>(v: <ExprsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_imports().wf(v@),
+        spec_exprs().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_imports().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_imports().spec_serialize(v@))
+            &&& n == spec_exprs().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_exprs().spec_serialize(v@))
         },
 {
-    let combinator = imports();
+    let combinator = exprs();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn imports_len<'a>(v: <ImportsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn exprs_len<'a>(v: <ExprsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_imports().wf(v@),
-        spec_imports().spec_serialize(v@).len() <= usize::MAX,
+        spec_exprs().wf(v@),
+        spec_exprs().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_imports().spec_serialize(v@).len(),
+        serialize_len == spec_exprs().spec_serialize(v@).len(),
 {
-    let combinator = imports();
+    let combinator = exprs();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ImportsCont0;
-type ImportsCont0Type<'a, 'b> = &'b u64;
-type ImportsCont0SType<'a, 'x> = &'x u64;
-type ImportsCont0Input<'a, 'b, 'x> = POrSType<ImportsCont0Type<'a, 'b>, ImportsCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ImportsCont0Input<'a, 'b, 'x>> for ImportsCont0 {
-    type Output = RepeatN<ImportCombinator>;
+pub struct ExprsCont0;
+type ExprsCont0Type<'a, 'b> = &'b u64;
+type ExprsCont0SType<'a, 'x> = &'x u64;
+type ExprsCont0Input<'a, 'b, 'x> = POrSType<ExprsCont0Type<'a, 'b>, ExprsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ExprsCont0Input<'a, 'b, 'x>> for ExprsCont0 {
+    type Output = RepeatN<ExprCombinator>;
 
-    open spec fn requires(&self, deps: ImportsCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: ExprsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: ImportsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_imports_cont0(deps@)
+    open spec fn ensures(&self, deps: ExprsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_exprs_cont0(deps@)
     }
 
-    fn apply(&self, deps: ImportsCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: ExprsCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(import(), l.ex_into())
+                let l = deps;
+                let l = *l;
+                RepeatN(expr(), (usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
                 let l = deps;
                 let l = *l;
-                RepeatN(import(), l.ex_into())
+                RepeatN(expr(), (usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
 
-pub struct SpecTypesecContent {
-    pub l: u64,
-    pub v: Seq<SpecFunctype>,
+pub struct SpecParsedElem4 {
+    pub offset: SpecExpr,
+    pub init: SpecExprs,
 }
 
-pub type SpecTypesecContentInner = (u64, Seq<SpecFunctype>);
+pub type SpecParsedElem4Inner = (SpecExpr, SpecExprs);
 
 
-impl SpecFrom<SpecTypesecContent> for SpecTypesecContentInner {
-    open spec fn spec_from(m: SpecTypesecContent) -> SpecTypesecContentInner {
-        (m.l, m.v)
+impl SpecFrom<SpecParsedElem4> for SpecParsedElem4Inner {
+    open spec fn spec_from(m: SpecParsedElem4) -> SpecParsedElem4Inner {
+        (m.offset, m.init)
     }
 }
 
-impl SpecFrom<SpecTypesecContentInner> for SpecTypesecContent {
-    open spec fn spec_from(m: SpecTypesecContentInner) -> SpecTypesecContent {
-        let (l, v) = m;
-        SpecTypesecContent { l, v }
+impl SpecFrom<SpecParsedElem4Inner> for SpecParsedElem4 {
+    open spec fn spec_from(m: SpecParsedElem4Inner) -> SpecParsedElem4 {
+        let (offset, init) = m;
+        SpecParsedElem4 { offset, init }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct TypesecContent {
-    pub l: u64,
-    pub v: RepeatResult<Functype>,
+pub struct ParsedElem4<'a> {
+    pub offset: Expr<'a>,
+    pub init: Exprs<'a>,
 }
 
-impl View for TypesecContent {
-    type V = SpecTypesecContent;
+impl View for ParsedElem4<'_> {
+    type V = SpecParsedElem4;
 
     open spec fn view(&self) -> Self::V {
-        SpecTypesecContent {
-            l: self.l@,
-            v: self.v@,
+        SpecParsedElem4 {
+            offset: self.offset@,
+            init: self.init@,
         }
     }
 }
-pub type TypesecContentInner = (u64, RepeatResult<Functype>);
+pub type ParsedElem4Inner<'a> = (Expr<'a>, Exprs<'a>);
 
-pub type TypesecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Functype>);
-impl<'a> From<&'a TypesecContent> for TypesecContentInnerRef<'a> {
-    fn ex_from(m: &'a TypesecContent) -> TypesecContentInnerRef<'a> {
-        (&m.l, &m.v)
+pub type ParsedElem4InnerRef<'a> = (&'a Expr<'a>, &'a Exprs<'a>);
+impl<'a> From<&'a ParsedElem4<'a>> for ParsedElem4InnerRef<'a> {
+    fn ex_from(m: &'a ParsedElem4) -> ParsedElem4InnerRef<'a> {
+        (&m.offset, &m.init)
     }
 }
 
-impl From<TypesecContentInner> for TypesecContent {
-    fn ex_from(m: TypesecContentInner) -> TypesecContent {
-        let (l, v) = m;
-        TypesecContent { l, v }
+impl<'a> From<ParsedElem4Inner<'a>> for ParsedElem4<'a> {
+    fn ex_from(m: ParsedElem4Inner) -> ParsedElem4 {
+        let (offset, init) = m;
+        ParsedElem4 { offset, init }
     }
 }
 
-pub struct TypesecContentMapper;
-impl View for TypesecContentMapper {
+pub struct ParsedElem4Mapper;
+impl View for ParsedElem4Mapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for TypesecContentMapper {
-    type Src = SpecTypesecContentInner;
-    type Dst = SpecTypesecContent;
+impl SpecIso for ParsedElem4Mapper {
+    type Src = SpecParsedElem4Inner;
+    type Dst = SpecParsedElem4;
 }
-impl SpecIsoProof for TypesecContentMapper {
+impl SpecIsoProof for ParsedElem4Mapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -20721,238 +20742,206 @@ impl SpecIsoProof for TypesecContentMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for TypesecContentMapper {
-    type Src = TypesecContentInner;
-    type Dst = TypesecContent;
-    type RefSrc = TypesecContentInnerRef<'a>;
+impl<'a> Iso<'a> for ParsedElem4Mapper {
+    type Src = ParsedElem4Inner<'a>;
+    type Dst = ParsedElem4<'a>;
+    type RefSrc = ParsedElem4InnerRef<'a>;
 }
+type SpecParsedElem4CombinatorAlias1 = (SpecExprCombinator, SpecExprsCombinator);
+pub struct SpecParsedElem4Combinator(pub SpecParsedElem4CombinatorAlias);
 
-pub struct SpecTypesecContentCombinator(pub SpecTypesecContentCombinatorAlias);
-
-impl SpecCombinator for SpecTypesecContentCombinator {
-    type Type = SpecTypesecContent;
+impl SpecCombinator for SpecParsedElem4Combinator {
+    type Type = SpecParsedElem4;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTypesecContentCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTypesecContentCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecParsedElem4Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecParsedElem4CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTypesecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecFunctypeCombinator>>, TypesecContentMapper>;
+pub type SpecParsedElem4CombinatorAlias = Mapped<SpecParsedElem4CombinatorAlias1, ParsedElem4Mapper>;
+type ParsedElem4CombinatorAlias1 = (ExprCombinator, ExprsCombinator);
+pub struct ParsedElem4Combinator1(pub ParsedElem4CombinatorAlias1);
+impl View for ParsedElem4Combinator1 {
+    type V = SpecParsedElem4CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ParsedElem4Combinator1, ParsedElem4CombinatorAlias1);
 
-pub struct TypesecContentCombinator(pub TypesecContentCombinatorAlias);
+pub struct ParsedElem4Combinator(pub ParsedElem4CombinatorAlias);
 
-impl View for TypesecContentCombinator {
-    type V = SpecTypesecContentCombinator;
-    open spec fn view(&self) -> Self::V { SpecTypesecContentCombinator(self.0@) }
+impl View for ParsedElem4Combinator {
+    type V = SpecParsedElem4Combinator;
+    open spec fn view(&self) -> Self::V { SpecParsedElem4Combinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TypesecContentCombinator {
-    type Type = TypesecContent;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem4Combinator {
+    type Type = ParsedElem4<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TypesecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<FunctypeCombinator>, TypesecContentCont0>, TypesecContentMapper>;
+}
+pub type ParsedElem4CombinatorAlias = Mapped<ParsedElem4Combinator1, ParsedElem4Mapper>;
 
 
-pub open spec fn spec_typesec_content() -> SpecTypesecContentCombinator {
-    SpecTypesecContentCombinator(
+pub open spec fn spec_parsed_elem4() -> SpecParsedElem4Combinator {
+    SpecParsedElem4Combinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_typesec_content_cont0(deps)),
-        mapper: TypesecContentMapper,
+        inner: (spec_expr(), spec_exprs()),
+        mapper: ParsedElem4Mapper,
     })
 }
 
-pub open spec fn spec_typesec_content_cont0(deps: u64) -> RepeatN<SpecFunctypeCombinator> {
-    let l = deps;
-    RepeatN(spec_functype(), l.spec_into())
-}
-
-impl View for TypesecContentCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecFunctypeCombinator>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_typesec_content_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn typesec_content<'a>() -> (o: TypesecContentCombinator)
-    ensures o@ == spec_typesec_content(),
+pub fn parsed_elem4<'a>() -> (o: ParsedElem4Combinator)
+    ensures o@ == spec_parsed_elem4(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = TypesecContentCombinator(
+    let combinator = ParsedElem4Combinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, TypesecContentCont0),
-        mapper: TypesecContentMapper,
-    });
-    assert({
-        &&& combinator@ == spec_typesec_content()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: ParsedElem4Combinator1((expr(), exprs())),
+        mapper: ParsedElem4Mapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_parsed_elem4()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_typesec_content<'a>(input: &'a [u8]) -> (res: PResult<<TypesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_parsed_elem4<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_typesec_content().spec_parse(input@) == Some((n as int, v@)),
-        spec_typesec_content().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_parsed_elem4().spec_parse(input@) == Some((n as int, v@)),
+        spec_parsed_elem4().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_typesec_content().spec_parse(input@) is None,
-        spec_typesec_content().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_parsed_elem4().spec_parse(input@) is None,
+        spec_parsed_elem4().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = typesec_content();
+    let combinator = parsed_elem4();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_typesec_content<'a>(v: <TypesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_parsed_elem4<'a>(v: <ParsedElem4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_typesec_content().wf(v@),
+        spec_parsed_elem4().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_typesec_content().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_typesec_content().spec_serialize(v@))
+            &&& n == spec_parsed_elem4().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem4().spec_serialize(v@))
         },
 {
-    let combinator = typesec_content();
+    let combinator = parsed_elem4();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn typesec_content_len<'a>(v: <TypesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn parsed_elem4_len<'a>(v: <ParsedElem4Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_typesec_content().wf(v@),
-        spec_typesec_content().spec_serialize(v@).len() <= usize::MAX,
+        spec_parsed_elem4().wf(v@),
+        spec_parsed_elem4().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_typesec_content().spec_serialize(v@).len(),
+        serialize_len == spec_parsed_elem4().spec_serialize(v@).len(),
 {
-    let combinator = typesec_content();
+    let combinator = parsed_elem4();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct TypesecContentCont0;
-type TypesecContentCont0Type<'a, 'b> = &'b u64;
-type TypesecContentCont0SType<'a, 'x> = &'x u64;
-type TypesecContentCont0Input<'a, 'b, 'x> = POrSType<TypesecContentCont0Type<'a, 'b>, TypesecContentCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<TypesecContentCont0Input<'a, 'b, 'x>> for TypesecContentCont0 {
-    type Output = RepeatN<FunctypeCombinator>;
-
-    open spec fn requires(&self, deps: TypesecContentCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: TypesecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_typesec_content_cont0(deps@)
-    }
-
-    fn apply(&self, deps: TypesecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(functype(), l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(functype(), l.ex_into())
-            }
-        }
-    }
-}
                 
 
-pub struct SpecMem {
-    pub ty: SpecMemtype,
+pub struct SpecParsedElem5 {
+    pub et: SpecReftype,
+    pub init: SpecExprs,
 }
 
-pub type SpecMemInner = SpecMemtype;
+pub type SpecParsedElem5Inner = (SpecReftype, SpecExprs);
 
 
-impl SpecFrom<SpecMem> for SpecMemInner {
-    open spec fn spec_from(m: SpecMem) -> SpecMemInner {
-        m.ty
+impl SpecFrom<SpecParsedElem5> for SpecParsedElem5Inner {
+    open spec fn spec_from(m: SpecParsedElem5) -> SpecParsedElem5Inner {
+        (m.et, m.init)
     }
 }
 
-impl SpecFrom<SpecMemInner> for SpecMem {
-    open spec fn spec_from(m: SpecMemInner) -> SpecMem {
-        let ty = m;
-        SpecMem { ty }
+impl SpecFrom<SpecParsedElem5Inner> for SpecParsedElem5 {
+    open spec fn spec_from(m: SpecParsedElem5Inner) -> SpecParsedElem5 {
+        let (et, init) = m;
+        SpecParsedElem5 { et, init }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Mem {
-    pub ty: Memtype,
+pub struct ParsedElem5<'a> {
+    pub et: Reftype,
+    pub init: Exprs<'a>,
 }
 
-impl View for Mem {
-    type V = SpecMem;
+impl View for ParsedElem5<'_> {
+    type V = SpecParsedElem5;
 
     open spec fn view(&self) -> Self::V {
-        SpecMem {
-            ty: self.ty@,
+        SpecParsedElem5 {
+            et: self.et@,
+            init: self.init@,
         }
     }
 }
-pub type MemInner = Memtype;
+pub type ParsedElem5Inner<'a> = (Reftype, Exprs<'a>);
 
-pub type MemInnerRef<'a> = &'a Memtype;
-impl<'a> From<&'a Mem> for MemInnerRef<'a> {
-    fn ex_from(m: &'a Mem) -> MemInnerRef<'a> {
-        &m.ty
+pub type ParsedElem5InnerRef<'a> = (&'a Reftype, &'a Exprs<'a>);
+impl<'a> From<&'a ParsedElem5<'a>> for ParsedElem5InnerRef<'a> {
+    fn ex_from(m: &'a ParsedElem5) -> ParsedElem5InnerRef<'a> {
+        (&m.et, &m.init)
     }
 }
 
-impl From<MemInner> for Mem {
-    fn ex_from(m: MemInner) -> Mem {
-        let ty = m;
-        Mem { ty }
+impl<'a> From<ParsedElem5Inner<'a>> for ParsedElem5<'a> {
+    fn ex_from(m: ParsedElem5Inner) -> ParsedElem5 {
+        let (et, init) = m;
+        ParsedElem5 { et, init }
     }
 }
 
-pub struct MemMapper;
-impl View for MemMapper {
+pub struct ParsedElem5Mapper;
+impl View for ParsedElem5Mapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for MemMapper {
-    type Src = SpecMemInner;
-    type Dst = SpecMem;
+impl SpecIso for ParsedElem5Mapper {
+    type Src = SpecParsedElem5Inner;
+    type Dst = SpecParsedElem5;
 }
-impl SpecIsoProof for MemMapper {
+impl SpecIsoProof for ParsedElem5Mapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -20960,199 +20949,212 @@ impl SpecIsoProof for MemMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for MemMapper {
-    type Src = MemInner;
-    type Dst = Mem;
-    type RefSrc = MemInnerRef<'a>;
+impl<'a> Iso<'a> for ParsedElem5Mapper {
+    type Src = ParsedElem5Inner<'a>;
+    type Dst = ParsedElem5<'a>;
+    type RefSrc = ParsedElem5InnerRef<'a>;
 }
+type SpecParsedElem5CombinatorAlias1 = (SpecReftypeCombinator, SpecExprsCombinator);
+pub struct SpecParsedElem5Combinator(pub SpecParsedElem5CombinatorAlias);
 
-pub struct SpecMemCombinator(pub SpecMemCombinatorAlias);
-
-impl SpecCombinator for SpecMemCombinator {
-    type Type = SpecMem;
+impl SpecCombinator for SpecParsedElem5Combinator {
+    type Type = SpecParsedElem5;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecMemCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecMemCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecParsedElem5Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecParsedElem5CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecMemCombinatorAlias = Mapped<SpecMemtypeCombinator, MemMapper>;
+pub type SpecParsedElem5CombinatorAlias = Mapped<SpecParsedElem5CombinatorAlias1, ParsedElem5Mapper>;
+type ParsedElem5CombinatorAlias1 = (ReftypeCombinator, ExprsCombinator);
+pub struct ParsedElem5Combinator1(pub ParsedElem5CombinatorAlias1);
+impl View for ParsedElem5Combinator1 {
+    type V = SpecParsedElem5CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ParsedElem5Combinator1, ParsedElem5CombinatorAlias1);
 
-pub struct MemCombinator(pub MemCombinatorAlias);
+pub struct ParsedElem5Combinator(pub ParsedElem5CombinatorAlias);
 
-impl View for MemCombinator {
-    type V = SpecMemCombinator;
-    open spec fn view(&self) -> Self::V { SpecMemCombinator(self.0@) }
+impl View for ParsedElem5Combinator {
+    type V = SpecParsedElem5Combinator;
+    open spec fn view(&self) -> Self::V { SpecParsedElem5Combinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemCombinator {
-    type Type = Mem;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem5Combinator {
+    type Type = ParsedElem5<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type MemCombinatorAlias = Mapped<MemtypeCombinator, MemMapper>;
+}
+pub type ParsedElem5CombinatorAlias = Mapped<ParsedElem5Combinator1, ParsedElem5Mapper>;
 
 
-pub open spec fn spec_mem() -> SpecMemCombinator {
-    SpecMemCombinator(
+pub open spec fn spec_parsed_elem5() -> SpecParsedElem5Combinator {
+    SpecParsedElem5Combinator(
     Mapped {
-        inner: spec_memtype(),
-        mapper: MemMapper,
+        inner: (spec_reftype(), spec_exprs()),
+        mapper: ParsedElem5Mapper,
     })
 }
 
                 
-pub fn mem<'a>() -> (o: MemCombinator)
-    ensures o@ == spec_mem(),
+pub fn parsed_elem5<'a>() -> (o: ParsedElem5Combinator)
+    ensures o@ == spec_parsed_elem5(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = MemCombinator(
+    let combinator = ParsedElem5Combinator(
     Mapped {
-        inner: memtype(),
-        mapper: MemMapper,
-    });
-    assert({
-        &&& combinator@ == spec_mem()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: ParsedElem5Combinator1((reftype(), exprs())),
+        mapper: ParsedElem5Mapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_parsed_elem5()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_mem<'a>(input: &'a [u8]) -> (res: PResult<<MemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_parsed_elem5<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem5Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_mem().spec_parse(input@) == Some((n as int, v@)),
-        spec_mem().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_parsed_elem5().spec_parse(input@) == Some((n as int, v@)),
+        spec_parsed_elem5().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_mem().spec_parse(input@) is None,
-        spec_mem().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_parsed_elem5().spec_parse(input@) is None,
+        spec_parsed_elem5().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = mem();
+    let combinator = parsed_elem5();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_mem<'a>(v: <MemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_parsed_elem5<'a>(v: <ParsedElem5Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_mem().wf(v@),
+        spec_parsed_elem5().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_mem().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_mem().spec_serialize(v@))
+            &&& n == spec_parsed_elem5().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem5().spec_serialize(v@))
         },
 {
-    let combinator = mem();
+    let combinator = parsed_elem5();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn mem_len<'a>(v: <MemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn parsed_elem5_len<'a>(v: <ParsedElem5Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_mem().wf(v@),
-        spec_mem().spec_serialize(v@).len() <= usize::MAX,
+        spec_parsed_elem5().wf(v@),
+        spec_parsed_elem5().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_mem().spec_serialize(v@).len(),
+        serialize_len == spec_parsed_elem5().spec_serialize(v@).len(),
 {
-    let combinator = mem();
+    let combinator = parsed_elem5();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecMemsecContent {
-    pub l: u64,
-    pub v: Seq<SpecMem>,
+pub struct SpecParsedElem6 {
+    pub table: SpecTableidx,
+    pub offset: SpecExpr,
+    pub et: SpecReftype,
+    pub init: SpecExprs,
 }
 
-pub type SpecMemsecContentInner = (u64, Seq<SpecMem>);
+pub type SpecParsedElem6Inner = (SpecTableidx, (SpecExpr, (SpecReftype, SpecExprs)));
 
 
-impl SpecFrom<SpecMemsecContent> for SpecMemsecContentInner {
-    open spec fn spec_from(m: SpecMemsecContent) -> SpecMemsecContentInner {
-        (m.l, m.v)
+impl SpecFrom<SpecParsedElem6> for SpecParsedElem6Inner {
+    open spec fn spec_from(m: SpecParsedElem6) -> SpecParsedElem6Inner {
+        (m.table, (m.offset, (m.et, m.init)))
     }
 }
 
-impl SpecFrom<SpecMemsecContentInner> for SpecMemsecContent {
-    open spec fn spec_from(m: SpecMemsecContentInner) -> SpecMemsecContent {
-        let (l, v) = m;
-        SpecMemsecContent { l, v }
+impl SpecFrom<SpecParsedElem6Inner> for SpecParsedElem6 {
+    open spec fn spec_from(m: SpecParsedElem6Inner) -> SpecParsedElem6 {
+        let (table, (offset, (et, init))) = m;
+        SpecParsedElem6 { table, offset, et, init }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct MemsecContent {
-    pub l: u64,
-    pub v: RepeatResult<Mem>,
+pub struct ParsedElem6<'a> {
+    pub table: Tableidx,
+    pub offset: Expr<'a>,
+    pub et: Reftype,
+    pub init: Exprs<'a>,
 }
 
-impl View for MemsecContent {
-    type V = SpecMemsecContent;
+impl View for ParsedElem6<'_> {
+    type V = SpecParsedElem6;
 
     open spec fn view(&self) -> Self::V {
-        SpecMemsecContent {
-            l: self.l@,
-            v: self.v@,
+        SpecParsedElem6 {
+            table: self.table@,
+            offset: self.offset@,
+            et: self.et@,
+            init: self.init@,
         }
     }
 }
-pub type MemsecContentInner = (u64, RepeatResult<Mem>);
+pub type ParsedElem6Inner<'a> = (Tableidx, (Expr<'a>, (Reftype, Exprs<'a>)));
 
-pub type MemsecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Mem>);
-impl<'a> From<&'a MemsecContent> for MemsecContentInnerRef<'a> {
-    fn ex_from(m: &'a MemsecContent) -> MemsecContentInnerRef<'a> {
-        (&m.l, &m.v)
+pub type ParsedElem6InnerRef<'a> = (&'a Tableidx, (&'a Expr<'a>, (&'a Reftype, &'a Exprs<'a>)));
+impl<'a> From<&'a ParsedElem6<'a>> for ParsedElem6InnerRef<'a> {
+    fn ex_from(m: &'a ParsedElem6) -> ParsedElem6InnerRef<'a> {
+        (&m.table, (&m.offset, (&m.et, &m.init)))
     }
 }
 
-impl From<MemsecContentInner> for MemsecContent {
-    fn ex_from(m: MemsecContentInner) -> MemsecContent {
-        let (l, v) = m;
-        MemsecContent { l, v }
+impl<'a> From<ParsedElem6Inner<'a>> for ParsedElem6<'a> {
+    fn ex_from(m: ParsedElem6Inner) -> ParsedElem6 {
+        let (table, (offset, (et, init))) = m;
+        ParsedElem6 { table, offset, et, init }
     }
 }
 
-pub struct MemsecContentMapper;
-impl View for MemsecContentMapper {
+pub struct ParsedElem6Mapper;
+impl View for ParsedElem6Mapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for MemsecContentMapper {
-    type Src = SpecMemsecContentInner;
-    type Dst = SpecMemsecContent;
+impl SpecIso for ParsedElem6Mapper {
+    type Src = SpecParsedElem6Inner;
+    type Dst = SpecParsedElem6;
 }
-impl SpecIsoProof for MemsecContentMapper {
+impl SpecIsoProof for ParsedElem6Mapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -21160,241 +21162,224 @@ impl SpecIsoProof for MemsecContentMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for MemsecContentMapper {
-    type Src = MemsecContentInner;
-    type Dst = MemsecContent;
-    type RefSrc = MemsecContentInnerRef<'a>;
+impl<'a> Iso<'a> for ParsedElem6Mapper {
+    type Src = ParsedElem6Inner<'a>;
+    type Dst = ParsedElem6<'a>;
+    type RefSrc = ParsedElem6InnerRef<'a>;
 }
+type SpecParsedElem6CombinatorAlias1 = (SpecReftypeCombinator, SpecExprsCombinator);
+type SpecParsedElem6CombinatorAlias2 = (SpecExprCombinator, SpecParsedElem6CombinatorAlias1);
+type SpecParsedElem6CombinatorAlias3 = (SpecTableidxCombinator, SpecParsedElem6CombinatorAlias2);
+pub struct SpecParsedElem6Combinator(pub SpecParsedElem6CombinatorAlias);
 
-pub struct SpecMemsecContentCombinator(pub SpecMemsecContentCombinatorAlias);
-
-impl SpecCombinator for SpecMemsecContentCombinator {
-    type Type = SpecMemsecContent;
+impl SpecCombinator for SpecParsedElem6Combinator {
+    type Type = SpecParsedElem6;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecMemsecContentCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecMemsecContentCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecParsedElem6Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecParsedElem6CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecMemsecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecMemCombinator>>, MemsecContentMapper>;
+pub type SpecParsedElem6CombinatorAlias = Mapped<SpecParsedElem6CombinatorAlias3, ParsedElem6Mapper>;
+type ParsedElem6CombinatorAlias1 = (ReftypeCombinator, ExprsCombinator);
+type ParsedElem6CombinatorAlias2 = (ExprCombinator, ParsedElem6Combinator1);
+type ParsedElem6CombinatorAlias3 = (TableidxCombinator, ParsedElem6Combinator2);
+pub struct ParsedElem6Combinator1(pub ParsedElem6CombinatorAlias1);
+impl View for ParsedElem6Combinator1 {
+    type V = SpecParsedElem6CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ParsedElem6Combinator1, ParsedElem6CombinatorAlias1);
 
-pub struct MemsecContentCombinator(pub MemsecContentCombinatorAlias);
+pub struct ParsedElem6Combinator2(pub ParsedElem6CombinatorAlias2);
+impl View for ParsedElem6Combinator2 {
+    type V = SpecParsedElem6CombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ParsedElem6Combinator2, ParsedElem6CombinatorAlias2);
 
-impl View for MemsecContentCombinator {
-    type V = SpecMemsecContentCombinator;
-    open spec fn view(&self) -> Self::V { SpecMemsecContentCombinator(self.0@) }
+pub struct ParsedElem6Combinator3(pub ParsedElem6CombinatorAlias3);
+impl View for ParsedElem6Combinator3 {
+    type V = SpecParsedElem6CombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemsecContentCombinator {
-    type Type = MemsecContent;
+impl_wrapper_combinator!(ParsedElem6Combinator3, ParsedElem6CombinatorAlias3);
+
+pub struct ParsedElem6Combinator(pub ParsedElem6CombinatorAlias);
+
+impl View for ParsedElem6Combinator {
+    type V = SpecParsedElem6Combinator;
+    open spec fn view(&self) -> Self::V { SpecParsedElem6Combinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem6Combinator {
+    type Type = ParsedElem6<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type MemsecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<MemCombinator>, MemsecContentCont0>, MemsecContentMapper>;
+}
+pub type ParsedElem6CombinatorAlias = Mapped<ParsedElem6Combinator3, ParsedElem6Mapper>;
 
 
-pub open spec fn spec_memsec_content() -> SpecMemsecContentCombinator {
-    SpecMemsecContentCombinator(
+pub open spec fn spec_parsed_elem6() -> SpecParsedElem6Combinator {
+    SpecParsedElem6Combinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_memsec_content_cont0(deps)),
-        mapper: MemsecContentMapper,
+        inner: (spec_tableidx(), (spec_expr(), (spec_reftype(), spec_exprs()))),
+        mapper: ParsedElem6Mapper,
     })
 }
 
-pub open spec fn spec_memsec_content_cont0(deps: u64) -> RepeatN<SpecMemCombinator> {
-    let l = deps;
-    RepeatN(spec_mem(), l.spec_into())
-}
-
-impl View for MemsecContentCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecMemCombinator>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_memsec_content_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn memsec_content<'a>() -> (o: MemsecContentCombinator)
-    ensures o@ == spec_memsec_content(),
+pub fn parsed_elem6<'a>() -> (o: ParsedElem6Combinator)
+    ensures o@ == spec_parsed_elem6(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = MemsecContentCombinator(
+    let combinator = ParsedElem6Combinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, MemsecContentCont0),
-        mapper: MemsecContentMapper,
-    });
-    assert({
-        &&& combinator@ == spec_memsec_content()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: ParsedElem6Combinator3((tableidx(), ParsedElem6Combinator2((expr(), ParsedElem6Combinator1((reftype(), exprs())))))),
+        mapper: ParsedElem6Mapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_parsed_elem6()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_memsec_content<'a>(input: &'a [u8]) -> (res: PResult<<MemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_parsed_elem6<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem6Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_memsec_content().spec_parse(input@) == Some((n as int, v@)),
-        spec_memsec_content().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_parsed_elem6().spec_parse(input@) == Some((n as int, v@)),
+        spec_parsed_elem6().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_memsec_content().spec_parse(input@) is None,
-        spec_memsec_content().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_parsed_elem6().spec_parse(input@) is None,
+        spec_parsed_elem6().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = memsec_content();
+    let combinator = parsed_elem6();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_memsec_content<'a>(v: <MemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_parsed_elem6<'a>(v: <ParsedElem6Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_memsec_content().wf(v@),
+        spec_parsed_elem6().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_memsec_content().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_memsec_content().spec_serialize(v@))
+            &&& n == spec_parsed_elem6().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem6().spec_serialize(v@))
         },
 {
-    let combinator = memsec_content();
+    let combinator = parsed_elem6();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn memsec_content_len<'a>(v: <MemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn parsed_elem6_len<'a>(v: <ParsedElem6Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_memsec_content().wf(v@),
-        spec_memsec_content().spec_serialize(v@).len() <= usize::MAX,
+        spec_parsed_elem6().wf(v@),
+        spec_parsed_elem6().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_memsec_content().spec_serialize(v@).len(),
+        serialize_len == spec_parsed_elem6().spec_serialize(v@).len(),
 {
-    let combinator = memsec_content();
+    let combinator = parsed_elem6();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct MemsecContentCont0;
-type MemsecContentCont0Type<'a, 'b> = &'b u64;
-type MemsecContentCont0SType<'a, 'x> = &'x u64;
-type MemsecContentCont0Input<'a, 'b, 'x> = POrSType<MemsecContentCont0Type<'a, 'b>, MemsecContentCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<MemsecContentCont0Input<'a, 'b, 'x>> for MemsecContentCont0 {
-    type Output = RepeatN<MemCombinator>;
-
-    open spec fn requires(&self, deps: MemsecContentCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: MemsecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_memsec_content_cont0(deps@)
-    }
-
-    fn apply(&self, deps: MemsecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(mem(), l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(mem(), l.ex_into())
-            }
-        }
-    }
-}
                 
 
-pub struct SpecGlobal {
-    pub gt: SpecGlobaltype,
-    pub init: SpecExpr,
+pub struct SpecParsedElem7 {
+    pub et: SpecReftype,
+    pub init: SpecExprs,
 }
 
-pub type SpecGlobalInner = (SpecGlobaltype, SpecExpr);
+pub type SpecParsedElem7Inner = (SpecReftype, SpecExprs);
 
 
-impl SpecFrom<SpecGlobal> for SpecGlobalInner {
-    open spec fn spec_from(m: SpecGlobal) -> SpecGlobalInner {
-        (m.gt, m.init)
+impl SpecFrom<SpecParsedElem7> for SpecParsedElem7Inner {
+    open spec fn spec_from(m: SpecParsedElem7) -> SpecParsedElem7Inner {
+        (m.et, m.init)
     }
 }
 
-impl SpecFrom<SpecGlobalInner> for SpecGlobal {
-    open spec fn spec_from(m: SpecGlobalInner) -> SpecGlobal {
-        let (gt, init) = m;
-        SpecGlobal { gt, init }
+impl SpecFrom<SpecParsedElem7Inner> for SpecParsedElem7 {
+    open spec fn spec_from(m: SpecParsedElem7Inner) -> SpecParsedElem7 {
+        let (et, init) = m;
+        SpecParsedElem7 { et, init }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Global<'a> {
-    pub gt: Globaltype,
-    pub init: Expr<'a>,
+pub struct ParsedElem7<'a> {
+    pub et: Reftype,
+    pub init: Exprs<'a>,
 }
 
-impl View for Global<'_> {
-    type V = SpecGlobal;
+impl View for ParsedElem7<'_> {
+    type V = SpecParsedElem7;
 
     open spec fn view(&self) -> Self::V {
-        SpecGlobal {
-            gt: self.gt@,
+        SpecParsedElem7 {
+            et: self.et@,
             init: self.init@,
         }
     }
 }
-pub type GlobalInner<'a> = (Globaltype, Expr<'a>);
+pub type ParsedElem7Inner<'a> = (Reftype, Exprs<'a>);
 
-pub type GlobalInnerRef<'a> = (&'a Globaltype, &'a Expr<'a>);
-impl<'a> From<&'a Global<'a>> for GlobalInnerRef<'a> {
-    fn ex_from(m: &'a Global) -> GlobalInnerRef<'a> {
-        (&m.gt, &m.init)
+pub type ParsedElem7InnerRef<'a> = (&'a Reftype, &'a Exprs<'a>);
+impl<'a> From<&'a ParsedElem7<'a>> for ParsedElem7InnerRef<'a> {
+    fn ex_from(m: &'a ParsedElem7) -> ParsedElem7InnerRef<'a> {
+        (&m.et, &m.init)
     }
 }
 
-impl<'a> From<GlobalInner<'a>> for Global<'a> {
-    fn ex_from(m: GlobalInner) -> Global {
-        let (gt, init) = m;
-        Global { gt, init }
+impl<'a> From<ParsedElem7Inner<'a>> for ParsedElem7<'a> {
+    fn ex_from(m: ParsedElem7Inner) -> ParsedElem7 {
+        let (et, init) = m;
+        ParsedElem7 { et, init }
     }
 }
 
-pub struct GlobalMapper;
-impl View for GlobalMapper {
+pub struct ParsedElem7Mapper;
+impl View for ParsedElem7Mapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for GlobalMapper {
-    type Src = SpecGlobalInner;
-    type Dst = SpecGlobal;
+impl SpecIso for ParsedElem7Mapper {
+    type Src = SpecParsedElem7Inner;
+    type Dst = SpecParsedElem7;
 }
-impl SpecIsoProof for GlobalMapper {
+impl SpecIsoProof for ParsedElem7Mapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -21402,206 +21387,268 @@ impl SpecIsoProof for GlobalMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for GlobalMapper {
-    type Src = GlobalInner<'a>;
-    type Dst = Global<'a>;
-    type RefSrc = GlobalInnerRef<'a>;
+impl<'a> Iso<'a> for ParsedElem7Mapper {
+    type Src = ParsedElem7Inner<'a>;
+    type Dst = ParsedElem7<'a>;
+    type RefSrc = ParsedElem7InnerRef<'a>;
 }
-type SpecGlobalCombinatorAlias1 = (SpecGlobaltypeCombinator, SpecExprCombinator);
-pub struct SpecGlobalCombinator(pub SpecGlobalCombinatorAlias);
+type SpecParsedElem7CombinatorAlias1 = (SpecReftypeCombinator, SpecExprsCombinator);
+pub struct SpecParsedElem7Combinator(pub SpecParsedElem7CombinatorAlias);
 
-impl SpecCombinator for SpecGlobalCombinator {
-    type Type = SpecGlobal;
+impl SpecCombinator for SpecParsedElem7Combinator {
+    type Type = SpecParsedElem7;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecGlobalCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecGlobalCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecParsedElem7Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecParsedElem7CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecGlobalCombinatorAlias = Mapped<SpecGlobalCombinatorAlias1, GlobalMapper>;
-type GlobalCombinatorAlias1 = (GlobaltypeCombinator, ExprCombinator);
-pub struct GlobalCombinator1(pub GlobalCombinatorAlias1);
-impl View for GlobalCombinator1 {
-    type V = SpecGlobalCombinatorAlias1;
+pub type SpecParsedElem7CombinatorAlias = Mapped<SpecParsedElem7CombinatorAlias1, ParsedElem7Mapper>;
+type ParsedElem7CombinatorAlias1 = (ReftypeCombinator, ExprsCombinator);
+pub struct ParsedElem7Combinator1(pub ParsedElem7CombinatorAlias1);
+impl View for ParsedElem7Combinator1 {
+    type V = SpecParsedElem7CombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(GlobalCombinator1, GlobalCombinatorAlias1);
+impl_wrapper_combinator!(ParsedElem7Combinator1, ParsedElem7CombinatorAlias1);
 
-pub struct GlobalCombinator(pub GlobalCombinatorAlias);
+pub struct ParsedElem7Combinator(pub ParsedElem7CombinatorAlias);
 
-impl View for GlobalCombinator {
-    type V = SpecGlobalCombinator;
-    open spec fn view(&self) -> Self::V { SpecGlobalCombinator(self.0@) }
+impl View for ParsedElem7Combinator {
+    type V = SpecParsedElem7Combinator;
+    open spec fn view(&self) -> Self::V { SpecParsedElem7Combinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GlobalCombinator {
-    type Type = Global<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ParsedElem7Combinator {
+    type Type = ParsedElem7<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type GlobalCombinatorAlias = Mapped<GlobalCombinator1, GlobalMapper>;
+}
+pub type ParsedElem7CombinatorAlias = Mapped<ParsedElem7Combinator1, ParsedElem7Mapper>;
 
 
-pub open spec fn spec_global() -> SpecGlobalCombinator {
-    SpecGlobalCombinator(
+pub open spec fn spec_parsed_elem7() -> SpecParsedElem7Combinator {
+    SpecParsedElem7Combinator(
     Mapped {
-        inner: (spec_globaltype(), spec_expr()),
-        mapper: GlobalMapper,
+        inner: (spec_reftype(), spec_exprs()),
+        mapper: ParsedElem7Mapper,
     })
 }
 
                 
-pub fn global<'a>() -> (o: GlobalCombinator)
-    ensures o@ == spec_global(),
+pub fn parsed_elem7<'a>() -> (o: ParsedElem7Combinator)
+    ensures o@ == spec_parsed_elem7(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = GlobalCombinator(
+    let combinator = ParsedElem7Combinator(
     Mapped {
-        inner: GlobalCombinator1((globaltype(), expr())),
-        mapper: GlobalMapper,
-    });
-    assert({
-        &&& combinator@ == spec_global()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: ParsedElem7Combinator1((reftype(), exprs())),
+        mapper: ParsedElem7Mapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_parsed_elem7()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_global<'a>(input: &'a [u8]) -> (res: PResult<<GlobalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_parsed_elem7<'a>(input: &'a [u8]) -> (res: PResult<<ParsedElem7Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_global().spec_parse(input@) == Some((n as int, v@)),
-        spec_global().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_parsed_elem7().spec_parse(input@) == Some((n as int, v@)),
+        spec_parsed_elem7().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_global().spec_parse(input@) is None,
-        spec_global().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_parsed_elem7().spec_parse(input@) is None,
+        spec_parsed_elem7().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = global();
+    let combinator = parsed_elem7();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_global<'a>(v: <GlobalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_parsed_elem7<'a>(v: <ParsedElem7Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_global().wf(v@),
+        spec_parsed_elem7().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_global().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_global().spec_serialize(v@))
+            &&& n == spec_parsed_elem7().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_parsed_elem7().spec_serialize(v@))
         },
 {
-    let combinator = global();
+    let combinator = parsed_elem7();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn global_len<'a>(v: <GlobalCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn parsed_elem7_len<'a>(v: <ParsedElem7Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_global().wf(v@),
-        spec_global().spec_serialize(v@).len() <= usize::MAX,
+        spec_parsed_elem7().wf(v@),
+        spec_parsed_elem7().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_global().spec_serialize(v@).len(),
+        serialize_len == spec_parsed_elem7().spec_serialize(v@).len(),
 {
-    let combinator = global();
+    let combinator = parsed_elem7();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecGlobalsecContent {
-    pub l: u64,
-    pub v: Seq<SpecGlobal>,
+pub enum SpecElem {
+    Elem0(SpecParsedElem0),
+    Elem1(SpecParsedElem1),
+    Elem2(SpecParsedElem2),
+    Elem3(SpecParsedElem3),
+    Elem4(SpecParsedElem4),
+    Elem5(SpecParsedElem5),
+    Elem6(SpecParsedElem6),
+    Elem7(SpecParsedElem7),
 }
 
-pub type SpecGlobalsecContentInner = (u64, Seq<SpecGlobal>);
-
+pub type SpecElemInner = Either<SpecParsedElem0, Either<SpecParsedElem1, Either<SpecParsedElem2, Either<SpecParsedElem3, Either<SpecParsedElem4, Either<SpecParsedElem5, Either<SpecParsedElem6, SpecParsedElem7>>>>>>>;
 
-impl SpecFrom<SpecGlobalsecContent> for SpecGlobalsecContentInner {
-    open spec fn spec_from(m: SpecGlobalsecContent) -> SpecGlobalsecContentInner {
-        (m.l, m.v)
+impl SpecFrom<SpecElem> for SpecElemInner {
+    open spec fn spec_from(m: SpecElem) -> SpecElemInner {
+        match m {
+            SpecElem::Elem0(m) => Either::Left(m),
+            SpecElem::Elem1(m) => Either::Right(Either::Left(m)),
+            SpecElem::Elem2(m) => Either::Right(Either::Right(Either::Left(m))),
+            SpecElem::Elem3(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            SpecElem::Elem4(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            SpecElem::Elem5(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            SpecElem::Elem6(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            SpecElem::Elem7(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))),
+        }
     }
+
 }
 
-impl SpecFrom<SpecGlobalsecContentInner> for SpecGlobalsecContent {
-    open spec fn spec_from(m: SpecGlobalsecContentInner) -> SpecGlobalsecContent {
-        let (l, v) = m;
-        SpecGlobalsecContent { l, v }
+                
+impl SpecFrom<SpecElemInner> for SpecElem {
+    open spec fn spec_from(m: SpecElemInner) -> SpecElem {
+        match m {
+            Either::Left(m) => SpecElem::Elem0(m),
+            Either::Right(Either::Left(m)) => SpecElem::Elem1(m),
+            Either::Right(Either::Right(Either::Left(m))) => SpecElem::Elem2(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => SpecElem::Elem3(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => SpecElem::Elem4(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => SpecElem::Elem5(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => SpecElem::Elem6(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))) => SpecElem::Elem7(m),
+        }
     }
+
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct GlobalsecContent<'a> {
-    pub l: u64,
-    pub v: RepeatResult<Global<'a>>,
+
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Elem<'a> {
+    Elem0(ParsedElem0<'a>),
+    Elem1(ParsedElem1),
+    Elem2(ParsedElem2<'a>),
+    Elem3(ParsedElem3),
+    Elem4(ParsedElem4<'a>),
+    Elem5(ParsedElem5<'a>),
+    Elem6(ParsedElem6<'a>),
+    Elem7(ParsedElem7<'a>),
 }
 
-impl View for GlobalsecContent<'_> {
-    type V = SpecGlobalsecContent;
+pub type ElemInner<'a> = Either<ParsedElem0<'a>, Either<ParsedElem1, Either<ParsedElem2<'a>, Either<ParsedElem3, Either<ParsedElem4<'a>, Either<ParsedElem5<'a>, Either<ParsedElem6<'a>, ParsedElem7<'a>>>>>>>>;
+
+pub type ElemInnerRef<'a> = Either<&'a ParsedElem0<'a>, Either<&'a ParsedElem1, Either<&'a ParsedElem2<'a>, Either<&'a ParsedElem3, Either<&'a ParsedElem4<'a>, Either<&'a ParsedElem5<'a>, Either<&'a ParsedElem6<'a>, &'a ParsedElem7<'a>>>>>>>>;
 
+
+impl<'a> View for Elem<'a> {
+    type V = SpecElem;
     open spec fn view(&self) -> Self::V {
-        SpecGlobalsecContent {
-            l: self.l@,
-            v: self.v@,
+        match self {
+            Elem::Elem0(m) => SpecElem::Elem0(m@),
+            Elem::Elem1(m) => SpecElem::Elem1(m@),
+            Elem::Elem2(m) => SpecElem::Elem2(m@),
+            Elem::Elem3(m) => SpecElem::Elem3(m@),
+            Elem::Elem4(m) => SpecElem::Elem4(m@),
+            Elem::Elem5(m) => SpecElem::Elem5(m@),
+            Elem::Elem6(m) => SpecElem::Elem6(m@),
+            Elem::Elem7(m) => SpecElem::Elem7(m@),
         }
     }
 }
-pub type GlobalsecContentInner<'a> = (u64, RepeatResult<Global<'a>>);
 
-pub type GlobalsecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Global<'a>>);
-impl<'a> From<&'a GlobalsecContent<'a>> for GlobalsecContentInnerRef<'a> {
-    fn ex_from(m: &'a GlobalsecContent) -> GlobalsecContentInnerRef<'a> {
-        (&m.l, &m.v)
+
+impl<'a> From<&'a Elem<'a>> for ElemInnerRef<'a> {
+    fn ex_from(m: &'a Elem<'a>) -> ElemInnerRef<'a> {
+        match m {
+            Elem::Elem0(m) => Either::Left(m),
+            Elem::Elem1(m) => Either::Right(Either::Left(m)),
+            Elem::Elem2(m) => Either::Right(Either::Right(Either::Left(m))),
+            Elem::Elem3(m) => Either::Right(Either::Right(Either::Right(Either::Left(m)))),
+            Elem::Elem4(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))),
+            Elem::Elem5(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))),
+            Elem::Elem6(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))),
+            Elem::Elem7(m) => Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))),
+        }
+    }
+
+}
+
+impl<'a> From<ElemInner<'a>> for Elem<'a> {
+    fn ex_from(m: ElemInner<'a>) -> Elem<'a> {
+        match m {
+            Either::Left(m) => Elem::Elem0(m),
+            Either::Right(Either::Left(m)) => Elem::Elem1(m),
+            Either::Right(Either::Right(Either::Left(m))) => Elem::Elem2(m),
+            Either::Right(Either::Right(Either::Right(Either::Left(m)))) => Elem::Elem3(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))) => Elem::Elem4(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m)))))) => Elem::Elem5(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Left(m))))))) => Elem::Elem6(m),
+            Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(Either::Right(m))))))) => Elem::Elem7(m),
+        }
     }
+    
 }
 
-impl<'a> From<GlobalsecContentInner<'a>> for GlobalsecContent<'a> {
-    fn ex_from(m: GlobalsecContentInner) -> GlobalsecContent {
-        let (l, v) = m;
-        GlobalsecContent { l, v }
-    }
-}
 
-pub struct GlobalsecContentMapper;
-impl View for GlobalsecContentMapper {
+pub struct ElemMapper;
+impl View for ElemMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for GlobalsecContentMapper {
-    type Src = SpecGlobalsecContentInner;
-    type Dst = SpecGlobalsecContent;
+impl SpecIso for ElemMapper {
+    type Src = SpecElemInner;
+    type Dst = SpecElem;
 }
-impl SpecIsoProof for GlobalsecContentMapper {
+impl SpecIsoProof for ElemMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -21609,241 +21656,277 @@ impl SpecIsoProof for GlobalsecContentMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for GlobalsecContentMapper {
-    type Src = GlobalsecContentInner<'a>;
-    type Dst = GlobalsecContent<'a>;
-    type RefSrc = GlobalsecContentInnerRef<'a>;
+impl<'a> Iso<'a> for ElemMapper {
+    type Src = ElemInner<'a>;
+    type Dst = Elem<'a>;
+    type RefSrc = ElemInnerRef<'a>;
 }
 
-pub struct SpecGlobalsecContentCombinator(pub SpecGlobalsecContentCombinatorAlias);
+pub const ELEMELEM0_0_FRONT_CONST: u64 = 0;
 
-impl SpecCombinator for SpecGlobalsecContentCombinator {
-    type Type = SpecGlobalsecContent;
+pub const ELEMELEM1_0_FRONT_CONST: u64 = 1;
+
+pub const ELEMELEM2_0_FRONT_CONST: u64 = 2;
+
+pub const ELEMELEM3_0_FRONT_CONST: u64 = 3;
+
+pub const ELEMELEM4_0_FRONT_CONST: u64 = 4;
+
+pub const ELEMELEM5_0_FRONT_CONST: u64 = 5;
+
+pub const ELEMELEM6_0_FRONT_CONST: u64 = 6;
+
+pub const ELEMELEM7_0_FRONT_CONST: u64 = 7;
+
+type SpecElemCombinatorAlias1 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem6Combinator>, Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem7Combinator>>;
+type SpecElemCombinatorAlias2 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem5Combinator>, SpecElemCombinatorAlias1>;
+type SpecElemCombinatorAlias3 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem4Combinator>, SpecElemCombinatorAlias2>;
+type SpecElemCombinatorAlias4 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem3Combinator>, SpecElemCombinatorAlias3>;
+type SpecElemCombinatorAlias5 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem2Combinator>, SpecElemCombinatorAlias4>;
+type SpecElemCombinatorAlias6 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem1Combinator>, SpecElemCombinatorAlias5>;
+type SpecElemCombinatorAlias7 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecParsedElem0Combinator>, SpecElemCombinatorAlias6>;
+pub struct SpecElemCombinator(pub SpecElemCombinatorAlias);
+
+impl SpecCombinator for SpecElemCombinator {
+    type Type = SpecElem;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecGlobalsecContentCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecGlobalsecContentCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecElemCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecElemCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecGlobalsecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecGlobalCombinator>>, GlobalsecContentMapper>;
+pub type SpecElemCombinatorAlias = Mapped<SpecElemCombinatorAlias7, ElemMapper>;
 
-pub struct GlobalsecContentCombinator(pub GlobalsecContentCombinatorAlias);
 
-impl View for GlobalsecContentCombinator {
-    type V = SpecGlobalsecContentCombinator;
-    open spec fn view(&self) -> Self::V { SpecGlobalsecContentCombinator(self.0@) }
+
+
+
+
+
+
+type ElemCombinatorAlias1 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem6Combinator>, Preceded<Tag<UnsignedLEB128, u64>, ParsedElem7Combinator>>;
+type ElemCombinatorAlias2 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem5Combinator>, ElemCombinator1>;
+type ElemCombinatorAlias3 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem4Combinator>, ElemCombinator2>;
+type ElemCombinatorAlias4 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem3Combinator>, ElemCombinator3>;
+type ElemCombinatorAlias5 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem2Combinator>, ElemCombinator4>;
+type ElemCombinatorAlias6 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem1Combinator>, ElemCombinator5>;
+type ElemCombinatorAlias7 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ParsedElem0Combinator>, ElemCombinator6>;
+pub struct ElemCombinator1(pub ElemCombinatorAlias1);
+impl View for ElemCombinator1 {
+    type V = SpecElemCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GlobalsecContentCombinator {
-    type Type = GlobalsecContent<'a>;
+impl_wrapper_combinator!(ElemCombinator1, ElemCombinatorAlias1);
+
+pub struct ElemCombinator2(pub ElemCombinatorAlias2);
+impl View for ElemCombinator2 {
+    type V = SpecElemCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ElemCombinator2, ElemCombinatorAlias2);
+
+pub struct ElemCombinator3(pub ElemCombinatorAlias3);
+impl View for ElemCombinator3 {
+    type V = SpecElemCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ElemCombinator3, ElemCombinatorAlias3);
+
+pub struct ElemCombinator4(pub ElemCombinatorAlias4);
+impl View for ElemCombinator4 {
+    type V = SpecElemCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ElemCombinator4, ElemCombinatorAlias4);
+
+pub struct ElemCombinator5(pub ElemCombinatorAlias5);
+impl View for ElemCombinator5 {
+    type V = SpecElemCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ElemCombinator5, ElemCombinatorAlias5);
+
+pub struct ElemCombinator6(pub ElemCombinatorAlias6);
+impl View for ElemCombinator6 {
+    type V = SpecElemCombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ElemCombinator6, ElemCombinatorAlias6);
+
+pub struct ElemCombinator7(pub ElemCombinatorAlias7);
+impl View for ElemCombinator7 {
+    type V = SpecElemCombinatorAlias7;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ElemCombinator7, ElemCombinatorAlias7);
+
+pub struct ElemCombinator(pub ElemCombinatorAlias);
+
+impl View for ElemCombinator {
+    type V = SpecElemCombinator;
+    open spec fn view(&self) -> Self::V { SpecElemCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ElemCombinator {
+    type Type = Elem<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type GlobalsecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<GlobalCombinator>, GlobalsecContentCont0>, GlobalsecContentMapper>;
-
-
-pub open spec fn spec_globalsec_content() -> SpecGlobalsecContentCombinator {
-    SpecGlobalsecContentCombinator(
-    Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_globalsec_content_cont0(deps)),
-        mapper: GlobalsecContentMapper,
-    })
-}
-
-pub open spec fn spec_globalsec_content_cont0(deps: u64) -> RepeatN<SpecGlobalCombinator> {
-    let l = deps;
-    RepeatN(spec_global(), l.spec_into())
 }
+pub type ElemCombinatorAlias = Mapped<ElemCombinator7, ElemMapper>;
 
-impl View for GlobalsecContentCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecGlobalCombinator>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_globalsec_content_cont0(deps)
-        }
-    }
+pub open spec fn spec_elem() -> SpecElemCombinator {
+    SpecElemCombinator(Mapped { inner: Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM0_0_FRONT_CONST), spec_parsed_elem0()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM1_0_FRONT_CONST), spec_parsed_elem1()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM2_0_FRONT_CONST), spec_parsed_elem2()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM3_0_FRONT_CONST), spec_parsed_elem3()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM4_0_FRONT_CONST), spec_parsed_elem4()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM5_0_FRONT_CONST), spec_parsed_elem5()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM6_0_FRONT_CONST), spec_parsed_elem6()), Preceded(Tag::spec_new(UnsignedLEB128, ELEMELEM7_0_FRONT_CONST), spec_parsed_elem7())))))))), mapper: ElemMapper })
 }
 
                 
-pub fn globalsec_content<'a>() -> (o: GlobalsecContentCombinator)
-    ensures o@ == spec_globalsec_content(),
+pub fn elem<'a>() -> (o: ElemCombinator)
+    ensures o@ == spec_elem(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = GlobalsecContentCombinator(
-    Mapped {
-        inner: Pair::new(UnsignedLEB128, GlobalsecContentCont0),
-        mapper: GlobalsecContentMapper,
-    });
-    assert({
-        &&& combinator@ == spec_globalsec_content()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = ElemCombinator(Mapped { inner: ElemCombinator7(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM0_0_FRONT_CONST), parsed_elem0()), ElemCombinator6(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM1_0_FRONT_CONST), parsed_elem1()), ElemCombinator5(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM2_0_FRONT_CONST), parsed_elem2()), ElemCombinator4(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM3_0_FRONT_CONST), parsed_elem3()), ElemCombinator3(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM4_0_FRONT_CONST), parsed_elem4()), ElemCombinator2(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM5_0_FRONT_CONST), parsed_elem5()), ElemCombinator1(Choice::new(Preceded(Tag::new(UnsignedLEB128, ELEMELEM6_0_FRONT_CONST), parsed_elem6()), Preceded(Tag::new(UnsignedLEB128, ELEMELEM7_0_FRONT_CONST), parsed_elem7()))))))))))))))), mapper: ElemMapper });
+    // assert({
+    //     &&& combinator@ == spec_elem()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_globalsec_content<'a>(input: &'a [u8]) -> (res: PResult<<GlobalsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_elem<'a>(input: &'a [u8]) -> (res: PResult<<ElemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_globalsec_content().spec_parse(input@) == Some((n as int, v@)),
-        spec_globalsec_content().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_elem().spec_parse(input@) == Some((n as int, v@)),
+        spec_elem().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_globalsec_content().spec_parse(input@) is None,
-        spec_globalsec_content().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_elem().spec_parse(input@) is None,
+        spec_elem().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = globalsec_content();
+    let combinator = elem();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_globalsec_content<'a>(v: <GlobalsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_elem<'a>(v: <ElemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_globalsec_content().wf(v@),
+        spec_elem().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_globalsec_content().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_globalsec_content().spec_serialize(v@))
+            &&& n == spec_elem().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_elem().spec_serialize(v@))
         },
 {
-    let combinator = globalsec_content();
+    let combinator = elem();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn globalsec_content_len<'a>(v: <GlobalsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn elem_len<'a>(v: <ElemCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_globalsec_content().wf(v@),
-        spec_globalsec_content().spec_serialize(v@).len() <= usize::MAX,
+        spec_elem().wf(v@),
+        spec_elem().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_globalsec_content().spec_serialize(v@).len(),
+        serialize_len == spec_elem().spec_serialize(v@).len(),
 {
-    let combinator = globalsec_content();
+    let combinator = elem();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct GlobalsecContentCont0;
-type GlobalsecContentCont0Type<'a, 'b> = &'b u64;
-type GlobalsecContentCont0SType<'a, 'x> = &'x u64;
-type GlobalsecContentCont0Input<'a, 'b, 'x> = POrSType<GlobalsecContentCont0Type<'a, 'b>, GlobalsecContentCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<GlobalsecContentCont0Input<'a, 'b, 'x>> for GlobalsecContentCont0 {
-    type Output = RepeatN<GlobalCombinator>;
-
-    open spec fn requires(&self, deps: GlobalsecContentCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: GlobalsecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_globalsec_content_cont0(deps@)
-    }
-
-    fn apply(&self, deps: GlobalsecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(global(), l.ex_into())
-            }
-            POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(global(), l.ex_into())
-            }
-        }
-    }
-}
                 
 
-pub struct SpecGlobalsec {
-    pub size: u64,
-    pub cont: SpecGlobalsecContent,
+pub struct SpecElemsecContent {
+    pub l: u64,
+    pub v: Seq<SpecElem>,
 }
 
-pub type SpecGlobalsecInner = (u64, SpecGlobalsecContent);
+pub type SpecElemsecContentInner = (u64, Seq<SpecElem>);
 
 
-impl SpecFrom<SpecGlobalsec> for SpecGlobalsecInner {
-    open spec fn spec_from(m: SpecGlobalsec) -> SpecGlobalsecInner {
-        (m.size, m.cont)
+impl SpecFrom<SpecElemsecContent> for SpecElemsecContentInner {
+    open spec fn spec_from(m: SpecElemsecContent) -> SpecElemsecContentInner {
+        (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecGlobalsecInner> for SpecGlobalsec {
-    open spec fn spec_from(m: SpecGlobalsecInner) -> SpecGlobalsec {
-        let (size, cont) = m;
-        SpecGlobalsec { size, cont }
+impl SpecFrom<SpecElemsecContentInner> for SpecElemsecContent {
+    open spec fn spec_from(m: SpecElemsecContentInner) -> SpecElemsecContent {
+        let (l, v) = m;
+        SpecElemsecContent { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Globalsec<'a> {
-    pub size: u64,
-    pub cont: GlobalsecContent<'a>,
+pub struct ElemsecContent<'a> {
+    pub l: u64,
+    pub v: RepeatResult<Elem<'a>>,
 }
 
-impl View for Globalsec<'_> {
-    type V = SpecGlobalsec;
+impl View for ElemsecContent<'_> {
+    type V = SpecElemsecContent;
 
     open spec fn view(&self) -> Self::V {
-        SpecGlobalsec {
-            size: self.size@,
-            cont: self.cont@,
+        SpecElemsecContent {
+            l: self.l@,
+            v: self.v@,
         }
     }
 }
-pub type GlobalsecInner<'a> = (u64, GlobalsecContent<'a>);
+pub type ElemsecContentInner<'a> = (u64, RepeatResult<Elem<'a>>);
 
-pub type GlobalsecInnerRef<'a> = (&'a u64, &'a GlobalsecContent<'a>);
-impl<'a> From<&'a Globalsec<'a>> for GlobalsecInnerRef<'a> {
-    fn ex_from(m: &'a Globalsec) -> GlobalsecInnerRef<'a> {
-        (&m.size, &m.cont)
+pub type ElemsecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Elem<'a>>);
+impl<'a> From<&'a ElemsecContent<'a>> for ElemsecContentInnerRef<'a> {
+    fn ex_from(m: &'a ElemsecContent) -> ElemsecContentInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-impl<'a> From<GlobalsecInner<'a>> for Globalsec<'a> {
-    fn ex_from(m: GlobalsecInner) -> Globalsec {
-        let (size, cont) = m;
-        Globalsec { size, cont }
+impl<'a> From<ElemsecContentInner<'a>> for ElemsecContent<'a> {
+    fn ex_from(m: ElemsecContentInner) -> ElemsecContent {
+        let (l, v) = m;
+        ElemsecContent { l, v }
     }
 }
 
-pub struct GlobalsecMapper;
-impl View for GlobalsecMapper {
+pub struct ElemsecContentMapper;
+impl View for ElemsecContentMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for GlobalsecMapper {
-    type Src = SpecGlobalsecInner;
-    type Dst = SpecGlobalsec;
+impl SpecIso for ElemsecContentMapper {
+    type Src = SpecElemsecContentInner;
+    type Dst = SpecElemsecContent;
 }
-impl SpecIsoProof for GlobalsecMapper {
+impl SpecIsoProof for ElemsecContentMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -21851,241 +21934,245 @@ impl SpecIsoProof for GlobalsecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for GlobalsecMapper {
-    type Src = GlobalsecInner<'a>;
-    type Dst = Globalsec<'a>;
-    type RefSrc = GlobalsecInnerRef<'a>;
+impl<'a> Iso<'a> for ElemsecContentMapper {
+    type Src = ElemsecContentInner<'a>;
+    type Dst = ElemsecContent<'a>;
+    type RefSrc = ElemsecContentInnerRef<'a>;
 }
 
-pub struct SpecGlobalsecCombinator(pub SpecGlobalsecCombinatorAlias);
+pub struct SpecElemsecContentCombinator(pub SpecElemsecContentCombinatorAlias);
 
-impl SpecCombinator for SpecGlobalsecCombinator {
-    type Type = SpecGlobalsec;
+impl SpecCombinator for SpecElemsecContentCombinator {
+    type Type = SpecElemsecContent;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecGlobalsecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecGlobalsecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecElemsecContentCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecElemsecContentCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecGlobalsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecGlobalsecContentCombinator>>, GlobalsecMapper>;
+pub type SpecElemsecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecElemCombinator>>, ElemsecContentMapper>;
 
-pub struct GlobalsecCombinator(pub GlobalsecCombinatorAlias);
+pub struct ElemsecContentCombinator(pub ElemsecContentCombinatorAlias);
 
-impl View for GlobalsecCombinator {
-    type V = SpecGlobalsecCombinator;
-    open spec fn view(&self) -> Self::V { SpecGlobalsecCombinator(self.0@) }
+impl View for ElemsecContentCombinator {
+    type V = SpecElemsecContentCombinator;
+    open spec fn view(&self) -> Self::V { SpecElemsecContentCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for GlobalsecCombinator {
-    type Type = Globalsec<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ElemsecContentCombinator {
+    type Type = ElemsecContent<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type GlobalsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, GlobalsecContentCombinator>, GlobalsecCont0>, GlobalsecMapper>;
+}
+pub type ElemsecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<ElemCombinator>, ElemsecContentCont0>, ElemsecContentMapper>;
 
 
-pub open spec fn spec_globalsec() -> SpecGlobalsecCombinator {
-    SpecGlobalsecCombinator(
+pub open spec fn spec_elemsec_content() -> SpecElemsecContentCombinator {
+    SpecElemsecContentCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_globalsec_cont0(deps)),
-        mapper: GlobalsecMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_elemsec_content_cont0(deps)),
+        mapper: ElemsecContentMapper,
     })
 }
 
-pub open spec fn spec_globalsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecGlobalsecContentCombinator> {
-    let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_globalsec_content())
+pub open spec fn spec_elemsec_content_cont0(deps: u64) -> RepeatN<SpecElemCombinator> {
+    let l = deps;
+    RepeatN(spec_elem(), (usize::spec_from(l)) as usize)
 }
 
-impl View for GlobalsecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecGlobalsecContentCombinator>;
+impl View for ElemsecContentCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecElemCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_globalsec_cont0(deps)
+            spec_elemsec_content_cont0(deps)
         }
     }
 }
 
                 
-pub fn globalsec<'a>() -> (o: GlobalsecCombinator)
-    ensures o@ == spec_globalsec(),
+pub fn elemsec_content<'a>() -> (o: ElemsecContentCombinator)
+    ensures o@ == spec_elemsec_content(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = GlobalsecCombinator(
+    let combinator = ElemsecContentCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, GlobalsecCont0),
-        mapper: GlobalsecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_globalsec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, ElemsecContentCont0),
+        mapper: ElemsecContentMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_elemsec_content()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_globalsec<'a>(input: &'a [u8]) -> (res: PResult<<GlobalsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_elemsec_content<'a>(input: &'a [u8]) -> (res: PResult<<ElemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_globalsec().spec_parse(input@) == Some((n as int, v@)),
-        spec_globalsec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_elemsec_content().spec_parse(input@) == Some((n as int, v@)),
+        spec_elemsec_content().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_globalsec().spec_parse(input@) is None,
-        spec_globalsec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_elemsec_content().spec_parse(input@) is None,
+        spec_elemsec_content().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = globalsec();
+    let combinator = elemsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_globalsec<'a>(v: <GlobalsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_elemsec_content<'a>(v: <ElemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_globalsec().wf(v@),
+        spec_elemsec_content().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_globalsec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_globalsec().spec_serialize(v@))
+            &&& n == spec_elemsec_content().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_elemsec_content().spec_serialize(v@))
         },
 {
-    let combinator = globalsec();
+    let combinator = elemsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn globalsec_len<'a>(v: <GlobalsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn elemsec_content_len<'a>(v: <ElemsecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_globalsec().wf(v@),
-        spec_globalsec().spec_serialize(v@).len() <= usize::MAX,
+        spec_elemsec_content().wf(v@),
+        spec_elemsec_content().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_globalsec().spec_serialize(v@).len(),
+        serialize_len == spec_elemsec_content().spec_serialize(v@).len(),
 {
-    let combinator = globalsec();
+    let combinator = elemsec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct GlobalsecCont0;
-type GlobalsecCont0Type<'a, 'b> = &'b u64;
-type GlobalsecCont0SType<'a, 'x> = &'x u64;
-type GlobalsecCont0Input<'a, 'b, 'x> = POrSType<GlobalsecCont0Type<'a, 'b>, GlobalsecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<GlobalsecCont0Input<'a, 'b, 'x>> for GlobalsecCont0 {
-    type Output = AndThen<bytes::Variable, GlobalsecContentCombinator>;
+pub struct ElemsecContentCont0;
+type ElemsecContentCont0Type<'a, 'b> = &'b u64;
+type ElemsecContentCont0SType<'a, 'x> = &'x u64;
+type ElemsecContentCont0Input<'a, 'b, 'x> = POrSType<ElemsecContentCont0Type<'a, 'b>, ElemsecContentCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ElemsecContentCont0Input<'a, 'b, 'x>> for ElemsecContentCont0 {
+    type Output = RepeatN<ElemCombinator>;
 
-    open spec fn requires(&self, deps: GlobalsecCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: ElemsecContentCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: GlobalsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_globalsec_cont0(deps@)
+    open spec fn ensures(&self, deps: ElemsecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_elemsec_content_cont0(deps@)
     }
 
-    fn apply(&self, deps: GlobalsecCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: ElemsecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), globalsec_content())
+                let l = deps;
+                let l = *l;
+                RepeatN(elem(), (usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
-                let size = deps;
-                let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), globalsec_content())
+                let l = deps;
+                let l = *l;
+                RepeatN(elem(), (usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
 
-pub struct SpecCode {
+pub struct SpecElemsec {
     pub size: u64,
-    pub code: SpecFunc,
+    pub cont: SpecElemsecContent,
 }
 
-pub type SpecCodeInner = (u64, SpecFunc);
+pub type SpecElemsecInner = (u64, SpecElemsecContent);
 
 
-impl SpecFrom<SpecCode> for SpecCodeInner {
-    open spec fn spec_from(m: SpecCode) -> SpecCodeInner {
-        (m.size, m.code)
+impl SpecFrom<SpecElemsec> for SpecElemsecInner {
+    open spec fn spec_from(m: SpecElemsec) -> SpecElemsecInner {
+        (m.size, m.cont)
     }
 }
 
-impl SpecFrom<SpecCodeInner> for SpecCode {
-    open spec fn spec_from(m: SpecCodeInner) -> SpecCode {
-        let (size, code) = m;
-        SpecCode { size, code }
+impl SpecFrom<SpecElemsecInner> for SpecElemsec {
+    open spec fn spec_from(m: SpecElemsecInner) -> SpecElemsec {
+        let (size, cont) = m;
+        SpecElemsec { size, cont }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Code<'a> {
+pub struct Elemsec<'a> {
     pub size: u64,
-    pub code: Func<'a>,
+    pub cont: ElemsecContent<'a>,
 }
 
-impl View for Code<'_> {
-    type V = SpecCode;
+impl View for Elemsec<'_> {
+    type V = SpecElemsec;
 
     open spec fn view(&self) -> Self::V {
-        SpecCode {
+        SpecElemsec {
             size: self.size@,
-            code: self.code@,
+            cont: self.cont@,
         }
     }
 }
-pub type CodeInner<'a> = (u64, Func<'a>);
+pub type ElemsecInner<'a> = (u64, ElemsecContent<'a>);
 
-pub type CodeInnerRef<'a> = (&'a u64, &'a Func<'a>);
-impl<'a> From<&'a Code<'a>> for CodeInnerRef<'a> {
-    fn ex_from(m: &'a Code) -> CodeInnerRef<'a> {
-        (&m.size, &m.code)
+pub type ElemsecInnerRef<'a> = (&'a u64, &'a ElemsecContent<'a>);
+impl<'a> From<&'a Elemsec<'a>> for ElemsecInnerRef<'a> {
+    fn ex_from(m: &'a Elemsec) -> ElemsecInnerRef<'a> {
+        (&m.size, &m.cont)
     }
 }
 
-impl<'a> From<CodeInner<'a>> for Code<'a> {
-    fn ex_from(m: CodeInner) -> Code {
-        let (size, code) = m;
-        Code { size, code }
+impl<'a> From<ElemsecInner<'a>> for Elemsec<'a> {
+    fn ex_from(m: ElemsecInner) -> Elemsec {
+        let (size, cont) = m;
+        Elemsec { size, cont }
     }
 }
 
-pub struct CodeMapper;
-impl View for CodeMapper {
+pub struct ElemsecMapper;
+impl View for ElemsecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CodeMapper {
-    type Src = SpecCodeInner;
-    type Dst = SpecCode;
+impl SpecIso for ElemsecMapper {
+    type Src = SpecElemsecInner;
+    type Dst = SpecElemsec;
 }
-impl SpecIsoProof for CodeMapper {
+impl SpecIsoProof for ElemsecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -22093,241 +22180,245 @@ impl SpecIsoProof for CodeMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CodeMapper {
-    type Src = CodeInner<'a>;
-    type Dst = Code<'a>;
-    type RefSrc = CodeInnerRef<'a>;
+impl<'a> Iso<'a> for ElemsecMapper {
+    type Src = ElemsecInner<'a>;
+    type Dst = Elemsec<'a>;
+    type RefSrc = ElemsecInnerRef<'a>;
 }
 
-pub struct SpecCodeCombinator(pub SpecCodeCombinatorAlias);
+pub struct SpecElemsecCombinator(pub SpecElemsecCombinatorAlias);
 
-impl SpecCombinator for SpecCodeCombinator {
-    type Type = SpecCode;
+impl SpecCombinator for SpecElemsecCombinator {
+    type Type = SpecElemsec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCodeCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCodeCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecElemsecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecElemsecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCodeCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecFuncCombinator>>, CodeMapper>;
+pub type SpecElemsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecElemsecContentCombinator>>, ElemsecMapper>;
 
-pub struct CodeCombinator(pub CodeCombinatorAlias);
+pub struct ElemsecCombinator(pub ElemsecCombinatorAlias);
 
-impl View for CodeCombinator {
-    type V = SpecCodeCombinator;
-    open spec fn view(&self) -> Self::V { SpecCodeCombinator(self.0@) }
+impl View for ElemsecCombinator {
+    type V = SpecElemsecCombinator;
+    open spec fn view(&self) -> Self::V { SpecElemsecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CodeCombinator {
-    type Type = Code<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ElemsecCombinator {
+    type Type = Elemsec<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CodeCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, FuncCombinator>, CodeCont0>, CodeMapper>;
+}
+pub type ElemsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, ElemsecContentCombinator>, ElemsecCont0>, ElemsecMapper>;
 
 
-pub open spec fn spec_code() -> SpecCodeCombinator {
-    SpecCodeCombinator(
+pub open spec fn spec_elemsec() -> SpecElemsecCombinator {
+    SpecElemsecCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_code_cont0(deps)),
-        mapper: CodeMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_elemsec_cont0(deps)),
+        mapper: ElemsecMapper,
     })
 }
 
-pub open spec fn spec_code_cont0(deps: u64) -> AndThen<bytes::Variable, SpecFuncCombinator> {
+pub open spec fn spec_elemsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecElemsecContentCombinator> {
     let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_func())
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_elemsec_content())
 }
 
-impl View for CodeCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecFuncCombinator>;
+impl View for ElemsecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecElemsecContentCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_code_cont0(deps)
+            spec_elemsec_cont0(deps)
         }
     }
 }
 
                 
-pub fn code<'a>() -> (o: CodeCombinator)
-    ensures o@ == spec_code(),
+pub fn elemsec<'a>() -> (o: ElemsecCombinator)
+    ensures o@ == spec_elemsec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CodeCombinator(
+    let combinator = ElemsecCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, CodeCont0),
-        mapper: CodeMapper,
-    });
-    assert({
-        &&& combinator@ == spec_code()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, ElemsecCont0),
+        mapper: ElemsecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_elemsec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_code<'a>(input: &'a [u8]) -> (res: PResult<<CodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_elemsec<'a>(input: &'a [u8]) -> (res: PResult<<ElemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_code().spec_parse(input@) == Some((n as int, v@)),
-        spec_code().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_elemsec().spec_parse(input@) == Some((n as int, v@)),
+        spec_elemsec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_code().spec_parse(input@) is None,
-        spec_code().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_elemsec().spec_parse(input@) is None,
+        spec_elemsec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = code();
+    let combinator = elemsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_code<'a>(v: <CodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_elemsec<'a>(v: <ElemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_code().wf(v@),
+        spec_elemsec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_code().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_code().spec_serialize(v@))
+            &&& n == spec_elemsec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_elemsec().spec_serialize(v@))
         },
 {
-    let combinator = code();
+    let combinator = elemsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn code_len<'a>(v: <CodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn elemsec_len<'a>(v: <ElemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_code().wf(v@),
-        spec_code().spec_serialize(v@).len() <= usize::MAX,
+        spec_elemsec().wf(v@),
+        spec_elemsec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_code().spec_serialize(v@).len(),
+        serialize_len == spec_elemsec().spec_serialize(v@).len(),
 {
-    let combinator = code();
+    let combinator = elemsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct CodeCont0;
-type CodeCont0Type<'a, 'b> = &'b u64;
-type CodeCont0SType<'a, 'x> = &'x u64;
-type CodeCont0Input<'a, 'b, 'x> = POrSType<CodeCont0Type<'a, 'b>, CodeCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CodeCont0Input<'a, 'b, 'x>> for CodeCont0 {
-    type Output = AndThen<bytes::Variable, FuncCombinator>;
+pub struct ElemsecCont0;
+type ElemsecCont0Type<'a, 'b> = &'b u64;
+type ElemsecCont0SType<'a, 'x> = &'x u64;
+type ElemsecCont0Input<'a, 'b, 'x> = POrSType<ElemsecCont0Type<'a, 'b>, ElemsecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<ElemsecCont0Input<'a, 'b, 'x>> for ElemsecCont0 {
+    type Output = AndThen<bytes::Variable, ElemsecContentCombinator>;
 
-    open spec fn requires(&self, deps: CodeCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: ElemsecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: CodeCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_code_cont0(deps@)
+    open spec fn ensures(&self, deps: ElemsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_elemsec_cont0(deps@)
     }
 
-    fn apply(&self, deps: CodeCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: ElemsecCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), func())
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), elemsec_content())
             }
             POrSType::S(deps) => {
                 let size = deps;
                 let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), func())
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), elemsec_content())
             }
         }
     }
 }
                 
 
-pub struct SpecCodesecContent {
-    pub l: u64,
-    pub v: Seq<SpecCode>,
+pub struct SpecDatacountsec {
+    pub size: u64,
+    pub cont: u64,
 }
 
-pub type SpecCodesecContentInner = (u64, Seq<SpecCode>);
+pub type SpecDatacountsecInner = (u64, u64);
 
 
-impl SpecFrom<SpecCodesecContent> for SpecCodesecContentInner {
-    open spec fn spec_from(m: SpecCodesecContent) -> SpecCodesecContentInner {
-        (m.l, m.v)
+impl SpecFrom<SpecDatacountsec> for SpecDatacountsecInner {
+    open spec fn spec_from(m: SpecDatacountsec) -> SpecDatacountsecInner {
+        (m.size, m.cont)
     }
 }
 
-impl SpecFrom<SpecCodesecContentInner> for SpecCodesecContent {
-    open spec fn spec_from(m: SpecCodesecContentInner) -> SpecCodesecContent {
-        let (l, v) = m;
-        SpecCodesecContent { l, v }
+impl SpecFrom<SpecDatacountsecInner> for SpecDatacountsec {
+    open spec fn spec_from(m: SpecDatacountsecInner) -> SpecDatacountsec {
+        let (size, cont) = m;
+        SpecDatacountsec { size, cont }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct CodesecContent<'a> {
-    pub l: u64,
-    pub v: RepeatResult<Code<'a>>,
+pub struct Datacountsec {
+    pub size: u64,
+    pub cont: u64,
 }
 
-impl View for CodesecContent<'_> {
-    type V = SpecCodesecContent;
+impl View for Datacountsec {
+    type V = SpecDatacountsec;
 
     open spec fn view(&self) -> Self::V {
-        SpecCodesecContent {
-            l: self.l@,
-            v: self.v@,
+        SpecDatacountsec {
+            size: self.size@,
+            cont: self.cont@,
         }
     }
 }
-pub type CodesecContentInner<'a> = (u64, RepeatResult<Code<'a>>);
+pub type DatacountsecInner = (u64, u64);
 
-pub type CodesecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Code<'a>>);
-impl<'a> From<&'a CodesecContent<'a>> for CodesecContentInnerRef<'a> {
-    fn ex_from(m: &'a CodesecContent) -> CodesecContentInnerRef<'a> {
-        (&m.l, &m.v)
+pub type DatacountsecInnerRef<'a> = (&'a u64, &'a u64);
+impl<'a> From<&'a Datacountsec> for DatacountsecInnerRef<'a> {
+    fn ex_from(m: &'a Datacountsec) -> DatacountsecInnerRef<'a> {
+        (&m.size, &m.cont)
     }
 }
 
-impl<'a> From<CodesecContentInner<'a>> for CodesecContent<'a> {
-    fn ex_from(m: CodesecContentInner) -> CodesecContent {
-        let (l, v) = m;
-        CodesecContent { l, v }
+impl From<DatacountsecInner> for Datacountsec {
+    fn ex_from(m: DatacountsecInner) -> Datacountsec {
+        let (size, cont) = m;
+        Datacountsec { size, cont }
     }
 }
 
-pub struct CodesecContentMapper;
-impl View for CodesecContentMapper {
+pub struct DatacountsecMapper;
+impl View for DatacountsecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CodesecContentMapper {
-    type Src = SpecCodesecContentInner;
-    type Dst = SpecCodesecContent;
+impl SpecIso for DatacountsecMapper {
+    type Src = SpecDatacountsecInner;
+    type Dst = SpecDatacountsec;
 }
-impl SpecIsoProof for CodesecContentMapper {
+impl SpecIsoProof for DatacountsecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -22335,238 +22426,245 @@ impl SpecIsoProof for CodesecContentMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CodesecContentMapper {
-    type Src = CodesecContentInner<'a>;
-    type Dst = CodesecContent<'a>;
-    type RefSrc = CodesecContentInnerRef<'a>;
+impl<'a> Iso<'a> for DatacountsecMapper {
+    type Src = DatacountsecInner;
+    type Dst = Datacountsec;
+    type RefSrc = DatacountsecInnerRef<'a>;
 }
 
-pub struct SpecCodesecContentCombinator(pub SpecCodesecContentCombinatorAlias);
+pub struct SpecDatacountsecCombinator(pub SpecDatacountsecCombinatorAlias);
 
-impl SpecCombinator for SpecCodesecContentCombinator {
-    type Type = SpecCodesecContent;
+impl SpecCombinator for SpecDatacountsecCombinator {
+    type Type = SpecDatacountsec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCodesecContentCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCodesecContentCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecDatacountsecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDatacountsecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCodesecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecCodeCombinator>>, CodesecContentMapper>;
+pub type SpecDatacountsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, UnsignedLEB128>>, DatacountsecMapper>;
 
-pub struct CodesecContentCombinator(pub CodesecContentCombinatorAlias);
+pub struct DatacountsecCombinator(pub DatacountsecCombinatorAlias);
 
-impl View for CodesecContentCombinator {
-    type V = SpecCodesecContentCombinator;
-    open spec fn view(&self) -> Self::V { SpecCodesecContentCombinator(self.0@) }
+impl View for DatacountsecCombinator {
+    type V = SpecDatacountsecCombinator;
+    open spec fn view(&self) -> Self::V { SpecDatacountsecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CodesecContentCombinator {
-    type Type = CodesecContent<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DatacountsecCombinator {
+    type Type = Datacountsec;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CodesecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<CodeCombinator>, CodesecContentCont0>, CodesecContentMapper>;
+}
+pub type DatacountsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, UnsignedLEB128>, DatacountsecCont0>, DatacountsecMapper>;
 
 
-pub open spec fn spec_codesec_content() -> SpecCodesecContentCombinator {
-    SpecCodesecContentCombinator(
+pub open spec fn spec_datacountsec() -> SpecDatacountsecCombinator {
+    SpecDatacountsecCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_codesec_content_cont0(deps)),
-        mapper: CodesecContentMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_datacountsec_cont0(deps)),
+        mapper: DatacountsecMapper,
     })
 }
 
-pub open spec fn spec_codesec_content_cont0(deps: u64) -> RepeatN<SpecCodeCombinator> {
-    let l = deps;
-    RepeatN(spec_code(), l.spec_into())
+pub open spec fn spec_datacountsec_cont0(deps: u64) -> AndThen<bytes::Variable, UnsignedLEB128> {
+    let size = deps;
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), UnsignedLEB128)
 }
 
-impl View for CodesecContentCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecCodeCombinator>;
+impl View for DatacountsecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, UnsignedLEB128>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_codesec_content_cont0(deps)
+            spec_datacountsec_cont0(deps)
         }
     }
 }
 
                 
-pub fn codesec_content<'a>() -> (o: CodesecContentCombinator)
-    ensures o@ == spec_codesec_content(),
+pub fn datacountsec<'a>() -> (o: DatacountsecCombinator)
+    ensures o@ == spec_datacountsec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CodesecContentCombinator(
+    let combinator = DatacountsecCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, CodesecContentCont0),
-        mapper: CodesecContentMapper,
-    });
-    assert({
-        &&& combinator@ == spec_codesec_content()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, DatacountsecCont0),
+        mapper: DatacountsecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_datacountsec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_codesec_content<'a>(input: &'a [u8]) -> (res: PResult<<CodesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_datacountsec<'a>(input: &'a [u8]) -> (res: PResult<<DatacountsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_codesec_content().spec_parse(input@) == Some((n as int, v@)),
-        spec_codesec_content().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_datacountsec().spec_parse(input@) == Some((n as int, v@)),
+        spec_datacountsec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_codesec_content().spec_parse(input@) is None,
-        spec_codesec_content().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_datacountsec().spec_parse(input@) is None,
+        spec_datacountsec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = codesec_content();
+    let combinator = datacountsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_codesec_content<'a>(v: <CodesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_datacountsec<'a>(v: <DatacountsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_codesec_content().wf(v@),
+        spec_datacountsec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_codesec_content().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_codesec_content().spec_serialize(v@))
+            &&& n == spec_datacountsec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_datacountsec().spec_serialize(v@))
         },
 {
-    let combinator = codesec_content();
+    let combinator = datacountsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn codesec_content_len<'a>(v: <CodesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn datacountsec_len<'a>(v: <DatacountsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_codesec_content().wf(v@),
-        spec_codesec_content().spec_serialize(v@).len() <= usize::MAX,
+        spec_datacountsec().wf(v@),
+        spec_datacountsec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_codesec_content().spec_serialize(v@).len(),
+        serialize_len == spec_datacountsec().spec_serialize(v@).len(),
 {
-    let combinator = codesec_content();
+    let combinator = datacountsec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct CodesecContentCont0;
-type CodesecContentCont0Type<'a, 'b> = &'b u64;
-type CodesecContentCont0SType<'a, 'x> = &'x u64;
-type CodesecContentCont0Input<'a, 'b, 'x> = POrSType<CodesecContentCont0Type<'a, 'b>, CodesecContentCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CodesecContentCont0Input<'a, 'b, 'x>> for CodesecContentCont0 {
-    type Output = RepeatN<CodeCombinator>;
+pub struct DatacountsecCont0;
+type DatacountsecCont0Type<'a, 'b> = &'b u64;
+type DatacountsecCont0SType<'a, 'x> = &'x u64;
+type DatacountsecCont0Input<'a, 'b, 'x> = POrSType<DatacountsecCont0Type<'a, 'b>, DatacountsecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<DatacountsecCont0Input<'a, 'b, 'x>> for DatacountsecCont0 {
+    type Output = AndThen<bytes::Variable, UnsignedLEB128>;
 
-    open spec fn requires(&self, deps: CodesecContentCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: DatacountsecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: CodesecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_codesec_content_cont0(deps@)
+    open spec fn ensures(&self, deps: DatacountsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_datacountsec_cont0(deps@)
     }
 
-    fn apply(&self, deps: CodesecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: DatacountsecCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(code(), l.ex_into())
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), UnsignedLEB128)
             }
             POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(code(), l.ex_into())
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), UnsignedLEB128)
             }
         }
     }
 }
                 
 
-pub struct SpecTable {
-    pub ty: SpecTabletype,
+pub struct SpecLocalCompressed {
+    pub count: u64,
+    pub vt: SpecValtype,
 }
 
-pub type SpecTableInner = SpecTabletype;
+pub type SpecLocalCompressedInner = (u64, SpecValtype);
 
 
-impl SpecFrom<SpecTable> for SpecTableInner {
-    open spec fn spec_from(m: SpecTable) -> SpecTableInner {
-        m.ty
+impl SpecFrom<SpecLocalCompressed> for SpecLocalCompressedInner {
+    open spec fn spec_from(m: SpecLocalCompressed) -> SpecLocalCompressedInner {
+        (m.count, m.vt)
     }
 }
 
-impl SpecFrom<SpecTableInner> for SpecTable {
-    open spec fn spec_from(m: SpecTableInner) -> SpecTable {
-        let ty = m;
-        SpecTable { ty }
+impl SpecFrom<SpecLocalCompressedInner> for SpecLocalCompressed {
+    open spec fn spec_from(m: SpecLocalCompressedInner) -> SpecLocalCompressed {
+        let (count, vt) = m;
+        SpecLocalCompressed { count, vt }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Table {
-    pub ty: Tabletype,
+pub struct LocalCompressed {
+    pub count: u64,
+    pub vt: Valtype,
 }
 
-impl View for Table {
-    type V = SpecTable;
+impl View for LocalCompressed {
+    type V = SpecLocalCompressed;
 
     open spec fn view(&self) -> Self::V {
-        SpecTable {
-            ty: self.ty@,
+        SpecLocalCompressed {
+            count: self.count@,
+            vt: self.vt@,
         }
     }
 }
-pub type TableInner = Tabletype;
+pub type LocalCompressedInner = (u64, Valtype);
 
-pub type TableInnerRef<'a> = &'a Tabletype;
-impl<'a> From<&'a Table> for TableInnerRef<'a> {
-    fn ex_from(m: &'a Table) -> TableInnerRef<'a> {
-        &m.ty
+pub type LocalCompressedInnerRef<'a> = (&'a u64, &'a Valtype);
+impl<'a> From<&'a LocalCompressed> for LocalCompressedInnerRef<'a> {
+    fn ex_from(m: &'a LocalCompressed) -> LocalCompressedInnerRef<'a> {
+        (&m.count, &m.vt)
     }
 }
 
-impl From<TableInner> for Table {
-    fn ex_from(m: TableInner) -> Table {
-        let ty = m;
-        Table { ty }
+impl From<LocalCompressedInner> for LocalCompressed {
+    fn ex_from(m: LocalCompressedInner) -> LocalCompressed {
+        let (count, vt) = m;
+        LocalCompressed { count, vt }
     }
 }
 
-pub struct TableMapper;
-impl View for TableMapper {
+pub struct LocalCompressedMapper;
+impl View for LocalCompressedMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for TableMapper {
-    type Src = SpecTableInner;
-    type Dst = SpecTable;
+impl SpecIso for LocalCompressedMapper {
+    type Src = SpecLocalCompressedInner;
+    type Dst = SpecLocalCompressed;
 }
-impl SpecIsoProof for TableMapper {
+impl SpecIsoProof for LocalCompressedMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -22574,199 +22672,206 @@ impl SpecIsoProof for TableMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for TableMapper {
-    type Src = TableInner;
-    type Dst = Table;
-    type RefSrc = TableInnerRef<'a>;
+impl<'a> Iso<'a> for LocalCompressedMapper {
+    type Src = LocalCompressedInner;
+    type Dst = LocalCompressed;
+    type RefSrc = LocalCompressedInnerRef<'a>;
 }
+type SpecLocalCompressedCombinatorAlias1 = (UnsignedLEB128, SpecValtypeCombinator);
+pub struct SpecLocalCompressedCombinator(pub SpecLocalCompressedCombinatorAlias);
 
-pub struct SpecTableCombinator(pub SpecTableCombinatorAlias);
-
-impl SpecCombinator for SpecTableCombinator {
-    type Type = SpecTable;
+impl SpecCombinator for SpecLocalCompressedCombinator {
+    type Type = SpecLocalCompressed;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTableCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTableCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecLocalCompressedCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecLocalCompressedCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTableCombinatorAlias = Mapped<SpecTabletypeCombinator, TableMapper>;
+pub type SpecLocalCompressedCombinatorAlias = Mapped<SpecLocalCompressedCombinatorAlias1, LocalCompressedMapper>;
+type LocalCompressedCombinatorAlias1 = (UnsignedLEB128, ValtypeCombinator);
+pub struct LocalCompressedCombinator1(pub LocalCompressedCombinatorAlias1);
+impl View for LocalCompressedCombinator1 {
+    type V = SpecLocalCompressedCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(LocalCompressedCombinator1, LocalCompressedCombinatorAlias1);
 
-pub struct TableCombinator(pub TableCombinatorAlias);
+pub struct LocalCompressedCombinator(pub LocalCompressedCombinatorAlias);
 
-impl View for TableCombinator {
-    type V = SpecTableCombinator;
-    open spec fn view(&self) -> Self::V { SpecTableCombinator(self.0@) }
+impl View for LocalCompressedCombinator {
+    type V = SpecLocalCompressedCombinator;
+    open spec fn view(&self) -> Self::V { SpecLocalCompressedCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TableCombinator {
-    type Type = Table;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LocalCompressedCombinator {
+    type Type = LocalCompressed;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TableCombinatorAlias = Mapped<TabletypeCombinator, TableMapper>;
+}
+pub type LocalCompressedCombinatorAlias = Mapped<LocalCompressedCombinator1, LocalCompressedMapper>;
 
 
-pub open spec fn spec_table() -> SpecTableCombinator {
-    SpecTableCombinator(
+pub open spec fn spec_local_compressed() -> SpecLocalCompressedCombinator {
+    SpecLocalCompressedCombinator(
     Mapped {
-        inner: spec_tabletype(),
-        mapper: TableMapper,
+        inner: (UnsignedLEB128, spec_valtype()),
+        mapper: LocalCompressedMapper,
     })
 }
 
                 
-pub fn table<'a>() -> (o: TableCombinator)
-    ensures o@ == spec_table(),
+pub fn local_compressed<'a>() -> (o: LocalCompressedCombinator)
+    ensures o@ == spec_local_compressed(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = TableCombinator(
+    let combinator = LocalCompressedCombinator(
     Mapped {
-        inner: tabletype(),
-        mapper: TableMapper,
-    });
-    assert({
-        &&& combinator@ == spec_table()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: LocalCompressedCombinator1((UnsignedLEB128, valtype())),
+        mapper: LocalCompressedMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_local_compressed()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_table<'a>(input: &'a [u8]) -> (res: PResult<<TableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_local_compressed<'a>(input: &'a [u8]) -> (res: PResult<<LocalCompressedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_table().spec_parse(input@) == Some((n as int, v@)),
-        spec_table().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_local_compressed().spec_parse(input@) == Some((n as int, v@)),
+        spec_local_compressed().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_table().spec_parse(input@) is None,
-        spec_table().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_local_compressed().spec_parse(input@) is None,
+        spec_local_compressed().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = table();
+    let combinator = local_compressed();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_table<'a>(v: <TableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_local_compressed<'a>(v: <LocalCompressedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_table().wf(v@),
+        spec_local_compressed().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_table().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_table().spec_serialize(v@))
+            &&& n == spec_local_compressed().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_local_compressed().spec_serialize(v@))
         },
 {
-    let combinator = table();
+    let combinator = local_compressed();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn table_len<'a>(v: <TableCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn local_compressed_len<'a>(v: <LocalCompressedCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_table().wf(v@),
-        spec_table().spec_serialize(v@).len() <= usize::MAX,
+        spec_local_compressed().wf(v@),
+        spec_local_compressed().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_table().spec_serialize(v@).len(),
+        serialize_len == spec_local_compressed().spec_serialize(v@).len(),
 {
-    let combinator = table();
+    let combinator = local_compressed();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecMemsec {
-    pub size: u64,
-    pub cont: SpecMemsecContent,
+pub struct SpecLocals {
+    pub l: u64,
+    pub v: Seq<SpecLocalCompressed>,
 }
 
-pub type SpecMemsecInner = (u64, SpecMemsecContent);
+pub type SpecLocalsInner = (u64, Seq<SpecLocalCompressed>);
 
 
-impl SpecFrom<SpecMemsec> for SpecMemsecInner {
-    open spec fn spec_from(m: SpecMemsec) -> SpecMemsecInner {
-        (m.size, m.cont)
+impl SpecFrom<SpecLocals> for SpecLocalsInner {
+    open spec fn spec_from(m: SpecLocals) -> SpecLocalsInner {
+        (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecMemsecInner> for SpecMemsec {
-    open spec fn spec_from(m: SpecMemsecInner) -> SpecMemsec {
-        let (size, cont) = m;
-        SpecMemsec { size, cont }
+impl SpecFrom<SpecLocalsInner> for SpecLocals {
+    open spec fn spec_from(m: SpecLocalsInner) -> SpecLocals {
+        let (l, v) = m;
+        SpecLocals { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Memsec {
-    pub size: u64,
-    pub cont: MemsecContent,
+pub struct Locals {
+    pub l: u64,
+    pub v: RepeatResult<LocalCompressed>,
 }
 
-impl View for Memsec {
-    type V = SpecMemsec;
+impl View for Locals {
+    type V = SpecLocals;
 
     open spec fn view(&self) -> Self::V {
-        SpecMemsec {
-            size: self.size@,
-            cont: self.cont@,
+        SpecLocals {
+            l: self.l@,
+            v: self.v@,
         }
     }
 }
-pub type MemsecInner = (u64, MemsecContent);
+pub type LocalsInner = (u64, RepeatResult<LocalCompressed>);
 
-pub type MemsecInnerRef<'a> = (&'a u64, &'a MemsecContent);
-impl<'a> From<&'a Memsec> for MemsecInnerRef<'a> {
-    fn ex_from(m: &'a Memsec) -> MemsecInnerRef<'a> {
-        (&m.size, &m.cont)
+pub type LocalsInnerRef<'a> = (&'a u64, &'a RepeatResult<LocalCompressed>);
+impl<'a> From<&'a Locals> for LocalsInnerRef<'a> {
+    fn ex_from(m: &'a Locals) -> LocalsInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-impl From<MemsecInner> for Memsec {
-    fn ex_from(m: MemsecInner) -> Memsec {
-        let (size, cont) = m;
-        Memsec { size, cont }
+impl From<LocalsInner> for Locals {
+    fn ex_from(m: LocalsInner) -> Locals {
+        let (l, v) = m;
+        Locals { l, v }
     }
 }
 
-pub struct MemsecMapper;
-impl View for MemsecMapper {
+pub struct LocalsMapper;
+impl View for LocalsMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for MemsecMapper {
-    type Src = SpecMemsecInner;
-    type Dst = SpecMemsec;
+impl SpecIso for LocalsMapper {
+    type Src = SpecLocalsInner;
+    type Dst = SpecLocals;
 }
-impl SpecIsoProof for MemsecMapper {
+impl SpecIsoProof for LocalsMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -22774,241 +22879,245 @@ impl SpecIsoProof for MemsecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for MemsecMapper {
-    type Src = MemsecInner;
-    type Dst = Memsec;
-    type RefSrc = MemsecInnerRef<'a>;
+impl<'a> Iso<'a> for LocalsMapper {
+    type Src = LocalsInner;
+    type Dst = Locals;
+    type RefSrc = LocalsInnerRef<'a>;
 }
 
-pub struct SpecMemsecCombinator(pub SpecMemsecCombinatorAlias);
+pub struct SpecLocalsCombinator(pub SpecLocalsCombinatorAlias);
 
-impl SpecCombinator for SpecMemsecCombinator {
-    type Type = SpecMemsec;
+impl SpecCombinator for SpecLocalsCombinator {
+    type Type = SpecLocals;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecMemsecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecMemsecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecLocalsCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecLocalsCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecMemsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecMemsecContentCombinator>>, MemsecMapper>;
+pub type SpecLocalsCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecLocalCompressedCombinator>>, LocalsMapper>;
 
-pub struct MemsecCombinator(pub MemsecCombinatorAlias);
+pub struct LocalsCombinator(pub LocalsCombinatorAlias);
 
-impl View for MemsecCombinator {
-    type V = SpecMemsecCombinator;
-    open spec fn view(&self) -> Self::V { SpecMemsecCombinator(self.0@) }
+impl View for LocalsCombinator {
+    type V = SpecLocalsCombinator;
+    open spec fn view(&self) -> Self::V { SpecLocalsCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MemsecCombinator {
-    type Type = Memsec;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for LocalsCombinator {
+    type Type = Locals;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type MemsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, MemsecContentCombinator>, MemsecCont0>, MemsecMapper>;
+}
+pub type LocalsCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<LocalCompressedCombinator>, LocalsCont0>, LocalsMapper>;
 
 
-pub open spec fn spec_memsec() -> SpecMemsecCombinator {
-    SpecMemsecCombinator(
+pub open spec fn spec_locals() -> SpecLocalsCombinator {
+    SpecLocalsCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_memsec_cont0(deps)),
-        mapper: MemsecMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_locals_cont0(deps)),
+        mapper: LocalsMapper,
     })
 }
 
-pub open spec fn spec_memsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecMemsecContentCombinator> {
-    let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_memsec_content())
+pub open spec fn spec_locals_cont0(deps: u64) -> RepeatN<SpecLocalCompressedCombinator> {
+    let l = deps;
+    RepeatN(spec_local_compressed(), (usize::spec_from(l)) as usize)
 }
 
-impl View for MemsecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecMemsecContentCombinator>;
+impl View for LocalsCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecLocalCompressedCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_memsec_cont0(deps)
+            spec_locals_cont0(deps)
         }
     }
 }
 
                 
-pub fn memsec<'a>() -> (o: MemsecCombinator)
-    ensures o@ == spec_memsec(),
+pub fn locals<'a>() -> (o: LocalsCombinator)
+    ensures o@ == spec_locals(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = MemsecCombinator(
+    let combinator = LocalsCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, MemsecCont0),
-        mapper: MemsecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_memsec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, LocalsCont0),
+        mapper: LocalsMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_locals()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_memsec<'a>(input: &'a [u8]) -> (res: PResult<<MemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_locals<'a>(input: &'a [u8]) -> (res: PResult<<LocalsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_memsec().spec_parse(input@) == Some((n as int, v@)),
-        spec_memsec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_locals().spec_parse(input@) == Some((n as int, v@)),
+        spec_locals().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_memsec().spec_parse(input@) is None,
-        spec_memsec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_locals().spec_parse(input@) is None,
+        spec_locals().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = memsec();
+    let combinator = locals();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_memsec<'a>(v: <MemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_locals<'a>(v: <LocalsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_memsec().wf(v@),
+        spec_locals().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_memsec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_memsec().spec_serialize(v@))
+            &&& n == spec_locals().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_locals().spec_serialize(v@))
         },
 {
-    let combinator = memsec();
+    let combinator = locals();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn memsec_len<'a>(v: <MemsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn locals_len<'a>(v: <LocalsCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_memsec().wf(v@),
-        spec_memsec().spec_serialize(v@).len() <= usize::MAX,
+        spec_locals().wf(v@),
+        spec_locals().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_memsec().spec_serialize(v@).len(),
+        serialize_len == spec_locals().spec_serialize(v@).len(),
 {
-    let combinator = memsec();
+    let combinator = locals();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct MemsecCont0;
-type MemsecCont0Type<'a, 'b> = &'b u64;
-type MemsecCont0SType<'a, 'x> = &'x u64;
-type MemsecCont0Input<'a, 'b, 'x> = POrSType<MemsecCont0Type<'a, 'b>, MemsecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<MemsecCont0Input<'a, 'b, 'x>> for MemsecCont0 {
-    type Output = AndThen<bytes::Variable, MemsecContentCombinator>;
+pub struct LocalsCont0;
+type LocalsCont0Type<'a, 'b> = &'b u64;
+type LocalsCont0SType<'a, 'x> = &'x u64;
+type LocalsCont0Input<'a, 'b, 'x> = POrSType<LocalsCont0Type<'a, 'b>, LocalsCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<LocalsCont0Input<'a, 'b, 'x>> for LocalsCont0 {
+    type Output = RepeatN<LocalCompressedCombinator>;
 
-    open spec fn requires(&self, deps: MemsecCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: LocalsCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: MemsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_memsec_cont0(deps@)
+    open spec fn ensures(&self, deps: LocalsCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_locals_cont0(deps@)
     }
 
-    fn apply(&self, deps: MemsecCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: LocalsCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), memsec_content())
+                let l = deps;
+                let l = *l;
+                RepeatN(local_compressed(), (usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
-                let size = deps;
-                let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), memsec_content())
+                let l = deps;
+                let l = *l;
+                RepeatN(local_compressed(), (usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
 
-pub struct SpecDatacountsec {
-    pub size: u64,
-    pub cont: u64,
+pub struct SpecFunc {
+    pub locals: SpecLocals,
+    pub body: SpecExpr,
 }
 
-pub type SpecDatacountsecInner = (u64, u64);
+pub type SpecFuncInner = (SpecLocals, SpecExpr);
 
 
-impl SpecFrom<SpecDatacountsec> for SpecDatacountsecInner {
-    open spec fn spec_from(m: SpecDatacountsec) -> SpecDatacountsecInner {
-        (m.size, m.cont)
+impl SpecFrom<SpecFunc> for SpecFuncInner {
+    open spec fn spec_from(m: SpecFunc) -> SpecFuncInner {
+        (m.locals, m.body)
     }
 }
 
-impl SpecFrom<SpecDatacountsecInner> for SpecDatacountsec {
-    open spec fn spec_from(m: SpecDatacountsecInner) -> SpecDatacountsec {
-        let (size, cont) = m;
-        SpecDatacountsec { size, cont }
+impl SpecFrom<SpecFuncInner> for SpecFunc {
+    open spec fn spec_from(m: SpecFuncInner) -> SpecFunc {
+        let (locals, body) = m;
+        SpecFunc { locals, body }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Datacountsec {
-    pub size: u64,
-    pub cont: u64,
+pub struct Func<'a> {
+    pub locals: Locals,
+    pub body: Expr<'a>,
 }
 
-impl View for Datacountsec {
-    type V = SpecDatacountsec;
+impl View for Func<'_> {
+    type V = SpecFunc;
 
     open spec fn view(&self) -> Self::V {
-        SpecDatacountsec {
-            size: self.size@,
-            cont: self.cont@,
+        SpecFunc {
+            locals: self.locals@,
+            body: self.body@,
         }
     }
 }
-pub type DatacountsecInner = (u64, u64);
+pub type FuncInner<'a> = (Locals, Expr<'a>);
 
-pub type DatacountsecInnerRef<'a> = (&'a u64, &'a u64);
-impl<'a> From<&'a Datacountsec> for DatacountsecInnerRef<'a> {
-    fn ex_from(m: &'a Datacountsec) -> DatacountsecInnerRef<'a> {
-        (&m.size, &m.cont)
+pub type FuncInnerRef<'a> = (&'a Locals, &'a Expr<'a>);
+impl<'a> From<&'a Func<'a>> for FuncInnerRef<'a> {
+    fn ex_from(m: &'a Func) -> FuncInnerRef<'a> {
+        (&m.locals, &m.body)
     }
 }
 
-impl From<DatacountsecInner> for Datacountsec {
-    fn ex_from(m: DatacountsecInner) -> Datacountsec {
-        let (size, cont) = m;
-        Datacountsec { size, cont }
+impl<'a> From<FuncInner<'a>> for Func<'a> {
+    fn ex_from(m: FuncInner) -> Func {
+        let (locals, body) = m;
+        Func { locals, body }
     }
 }
 
-pub struct DatacountsecMapper;
-impl View for DatacountsecMapper {
+pub struct FuncMapper;
+impl View for FuncMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for DatacountsecMapper {
-    type Src = SpecDatacountsecInner;
-    type Dst = SpecDatacountsec;
+impl SpecIso for FuncMapper {
+    type Src = SpecFuncInner;
+    type Dst = SpecFunc;
 }
-impl SpecIsoProof for DatacountsecMapper {
+impl SpecIsoProof for FuncMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -23016,238 +23125,206 @@ impl SpecIsoProof for DatacountsecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for DatacountsecMapper {
-    type Src = DatacountsecInner;
-    type Dst = Datacountsec;
-    type RefSrc = DatacountsecInnerRef<'a>;
+impl<'a> Iso<'a> for FuncMapper {
+    type Src = FuncInner<'a>;
+    type Dst = Func<'a>;
+    type RefSrc = FuncInnerRef<'a>;
 }
+type SpecFuncCombinatorAlias1 = (SpecLocalsCombinator, SpecExprCombinator);
+pub struct SpecFuncCombinator(pub SpecFuncCombinatorAlias);
 
-pub struct SpecDatacountsecCombinator(pub SpecDatacountsecCombinatorAlias);
-
-impl SpecCombinator for SpecDatacountsecCombinator {
-    type Type = SpecDatacountsec;
+impl SpecCombinator for SpecFuncCombinator {
+    type Type = SpecFunc;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecDatacountsecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecDatacountsecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecFuncCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecFuncCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecDatacountsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, UnsignedLEB128>>, DatacountsecMapper>;
+pub type SpecFuncCombinatorAlias = Mapped<SpecFuncCombinatorAlias1, FuncMapper>;
+type FuncCombinatorAlias1 = (LocalsCombinator, ExprCombinator);
+pub struct FuncCombinator1(pub FuncCombinatorAlias1);
+impl View for FuncCombinator1 {
+    type V = SpecFuncCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(FuncCombinator1, FuncCombinatorAlias1);
 
-pub struct DatacountsecCombinator(pub DatacountsecCombinatorAlias);
+pub struct FuncCombinator(pub FuncCombinatorAlias);
 
-impl View for DatacountsecCombinator {
-    type V = SpecDatacountsecCombinator;
-    open spec fn view(&self) -> Self::V { SpecDatacountsecCombinator(self.0@) }
+impl View for FuncCombinator {
+    type V = SpecFuncCombinator;
+    open spec fn view(&self) -> Self::V { SpecFuncCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DatacountsecCombinator {
-    type Type = Datacountsec;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for FuncCombinator {
+    type Type = Func<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type DatacountsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, UnsignedLEB128>, DatacountsecCont0>, DatacountsecMapper>;
+}
+pub type FuncCombinatorAlias = Mapped<FuncCombinator1, FuncMapper>;
 
 
-pub open spec fn spec_datacountsec() -> SpecDatacountsecCombinator {
-    SpecDatacountsecCombinator(
+pub open spec fn spec_func() -> SpecFuncCombinator {
+    SpecFuncCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_datacountsec_cont0(deps)),
-        mapper: DatacountsecMapper,
+        inner: (spec_locals(), spec_expr()),
+        mapper: FuncMapper,
     })
 }
 
-pub open spec fn spec_datacountsec_cont0(deps: u64) -> AndThen<bytes::Variable, UnsignedLEB128> {
-    let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), UnsignedLEB128)
-}
-
-impl View for DatacountsecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, UnsignedLEB128>;
-
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_datacountsec_cont0(deps)
-        }
-    }
-}
-
                 
-pub fn datacountsec<'a>() -> (o: DatacountsecCombinator)
-    ensures o@ == spec_datacountsec(),
+pub fn func<'a>() -> (o: FuncCombinator)
+    ensures o@ == spec_func(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = DatacountsecCombinator(
+    let combinator = FuncCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, DatacountsecCont0),
-        mapper: DatacountsecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_datacountsec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: FuncCombinator1((locals(), expr())),
+        mapper: FuncMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_func()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_datacountsec<'a>(input: &'a [u8]) -> (res: PResult<<DatacountsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_func<'a>(input: &'a [u8]) -> (res: PResult<<FuncCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_datacountsec().spec_parse(input@) == Some((n as int, v@)),
-        spec_datacountsec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_func().spec_parse(input@) == Some((n as int, v@)),
+        spec_func().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_datacountsec().spec_parse(input@) is None,
-        spec_datacountsec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_func().spec_parse(input@) is None,
+        spec_func().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = datacountsec();
+    let combinator = func();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_datacountsec<'a>(v: <DatacountsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_func<'a>(v: <FuncCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_datacountsec().wf(v@),
+        spec_func().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_datacountsec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_datacountsec().spec_serialize(v@))
+            &&& n == spec_func().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_func().spec_serialize(v@))
         },
 {
-    let combinator = datacountsec();
+    let combinator = func();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn datacountsec_len<'a>(v: <DatacountsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn func_len<'a>(v: <FuncCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_datacountsec().wf(v@),
-        spec_datacountsec().spec_serialize(v@).len() <= usize::MAX,
+        spec_func().wf(v@),
+        spec_func().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_datacountsec().spec_serialize(v@).len(),
+        serialize_len == spec_func().spec_serialize(v@).len(),
 {
-    let combinator = datacountsec();
+    let combinator = func();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct DatacountsecCont0;
-type DatacountsecCont0Type<'a, 'b> = &'b u64;
-type DatacountsecCont0SType<'a, 'x> = &'x u64;
-type DatacountsecCont0Input<'a, 'b, 'x> = POrSType<DatacountsecCont0Type<'a, 'b>, DatacountsecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<DatacountsecCont0Input<'a, 'b, 'x>> for DatacountsecCont0 {
-    type Output = AndThen<bytes::Variable, UnsignedLEB128>;
-
-    open spec fn requires(&self, deps: DatacountsecCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: DatacountsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_datacountsec_cont0(deps@)
-    }
-
-    fn apply(&self, deps: DatacountsecCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), UnsignedLEB128)
-            }
-            POrSType::S(deps) => {
-                let size = deps;
-                let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), UnsignedLEB128)
-            }
-        }
-    }
-}
                 
 
-pub struct SpecStart {
-    pub func: SpecFuncidx,
+pub struct SpecCode {
+    pub size: u64,
+    pub code: SpecFunc,
 }
 
-pub type SpecStartInner = SpecFuncidx;
+pub type SpecCodeInner = (u64, SpecFunc);
 
 
-impl SpecFrom<SpecStart> for SpecStartInner {
-    open spec fn spec_from(m: SpecStart) -> SpecStartInner {
-        m.func
+impl SpecFrom<SpecCode> for SpecCodeInner {
+    open spec fn spec_from(m: SpecCode) -> SpecCodeInner {
+        (m.size, m.code)
     }
 }
 
-impl SpecFrom<SpecStartInner> for SpecStart {
-    open spec fn spec_from(m: SpecStartInner) -> SpecStart {
-        let func = m;
-        SpecStart { func }
+impl SpecFrom<SpecCodeInner> for SpecCode {
+    open spec fn spec_from(m: SpecCodeInner) -> SpecCode {
+        let (size, code) = m;
+        SpecCode { size, code }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Start {
-    pub func: Funcidx,
+pub struct Code<'a> {
+    pub size: u64,
+    pub code: Func<'a>,
 }
 
-impl View for Start {
-    type V = SpecStart;
+impl View for Code<'_> {
+    type V = SpecCode;
 
     open spec fn view(&self) -> Self::V {
-        SpecStart {
-            func: self.func@,
+        SpecCode {
+            size: self.size@,
+            code: self.code@,
         }
     }
 }
-pub type StartInner = Funcidx;
+pub type CodeInner<'a> = (u64, Func<'a>);
 
-pub type StartInnerRef<'a> = &'a Funcidx;
-impl<'a> From<&'a Start> for StartInnerRef<'a> {
-    fn ex_from(m: &'a Start) -> StartInnerRef<'a> {
-        &m.func
+pub type CodeInnerRef<'a> = (&'a u64, &'a Func<'a>);
+impl<'a> From<&'a Code<'a>> for CodeInnerRef<'a> {
+    fn ex_from(m: &'a Code) -> CodeInnerRef<'a> {
+        (&m.size, &m.code)
     }
 }
 
-impl From<StartInner> for Start {
-    fn ex_from(m: StartInner) -> Start {
-        let func = m;
-        Start { func }
+impl<'a> From<CodeInner<'a>> for Code<'a> {
+    fn ex_from(m: CodeInner) -> Code {
+        let (size, code) = m;
+        Code { size, code }
     }
 }
 
-pub struct StartMapper;
-impl View for StartMapper {
+pub struct CodeMapper;
+impl View for CodeMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for StartMapper {
-    type Src = SpecStartInner;
-    type Dst = SpecStart;
+impl SpecIso for CodeMapper {
+    type Src = SpecCodeInner;
+    type Dst = SpecCode;
 }
-impl SpecIsoProof for StartMapper {
+impl SpecIsoProof for CodeMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -23255,199 +23332,245 @@ impl SpecIsoProof for StartMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for StartMapper {
-    type Src = StartInner;
-    type Dst = Start;
-    type RefSrc = StartInnerRef<'a>;
+impl<'a> Iso<'a> for CodeMapper {
+    type Src = CodeInner<'a>;
+    type Dst = Code<'a>;
+    type RefSrc = CodeInnerRef<'a>;
 }
 
-pub struct SpecStartCombinator(pub SpecStartCombinatorAlias);
+pub struct SpecCodeCombinator(pub SpecCodeCombinatorAlias);
 
-impl SpecCombinator for SpecStartCombinator {
-    type Type = SpecStart;
+impl SpecCombinator for SpecCodeCombinator {
+    type Type = SpecCode;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecStartCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecStartCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCodeCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCodeCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecStartCombinatorAlias = Mapped<SpecFuncidxCombinator, StartMapper>;
+pub type SpecCodeCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecFuncCombinator>>, CodeMapper>;
 
-pub struct StartCombinator(pub StartCombinatorAlias);
+pub struct CodeCombinator(pub CodeCombinatorAlias);
 
-impl View for StartCombinator {
-    type V = SpecStartCombinator;
-    open spec fn view(&self) -> Self::V { SpecStartCombinator(self.0@) }
+impl View for CodeCombinator {
+    type V = SpecCodeCombinator;
+    open spec fn view(&self) -> Self::V { SpecCodeCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for StartCombinator {
-    type Type = Start;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CodeCombinator {
+    type Type = Code<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type StartCombinatorAlias = Mapped<FuncidxCombinator, StartMapper>;
+}
+pub type CodeCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, FuncCombinator>, CodeCont0>, CodeMapper>;
 
 
-pub open spec fn spec_start() -> SpecStartCombinator {
-    SpecStartCombinator(
+pub open spec fn spec_code() -> SpecCodeCombinator {
+    SpecCodeCombinator(
     Mapped {
-        inner: spec_funcidx(),
-        mapper: StartMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_code_cont0(deps)),
+        mapper: CodeMapper,
     })
 }
 
+pub open spec fn spec_code_cont0(deps: u64) -> AndThen<bytes::Variable, SpecFuncCombinator> {
+    let size = deps;
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_func())
+}
+
+impl View for CodeCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecFuncCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_code_cont0(deps)
+        }
+    }
+}
+
                 
-pub fn start<'a>() -> (o: StartCombinator)
-    ensures o@ == spec_start(),
+pub fn code<'a>() -> (o: CodeCombinator)
+    ensures o@ == spec_code(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = StartCombinator(
+    let combinator = CodeCombinator(
     Mapped {
-        inner: funcidx(),
-        mapper: StartMapper,
-    });
-    assert({
-        &&& combinator@ == spec_start()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, CodeCont0),
+        mapper: CodeMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_code()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_start<'a>(input: &'a [u8]) -> (res: PResult<<StartCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_code<'a>(input: &'a [u8]) -> (res: PResult<<CodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_start().spec_parse(input@) == Some((n as int, v@)),
-        spec_start().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_code().spec_parse(input@) == Some((n as int, v@)),
+        spec_code().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_start().spec_parse(input@) is None,
-        spec_start().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_code().spec_parse(input@) is None,
+        spec_code().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = start();
+    let combinator = code();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_start<'a>(v: <StartCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_code<'a>(v: <CodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_start().wf(v@),
+        spec_code().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_start().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_start().spec_serialize(v@))
+            &&& n == spec_code().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_code().spec_serialize(v@))
         },
 {
-    let combinator = start();
+    let combinator = code();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn start_len<'a>(v: <StartCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn code_len<'a>(v: <CodeCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_start().wf(v@),
-        spec_start().spec_serialize(v@).len() <= usize::MAX,
+        spec_code().wf(v@),
+        spec_code().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_start().spec_serialize(v@).len(),
+        serialize_len == spec_code().spec_serialize(v@).len(),
 {
-    let combinator = start();
+    let combinator = code();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-                
-
-pub struct SpecCodesec {
-    pub size: u64,
-    pub cont: SpecCodesecContent,
-}
+pub struct CodeCont0;
+type CodeCont0Type<'a, 'b> = &'b u64;
+type CodeCont0SType<'a, 'x> = &'x u64;
+type CodeCont0Input<'a, 'b, 'x> = POrSType<CodeCont0Type<'a, 'b>, CodeCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CodeCont0Input<'a, 'b, 'x>> for CodeCont0 {
+    type Output = AndThen<bytes::Variable, FuncCombinator>;
 
-pub type SpecCodesecInner = (u64, SpecCodesecContent);
+    open spec fn requires(&self, deps: CodeCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
+    open spec fn ensures(&self, deps: CodeCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_code_cont0(deps@)
+    }
 
-impl SpecFrom<SpecCodesec> for SpecCodesecInner {
-    open spec fn spec_from(m: SpecCodesec) -> SpecCodesecInner {
-        (m.size, m.cont)
+    fn apply(&self, deps: CodeCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), func())
+            }
+            POrSType::S(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), func())
+            }
+        }
     }
 }
+                
 
-impl SpecFrom<SpecCodesecInner> for SpecCodesec {
-    open spec fn spec_from(m: SpecCodesecInner) -> SpecCodesec {
-        let (size, cont) = m;
-        SpecCodesec { size, cont }
+pub struct SpecCodesecContent {
+    pub l: u64,
+    pub v: Seq<SpecCode>,
+}
+
+pub type SpecCodesecContentInner = (u64, Seq<SpecCode>);
+
+
+impl SpecFrom<SpecCodesecContent> for SpecCodesecContentInner {
+    open spec fn spec_from(m: SpecCodesecContent) -> SpecCodesecContentInner {
+        (m.l, m.v)
+    }
+}
+
+impl SpecFrom<SpecCodesecContentInner> for SpecCodesecContent {
+    open spec fn spec_from(m: SpecCodesecContentInner) -> SpecCodesecContent {
+        let (l, v) = m;
+        SpecCodesecContent { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Codesec<'a> {
-    pub size: u64,
-    pub cont: CodesecContent<'a>,
+pub struct CodesecContent<'a> {
+    pub l: u64,
+    pub v: RepeatResult<Code<'a>>,
 }
 
-impl View for Codesec<'_> {
-    type V = SpecCodesec;
+impl View for CodesecContent<'_> {
+    type V = SpecCodesecContent;
 
     open spec fn view(&self) -> Self::V {
-        SpecCodesec {
-            size: self.size@,
-            cont: self.cont@,
+        SpecCodesecContent {
+            l: self.l@,
+            v: self.v@,
         }
     }
 }
-pub type CodesecInner<'a> = (u64, CodesecContent<'a>);
+pub type CodesecContentInner<'a> = (u64, RepeatResult<Code<'a>>);
 
-pub type CodesecInnerRef<'a> = (&'a u64, &'a CodesecContent<'a>);
-impl<'a> From<&'a Codesec<'a>> for CodesecInnerRef<'a> {
-    fn ex_from(m: &'a Codesec) -> CodesecInnerRef<'a> {
-        (&m.size, &m.cont)
+pub type CodesecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Code<'a>>);
+impl<'a> From<&'a CodesecContent<'a>> for CodesecContentInnerRef<'a> {
+    fn ex_from(m: &'a CodesecContent) -> CodesecContentInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-impl<'a> From<CodesecInner<'a>> for Codesec<'a> {
-    fn ex_from(m: CodesecInner) -> Codesec {
-        let (size, cont) = m;
-        Codesec { size, cont }
+impl<'a> From<CodesecContentInner<'a>> for CodesecContent<'a> {
+    fn ex_from(m: CodesecContentInner) -> CodesecContent {
+        let (l, v) = m;
+        CodesecContent { l, v }
     }
 }
 
-pub struct CodesecMapper;
-impl View for CodesecMapper {
+pub struct CodesecContentMapper;
+impl View for CodesecContentMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CodesecMapper {
-    type Src = SpecCodesecInner;
-    type Dst = SpecCodesec;
+impl SpecIso for CodesecContentMapper {
+    type Src = SpecCodesecContentInner;
+    type Dst = SpecCodesecContent;
 }
-impl SpecIsoProof for CodesecMapper {
+impl SpecIsoProof for CodesecContentMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -23455,309 +23578,245 @@ impl SpecIsoProof for CodesecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CodesecMapper {
-    type Src = CodesecInner<'a>;
-    type Dst = Codesec<'a>;
-    type RefSrc = CodesecInnerRef<'a>;
+impl<'a> Iso<'a> for CodesecContentMapper {
+    type Src = CodesecContentInner<'a>;
+    type Dst = CodesecContent<'a>;
+    type RefSrc = CodesecContentInnerRef<'a>;
 }
 
-pub struct SpecCodesecCombinator(pub SpecCodesecCombinatorAlias);
+pub struct SpecCodesecContentCombinator(pub SpecCodesecContentCombinatorAlias);
 
-impl SpecCombinator for SpecCodesecCombinator {
-    type Type = SpecCodesec;
+impl SpecCombinator for SpecCodesecContentCombinator {
+    type Type = SpecCodesecContent;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCodesecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCodesecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCodesecContentCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCodesecContentCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCodesecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecCodesecContentCombinator>>, CodesecMapper>;
+pub type SpecCodesecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecCodeCombinator>>, CodesecContentMapper>;
 
-pub struct CodesecCombinator(pub CodesecCombinatorAlias);
+pub struct CodesecContentCombinator(pub CodesecContentCombinatorAlias);
 
-impl View for CodesecCombinator {
-    type V = SpecCodesecCombinator;
-    open spec fn view(&self) -> Self::V { SpecCodesecCombinator(self.0@) }
+impl View for CodesecContentCombinator {
+    type V = SpecCodesecContentCombinator;
+    open spec fn view(&self) -> Self::V { SpecCodesecContentCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CodesecCombinator {
-    type Type = Codesec<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CodesecContentCombinator {
+    type Type = CodesecContent<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CodesecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, CodesecContentCombinator>, CodesecCont0>, CodesecMapper>;
+}
+pub type CodesecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<CodeCombinator>, CodesecContentCont0>, CodesecContentMapper>;
 
 
-pub open spec fn spec_codesec() -> SpecCodesecCombinator {
-    SpecCodesecCombinator(
+pub open spec fn spec_codesec_content() -> SpecCodesecContentCombinator {
+    SpecCodesecContentCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_codesec_cont0(deps)),
-        mapper: CodesecMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_codesec_content_cont0(deps)),
+        mapper: CodesecContentMapper,
     })
 }
 
-pub open spec fn spec_codesec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecCodesecContentCombinator> {
-    let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_codesec_content())
+pub open spec fn spec_codesec_content_cont0(deps: u64) -> RepeatN<SpecCodeCombinator> {
+    let l = deps;
+    RepeatN(spec_code(), (usize::spec_from(l)) as usize)
 }
 
-impl View for CodesecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecCodesecContentCombinator>;
+impl View for CodesecContentCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecCodeCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_codesec_cont0(deps)
+            spec_codesec_content_cont0(deps)
         }
     }
 }
 
                 
-pub fn codesec<'a>() -> (o: CodesecCombinator)
-    ensures o@ == spec_codesec(),
+pub fn codesec_content<'a>() -> (o: CodesecContentCombinator)
+    ensures o@ == spec_codesec_content(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CodesecCombinator(
+    let combinator = CodesecContentCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, CodesecCont0),
-        mapper: CodesecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_codesec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, CodesecContentCont0),
+        mapper: CodesecContentMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_codesec_content()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_codesec<'a>(input: &'a [u8]) -> (res: PResult<<CodesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_codesec_content<'a>(input: &'a [u8]) -> (res: PResult<<CodesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_codesec().spec_parse(input@) == Some((n as int, v@)),
-        spec_codesec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_codesec_content().spec_parse(input@) == Some((n as int, v@)),
+        spec_codesec_content().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_codesec().spec_parse(input@) is None,
-        spec_codesec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_codesec_content().spec_parse(input@) is None,
+        spec_codesec_content().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = codesec();
+    let combinator = codesec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_codesec<'a>(v: <CodesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_codesec_content<'a>(v: <CodesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_codesec().wf(v@),
+        spec_codesec_content().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_codesec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_codesec().spec_serialize(v@))
+            &&& n == spec_codesec_content().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_codesec_content().spec_serialize(v@))
         },
 {
-    let combinator = codesec();
+    let combinator = codesec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn codesec_len<'a>(v: <CodesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn codesec_content_len<'a>(v: <CodesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_codesec().wf(v@),
-        spec_codesec().spec_serialize(v@).len() <= usize::MAX,
+        spec_codesec_content().wf(v@),
+        spec_codesec_content().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_codesec().spec_serialize(v@).len(),
+        serialize_len == spec_codesec_content().spec_serialize(v@).len(),
 {
-    let combinator = codesec();
+    let combinator = codesec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct CodesecCont0;
-type CodesecCont0Type<'a, 'b> = &'b u64;
-type CodesecCont0SType<'a, 'x> = &'x u64;
-type CodesecCont0Input<'a, 'b, 'x> = POrSType<CodesecCont0Type<'a, 'b>, CodesecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CodesecCont0Input<'a, 'b, 'x>> for CodesecCont0 {
-    type Output = AndThen<bytes::Variable, CodesecContentCombinator>;
+pub struct CodesecContentCont0;
+type CodesecContentCont0Type<'a, 'b> = &'b u64;
+type CodesecContentCont0SType<'a, 'x> = &'x u64;
+type CodesecContentCont0Input<'a, 'b, 'x> = POrSType<CodesecContentCont0Type<'a, 'b>, CodesecContentCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CodesecContentCont0Input<'a, 'b, 'x>> for CodesecContentCont0 {
+    type Output = RepeatN<CodeCombinator>;
 
-    open spec fn requires(&self, deps: CodesecCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: CodesecContentCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: CodesecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_codesec_cont0(deps@)
+    open spec fn ensures(&self, deps: CodesecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_codesec_content_cont0(deps@)
     }
 
-    fn apply(&self, deps: CodesecCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: CodesecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), codesec_content())
+                let l = deps;
+                let l = *l;
+                RepeatN(code(), (usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
-                let size = deps;
-                let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), codesec_content())
+                let l = deps;
+                let l = *l;
+                RepeatN(code(), (usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
-pub type SpecELEMKIND = u8;
-pub type ELEMKIND = u8;
-pub type ELEMKINDRef<'a> = &'a u8;
-
-pub const ELEMKIND_CONST: u8 = 0;
-pub type SpecELEMKINDCombinator = Refined<U8, TagPred<u8>>;
-pub type ELEMKINDCombinator = Refined<U8, TagPred<u8>>;
-
-
-pub open spec fn spec_ELEMKIND() -> SpecELEMKINDCombinator {
-    Refined { inner: U8, predicate: TagPred(ELEMKIND_CONST) }
-}
-
-pub fn ELEMKIND<'a>() -> (o: ELEMKINDCombinator)
-    ensures o@ == spec_ELEMKIND(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = Refined { inner: U8, predicate: TagPred(ELEMKIND_CONST) };
-    assert({
-        &&& combinator@ == spec_ELEMKIND()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
-}
-
-pub fn parse_ELEMKIND<'a>(input: &'a [u8]) -> (res: PResult<<ELEMKINDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_ELEMKIND().spec_parse(input@) == Some((n as int, v@)),
-        spec_ELEMKIND().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_ELEMKIND().spec_parse(input@) is None,
-        spec_ELEMKIND().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = ELEMKIND();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
-}
-
-pub fn serialize_ELEMKIND<'a>(v: <ELEMKINDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_ELEMKIND().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_ELEMKIND().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_ELEMKIND().spec_serialize(v@))
-        },
-{
-    let combinator = ELEMKIND();
-    combinator.serialize(v, data, pos)
-}
 
-pub fn ELEMKIND_len<'a>(v: <ELEMKINDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_ELEMKIND().wf(v@),
-        spec_ELEMKIND().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_ELEMKIND().spec_serialize(v@).len(),
-{
-    let combinator = ELEMKIND();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
-}
-
-
-pub struct SpecTablesecContent {
-    pub l: u64,
-    pub v: Seq<SpecTable>,
+pub struct SpecCodesec {
+    pub size: u64,
+    pub cont: SpecCodesecContent,
 }
 
-pub type SpecTablesecContentInner = (u64, Seq<SpecTable>);
+pub type SpecCodesecInner = (u64, SpecCodesecContent);
 
 
-impl SpecFrom<SpecTablesecContent> for SpecTablesecContentInner {
-    open spec fn spec_from(m: SpecTablesecContent) -> SpecTablesecContentInner {
-        (m.l, m.v)
+impl SpecFrom<SpecCodesec> for SpecCodesecInner {
+    open spec fn spec_from(m: SpecCodesec) -> SpecCodesecInner {
+        (m.size, m.cont)
     }
 }
 
-impl SpecFrom<SpecTablesecContentInner> for SpecTablesecContent {
-    open spec fn spec_from(m: SpecTablesecContentInner) -> SpecTablesecContent {
-        let (l, v) = m;
-        SpecTablesecContent { l, v }
+impl SpecFrom<SpecCodesecInner> for SpecCodesec {
+    open spec fn spec_from(m: SpecCodesecInner) -> SpecCodesec {
+        let (size, cont) = m;
+        SpecCodesec { size, cont }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct TablesecContent {
-    pub l: u64,
-    pub v: RepeatResult<Table>,
+pub struct Codesec<'a> {
+    pub size: u64,
+    pub cont: CodesecContent<'a>,
 }
 
-impl View for TablesecContent {
-    type V = SpecTablesecContent;
+impl View for Codesec<'_> {
+    type V = SpecCodesec;
 
     open spec fn view(&self) -> Self::V {
-        SpecTablesecContent {
-            l: self.l@,
-            v: self.v@,
+        SpecCodesec {
+            size: self.size@,
+            cont: self.cont@,
         }
     }
 }
-pub type TablesecContentInner = (u64, RepeatResult<Table>);
+pub type CodesecInner<'a> = (u64, CodesecContent<'a>);
 
-pub type TablesecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Table>);
-impl<'a> From<&'a TablesecContent> for TablesecContentInnerRef<'a> {
-    fn ex_from(m: &'a TablesecContent) -> TablesecContentInnerRef<'a> {
-        (&m.l, &m.v)
+pub type CodesecInnerRef<'a> = (&'a u64, &'a CodesecContent<'a>);
+impl<'a> From<&'a Codesec<'a>> for CodesecInnerRef<'a> {
+    fn ex_from(m: &'a Codesec) -> CodesecInnerRef<'a> {
+        (&m.size, &m.cont)
     }
 }
 
-impl From<TablesecContentInner> for TablesecContent {
-    fn ex_from(m: TablesecContentInner) -> TablesecContent {
-        let (l, v) = m;
-        TablesecContent { l, v }
+impl<'a> From<CodesecInner<'a>> for Codesec<'a> {
+    fn ex_from(m: CodesecInner) -> Codesec {
+        let (size, cont) = m;
+        Codesec { size, cont }
     }
 }
 
-pub struct TablesecContentMapper;
-impl View for TablesecContentMapper {
+pub struct CodesecMapper;
+impl View for CodesecMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for TablesecContentMapper {
-    type Src = SpecTablesecContentInner;
-    type Dst = SpecTablesecContent;
+impl SpecIso for CodesecMapper {
+    type Src = SpecCodesecInner;
+    type Dst = SpecCodesec;
 }
-impl SpecIsoProof for TablesecContentMapper {
+impl SpecIsoProof for CodesecMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -23765,566 +23824,597 @@ impl SpecIsoProof for TablesecContentMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for TablesecContentMapper {
-    type Src = TablesecContentInner;
-    type Dst = TablesecContent;
-    type RefSrc = TablesecContentInnerRef<'a>;
+impl<'a> Iso<'a> for CodesecMapper {
+    type Src = CodesecInner<'a>;
+    type Dst = Codesec<'a>;
+    type RefSrc = CodesecInnerRef<'a>;
 }
 
-pub struct SpecTablesecContentCombinator(pub SpecTablesecContentCombinatorAlias);
+pub struct SpecCodesecCombinator(pub SpecCodesecCombinatorAlias);
 
-impl SpecCombinator for SpecTablesecContentCombinator {
-    type Type = SpecTablesecContent;
+impl SpecCombinator for SpecCodesecCombinator {
+    type Type = SpecCodesec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTablesecContentCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTablesecContentCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCodesecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCodesecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTablesecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecTableCombinator>>, TablesecContentMapper>;
+pub type SpecCodesecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecCodesecContentCombinator>>, CodesecMapper>;
 
-pub struct TablesecContentCombinator(pub TablesecContentCombinatorAlias);
+pub struct CodesecCombinator(pub CodesecCombinatorAlias);
 
-impl View for TablesecContentCombinator {
-    type V = SpecTablesecContentCombinator;
-    open spec fn view(&self) -> Self::V { SpecTablesecContentCombinator(self.0@) }
+impl View for CodesecCombinator {
+    type V = SpecCodesecCombinator;
+    open spec fn view(&self) -> Self::V { SpecCodesecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TablesecContentCombinator {
-    type Type = TablesecContent;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CodesecCombinator {
+    type Type = Codesec<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TablesecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<TableCombinator>, TablesecContentCont0>, TablesecContentMapper>;
+}
+pub type CodesecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, CodesecContentCombinator>, CodesecCont0>, CodesecMapper>;
 
 
-pub open spec fn spec_tablesec_content() -> SpecTablesecContentCombinator {
-    SpecTablesecContentCombinator(
+pub open spec fn spec_codesec() -> SpecCodesecCombinator {
+    SpecCodesecCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_tablesec_content_cont0(deps)),
-        mapper: TablesecContentMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_codesec_cont0(deps)),
+        mapper: CodesecMapper,
     })
 }
 
-pub open spec fn spec_tablesec_content_cont0(deps: u64) -> RepeatN<SpecTableCombinator> {
-    let l = deps;
-    RepeatN(spec_table(), l.spec_into())
+pub open spec fn spec_codesec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecCodesecContentCombinator> {
+    let size = deps;
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_codesec_content())
 }
 
-impl View for TablesecContentCont0 {
-    type V = spec_fn(u64) -> RepeatN<SpecTableCombinator>;
+impl View for CodesecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecCodesecContentCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_tablesec_content_cont0(deps)
+            spec_codesec_cont0(deps)
         }
     }
 }
 
                 
-pub fn tablesec_content<'a>() -> (o: TablesecContentCombinator)
-    ensures o@ == spec_tablesec_content(),
+pub fn codesec<'a>() -> (o: CodesecCombinator)
+    ensures o@ == spec_codesec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = TablesecContentCombinator(
+    let combinator = CodesecCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, TablesecContentCont0),
-        mapper: TablesecContentMapper,
-    });
-    assert({
-        &&& combinator@ == spec_tablesec_content()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, CodesecCont0),
+        mapper: CodesecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_codesec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_tablesec_content<'a>(input: &'a [u8]) -> (res: PResult<<TablesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_codesec<'a>(input: &'a [u8]) -> (res: PResult<<CodesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_tablesec_content().spec_parse(input@) == Some((n as int, v@)),
-        spec_tablesec_content().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_codesec().spec_parse(input@) == Some((n as int, v@)),
+        spec_codesec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_tablesec_content().spec_parse(input@) is None,
-        spec_tablesec_content().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_codesec().spec_parse(input@) is None,
+        spec_codesec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = tablesec_content();
+    let combinator = codesec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_tablesec_content<'a>(v: <TablesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_codesec<'a>(v: <CodesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_tablesec_content().wf(v@),
+        spec_codesec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_tablesec_content().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_tablesec_content().spec_serialize(v@))
+            &&& n == spec_codesec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_codesec().spec_serialize(v@))
         },
 {
-    let combinator = tablesec_content();
+    let combinator = codesec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn tablesec_content_len<'a>(v: <TablesecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn codesec_len<'a>(v: <CodesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_tablesec_content().wf(v@),
-        spec_tablesec_content().spec_serialize(v@).len() <= usize::MAX,
+        spec_codesec().wf(v@),
+        spec_codesec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_tablesec_content().spec_serialize(v@).len(),
+        serialize_len == spec_codesec().spec_serialize(v@).len(),
 {
-    let combinator = tablesec_content();
+    let combinator = codesec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct TablesecContentCont0;
-type TablesecContentCont0Type<'a, 'b> = &'b u64;
-type TablesecContentCont0SType<'a, 'x> = &'x u64;
-type TablesecContentCont0Input<'a, 'b, 'x> = POrSType<TablesecContentCont0Type<'a, 'b>, TablesecContentCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<TablesecContentCont0Input<'a, 'b, 'x>> for TablesecContentCont0 {
-    type Output = RepeatN<TableCombinator>;
+pub struct CodesecCont0;
+type CodesecCont0Type<'a, 'b> = &'b u64;
+type CodesecCont0SType<'a, 'x> = &'x u64;
+type CodesecCont0Input<'a, 'b, 'x> = POrSType<CodesecCont0Type<'a, 'b>, CodesecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CodesecCont0Input<'a, 'b, 'x>> for CodesecCont0 {
+    type Output = AndThen<bytes::Variable, CodesecContentCombinator>;
 
-    open spec fn requires(&self, deps: TablesecContentCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: CodesecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: TablesecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_tablesec_content_cont0(deps@)
+    open spec fn ensures(&self, deps: CodesecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_codesec_cont0(deps@)
     }
 
-    fn apply(&self, deps: TablesecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: CodesecCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let l = *deps;
-                RepeatN(table(), l.ex_into())
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), codesec_content())
             }
             POrSType::S(deps) => {
-                let l = deps;
-                let l = *l;
-                RepeatN(table(), l.ex_into())
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), codesec_content())
             }
         }
     }
 }
                 
-pub type SpecMyCustomSection = SpecByteVec;
-pub type MyCustomSection = ByteVec;
-pub type MyCustomSectionRef<'a> = &'a ByteVec;
 
+pub struct SpecActiveData0 {
+    pub offset: SpecExpr,
+    pub init: SpecByteVec,
+}
 
-pub struct SpecMyCustomSectionCombinator(pub SpecMyCustomSectionCombinatorAlias);
+pub type SpecActiveData0Inner = (SpecExpr, SpecByteVec);
 
-impl SpecCombinator for SpecMyCustomSectionCombinator {
-    type Type = SpecMyCustomSection;
+
+impl SpecFrom<SpecActiveData0> for SpecActiveData0Inner {
+    open spec fn spec_from(m: SpecActiveData0) -> SpecActiveData0Inner {
+        (m.offset, m.init)
+    }
+}
+
+impl SpecFrom<SpecActiveData0Inner> for SpecActiveData0 {
+    open spec fn spec_from(m: SpecActiveData0Inner) -> SpecActiveData0 {
+        let (offset, init) = m;
+        SpecActiveData0 { offset, init }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct ActiveData0<'a> {
+    pub offset: Expr<'a>,
+    pub init: ByteVec,
+}
+
+impl View for ActiveData0<'_> {
+    type V = SpecActiveData0;
+
+    open spec fn view(&self) -> Self::V {
+        SpecActiveData0 {
+            offset: self.offset@,
+            init: self.init@,
+        }
+    }
+}
+pub type ActiveData0Inner<'a> = (Expr<'a>, ByteVec);
+
+pub type ActiveData0InnerRef<'a> = (&'a Expr<'a>, &'a ByteVec);
+impl<'a> From<&'a ActiveData0<'a>> for ActiveData0InnerRef<'a> {
+    fn ex_from(m: &'a ActiveData0) -> ActiveData0InnerRef<'a> {
+        (&m.offset, &m.init)
+    }
+}
+
+impl<'a> From<ActiveData0Inner<'a>> for ActiveData0<'a> {
+    fn ex_from(m: ActiveData0Inner) -> ActiveData0 {
+        let (offset, init) = m;
+        ActiveData0 { offset, init }
+    }
+}
+
+pub struct ActiveData0Mapper;
+impl View for ActiveData0Mapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for ActiveData0Mapper {
+    type Src = SpecActiveData0Inner;
+    type Dst = SpecActiveData0;
+}
+impl SpecIsoProof for ActiveData0Mapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for ActiveData0Mapper {
+    type Src = ActiveData0Inner<'a>;
+    type Dst = ActiveData0<'a>;
+    type RefSrc = ActiveData0InnerRef<'a>;
+}
+type SpecActiveData0CombinatorAlias1 = (SpecExprCombinator, SpecByteVecCombinator);
+pub struct SpecActiveData0Combinator(pub SpecActiveData0CombinatorAlias);
+
+impl SpecCombinator for SpecActiveData0Combinator {
+    type Type = SpecActiveData0;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecMyCustomSectionCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecMyCustomSectionCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecActiveData0Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecActiveData0CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecMyCustomSectionCombinatorAlias = SpecByteVecCombinator;
+pub type SpecActiveData0CombinatorAlias = Mapped<SpecActiveData0CombinatorAlias1, ActiveData0Mapper>;
+type ActiveData0CombinatorAlias1 = (ExprCombinator, ByteVecCombinator);
+pub struct ActiveData0Combinator1(pub ActiveData0CombinatorAlias1);
+impl View for ActiveData0Combinator1 {
+    type V = SpecActiveData0CombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ActiveData0Combinator1, ActiveData0CombinatorAlias1);
 
-pub struct MyCustomSectionCombinator(pub MyCustomSectionCombinatorAlias);
+pub struct ActiveData0Combinator(pub ActiveData0CombinatorAlias);
 
-impl View for MyCustomSectionCombinator {
-    type V = SpecMyCustomSectionCombinator;
-    open spec fn view(&self) -> Self::V { SpecMyCustomSectionCombinator(self.0@) }
+impl View for ActiveData0Combinator {
+    type V = SpecActiveData0Combinator;
+    open spec fn view(&self) -> Self::V { SpecActiveData0Combinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MyCustomSectionCombinator {
-    type Type = MyCustomSection;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ActiveData0Combinator {
+    type Type = ActiveData0<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type MyCustomSectionCombinatorAlias = ByteVecCombinator;
+}
+pub type ActiveData0CombinatorAlias = Mapped<ActiveData0Combinator1, ActiveData0Mapper>;
 
 
-pub open spec fn spec_my_custom_section() -> SpecMyCustomSectionCombinator {
-    SpecMyCustomSectionCombinator(spec_byte_vec())
+pub open spec fn spec_active_data0() -> SpecActiveData0Combinator {
+    SpecActiveData0Combinator(
+    Mapped {
+        inner: (spec_expr(), spec_byte_vec()),
+        mapper: ActiveData0Mapper,
+    })
 }
 
                 
-pub fn my_custom_section<'a>() -> (o: MyCustomSectionCombinator)
-    ensures o@ == spec_my_custom_section(),
+pub fn active_data0<'a>() -> (o: ActiveData0Combinator)
+    ensures o@ == spec_active_data0(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = MyCustomSectionCombinator(byte_vec());
-    assert({
-        &&& combinator@ == spec_my_custom_section()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = ActiveData0Combinator(
+    Mapped {
+        inner: ActiveData0Combinator1((expr(), byte_vec())),
+        mapper: ActiveData0Mapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_active_data0()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_my_custom_section<'a>(input: &'a [u8]) -> (res: PResult<<MyCustomSectionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_active_data0<'a>(input: &'a [u8]) -> (res: PResult<<ActiveData0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_my_custom_section().spec_parse(input@) == Some((n as int, v@)),
-        spec_my_custom_section().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_active_data0().spec_parse(input@) == Some((n as int, v@)),
+        spec_active_data0().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_my_custom_section().spec_parse(input@) is None,
-        spec_my_custom_section().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_active_data0().spec_parse(input@) is None,
+        spec_active_data0().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = my_custom_section();
+    let combinator = active_data0();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_my_custom_section<'a>(v: <MyCustomSectionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_active_data0<'a>(v: <ActiveData0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_my_custom_section().wf(v@),
+        spec_active_data0().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_my_custom_section().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_my_custom_section().spec_serialize(v@))
+            &&& n == spec_active_data0().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_active_data0().spec_serialize(v@))
         },
 {
-    let combinator = my_custom_section();
+    let combinator = active_data0();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn my_custom_section_len<'a>(v: <MyCustomSectionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn active_data0_len<'a>(v: <ActiveData0Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_my_custom_section().wf(v@),
-        spec_my_custom_section().spec_serialize(v@).len() <= usize::MAX,
+        spec_active_data0().wf(v@),
+        spec_active_data0().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_my_custom_section().spec_serialize(v@).len(),
+        serialize_len == spec_active_data0().spec_serialize(v@).len(),
 {
-    let combinator = my_custom_section();
+    let combinator = active_data0();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
+pub type SpecPassiveData = SpecByteVec;
+pub type PassiveData = ByteVec;
+pub type PassiveDataRef<'a> = &'a ByteVec;
 
-pub struct SpecCustom {
-    pub name: SpecName,
-    pub data: SpecMyCustomSection,
-}
-
-pub type SpecCustomInner = (SpecName, SpecMyCustomSection);
-
-
-impl SpecFrom<SpecCustom> for SpecCustomInner {
-    open spec fn spec_from(m: SpecCustom) -> SpecCustomInner {
-        (m.name, m.data)
-    }
-}
-
-impl SpecFrom<SpecCustomInner> for SpecCustom {
-    open spec fn spec_from(m: SpecCustomInner) -> SpecCustom {
-        let (name, data) = m;
-        SpecCustom { name, data }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct Custom {
-    pub name: Name,
-    pub data: MyCustomSection,
-}
-
-impl View for Custom {
-    type V = SpecCustom;
-
-    open spec fn view(&self) -> Self::V {
-        SpecCustom {
-            name: self.name@,
-            data: self.data@,
-        }
-    }
-}
-pub type CustomInner = (Name, MyCustomSection);
-
-pub type CustomInnerRef<'a> = (&'a Name, &'a MyCustomSection);
-impl<'a> From<&'a Custom> for CustomInnerRef<'a> {
-    fn ex_from(m: &'a Custom) -> CustomInnerRef<'a> {
-        (&m.name, &m.data)
-    }
-}
-
-impl From<CustomInner> for Custom {
-    fn ex_from(m: CustomInner) -> Custom {
-        let (name, data) = m;
-        Custom { name, data }
-    }
-}
 
-pub struct CustomMapper;
-impl View for CustomMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for CustomMapper {
-    type Src = SpecCustomInner;
-    type Dst = SpecCustom;
-}
-impl SpecIsoProof for CustomMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for CustomMapper {
-    type Src = CustomInner;
-    type Dst = Custom;
-    type RefSrc = CustomInnerRef<'a>;
-}
-type SpecCustomCombinatorAlias1 = (SpecNameCombinator, SpecMyCustomSectionCombinator);
-pub struct SpecCustomCombinator(pub SpecCustomCombinatorAlias);
+pub struct SpecPassiveDataCombinator(pub SpecPassiveDataCombinatorAlias);
 
-impl SpecCombinator for SpecCustomCombinator {
-    type Type = SpecCustom;
+impl SpecCombinator for SpecPassiveDataCombinator {
+    type Type = SpecPassiveData;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCustomCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCustomCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecPassiveDataCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecPassiveDataCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCustomCombinatorAlias = Mapped<SpecCustomCombinatorAlias1, CustomMapper>;
-type CustomCombinatorAlias1 = (NameCombinator, MyCustomSectionCombinator);
-pub struct CustomCombinator1(pub CustomCombinatorAlias1);
-impl View for CustomCombinator1 {
-    type V = SpecCustomCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(CustomCombinator1, CustomCombinatorAlias1);
+pub type SpecPassiveDataCombinatorAlias = SpecByteVecCombinator;
 
-pub struct CustomCombinator(pub CustomCombinatorAlias);
+pub struct PassiveDataCombinator(pub PassiveDataCombinatorAlias);
 
-impl View for CustomCombinator {
-    type V = SpecCustomCombinator;
-    open spec fn view(&self) -> Self::V { SpecCustomCombinator(self.0@) }
+impl View for PassiveDataCombinator {
+    type V = SpecPassiveDataCombinator;
+    open spec fn view(&self) -> Self::V { SpecPassiveDataCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CustomCombinator {
-    type Type = Custom;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for PassiveDataCombinator {
+    type Type = PassiveData;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CustomCombinatorAlias = Mapped<CustomCombinator1, CustomMapper>;
+}
+pub type PassiveDataCombinatorAlias = ByteVecCombinator;
 
 
-pub open spec fn spec_custom() -> SpecCustomCombinator {
-    SpecCustomCombinator(
-    Mapped {
-        inner: (spec_name(), spec_my_custom_section()),
-        mapper: CustomMapper,
-    })
+pub open spec fn spec_passive_data() -> SpecPassiveDataCombinator {
+    SpecPassiveDataCombinator(spec_byte_vec())
 }
 
                 
-pub fn custom<'a>() -> (o: CustomCombinator)
-    ensures o@ == spec_custom(),
+pub fn passive_data<'a>() -> (o: PassiveDataCombinator)
+    ensures o@ == spec_passive_data(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CustomCombinator(
-    Mapped {
-        inner: CustomCombinator1((name(), my_custom_section())),
-        mapper: CustomMapper,
-    });
-    assert({
-        &&& combinator@ == spec_custom()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = PassiveDataCombinator(byte_vec());
+    // assert({
+    //     &&& combinator@ == spec_passive_data()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_custom<'a>(input: &'a [u8]) -> (res: PResult<<CustomCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_passive_data<'a>(input: &'a [u8]) -> (res: PResult<<PassiveDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_custom().spec_parse(input@) == Some((n as int, v@)),
-        spec_custom().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_passive_data().spec_parse(input@) == Some((n as int, v@)),
+        spec_passive_data().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_custom().spec_parse(input@) is None,
-        spec_custom().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_passive_data().spec_parse(input@) is None,
+        spec_passive_data().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = custom();
+    let combinator = passive_data();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_custom<'a>(v: <CustomCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_passive_data<'a>(v: <PassiveDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_custom().wf(v@),
+        spec_passive_data().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_custom().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_custom().spec_serialize(v@))
+            &&& n == spec_passive_data().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_passive_data().spec_serialize(v@))
         },
 {
-    let combinator = custom();
+    let combinator = passive_data();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn custom_len<'a>(v: <CustomCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn passive_data_len<'a>(v: <PassiveDataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_custom().wf(v@),
-        spec_custom().spec_serialize(v@).len() <= usize::MAX,
+        spec_passive_data().wf(v@),
+        spec_passive_data().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_custom().spec_serialize(v@).len(),
+        serialize_len == spec_passive_data().spec_serialize(v@).len(),
 {
-    let combinator = custom();
+    let combinator = passive_data();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
                 
 
-pub struct SpecCustomsec {
-    pub size: u64,
-    pub cont: SpecCustom,
+pub enum SpecData {
+    ActiveData0(SpecActiveData0),
+    PassiveData(SpecPassiveData),
+    ActiveDataX(SpecActiveDatax),
+}
+
+pub type SpecDataInner = Either<SpecActiveData0, Either<SpecPassiveData, SpecActiveDatax>>;
+
+impl SpecFrom<SpecData> for SpecDataInner {
+    open spec fn spec_from(m: SpecData) -> SpecDataInner {
+        match m {
+            SpecData::ActiveData0(m) => Either::Left(m),
+            SpecData::PassiveData(m) => Either::Right(Either::Left(m)),
+            SpecData::ActiveDataX(m) => Either::Right(Either::Right(m)),
+        }
+    }
+
+}
+
+                
+impl SpecFrom<SpecDataInner> for SpecData {
+    open spec fn spec_from(m: SpecDataInner) -> SpecData {
+        match m {
+            Either::Left(m) => SpecData::ActiveData0(m),
+            Either::Right(Either::Left(m)) => SpecData::PassiveData(m),
+            Either::Right(Either::Right(m)) => SpecData::ActiveDataX(m),
+        }
+    }
+
 }
 
-pub type SpecCustomsecInner = (u64, SpecCustom);
 
 
-impl SpecFrom<SpecCustomsec> for SpecCustomsecInner {
-    open spec fn spec_from(m: SpecCustomsec) -> SpecCustomsecInner {
-        (m.size, m.cont)
-    }
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Data<'a> {
+    ActiveData0(ActiveData0<'a>),
+    PassiveData(PassiveData),
+    ActiveDataX(ActiveDatax<'a>),
 }
 
-impl SpecFrom<SpecCustomsecInner> for SpecCustomsec {
-    open spec fn spec_from(m: SpecCustomsecInner) -> SpecCustomsec {
-        let (size, cont) = m;
-        SpecCustomsec { size, cont }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
+pub type DataInner<'a> = Either<ActiveData0<'a>, Either<PassiveData, ActiveDatax<'a>>>;
 
-pub struct Customsec {
-    pub size: u64,
-    pub cont: Custom,
-}
+pub type DataInnerRef<'a> = Either<&'a ActiveData0<'a>, Either<&'a PassiveData, &'a ActiveDatax<'a>>>;
 
-impl View for Customsec {
-    type V = SpecCustomsec;
 
+impl<'a> View for Data<'a> {
+    type V = SpecData;
     open spec fn view(&self) -> Self::V {
-        SpecCustomsec {
-            size: self.size@,
-            cont: self.cont@,
+        match self {
+            Data::ActiveData0(m) => SpecData::ActiveData0(m@),
+            Data::PassiveData(m) => SpecData::PassiveData(m@),
+            Data::ActiveDataX(m) => SpecData::ActiveDataX(m@),
         }
     }
 }
-pub type CustomsecInner = (u64, Custom);
 
-pub type CustomsecInnerRef<'a> = (&'a u64, &'a Custom);
-impl<'a> From<&'a Customsec> for CustomsecInnerRef<'a> {
-    fn ex_from(m: &'a Customsec) -> CustomsecInnerRef<'a> {
-        (&m.size, &m.cont)
+
+impl<'a> From<&'a Data<'a>> for DataInnerRef<'a> {
+    fn ex_from(m: &'a Data<'a>) -> DataInnerRef<'a> {
+        match m {
+            Data::ActiveData0(m) => Either::Left(m),
+            Data::PassiveData(m) => Either::Right(Either::Left(m)),
+            Data::ActiveDataX(m) => Either::Right(Either::Right(m)),
+        }
     }
+
 }
 
-impl From<CustomsecInner> for Customsec {
-    fn ex_from(m: CustomsecInner) -> Customsec {
-        let (size, cont) = m;
-        Customsec { size, cont }
+impl<'a> From<DataInner<'a>> for Data<'a> {
+    fn ex_from(m: DataInner<'a>) -> Data<'a> {
+        match m {
+            Either::Left(m) => Data::ActiveData0(m),
+            Either::Right(Either::Left(m)) => Data::PassiveData(m),
+            Either::Right(Either::Right(m)) => Data::ActiveDataX(m),
+        }
     }
+    
 }
 
-pub struct CustomsecMapper;
-impl View for CustomsecMapper {
+
+pub struct DataMapper;
+impl View for DataMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for CustomsecMapper {
-    type Src = SpecCustomsecInner;
-    type Dst = SpecCustomsec;
+impl SpecIso for DataMapper {
+    type Src = SpecDataInner;
+    type Dst = SpecData;
 }
-impl SpecIsoProof for CustomsecMapper {
+impl SpecIsoProof for DataMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -24332,241 +24422,217 @@ impl SpecIsoProof for CustomsecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for CustomsecMapper {
-    type Src = CustomsecInner;
-    type Dst = Customsec;
-    type RefSrc = CustomsecInnerRef<'a>;
+impl<'a> Iso<'a> for DataMapper {
+    type Src = DataInner<'a>;
+    type Dst = Data<'a>;
+    type RefSrc = DataInnerRef<'a>;
 }
 
-pub struct SpecCustomsecCombinator(pub SpecCustomsecCombinatorAlias);
+pub const DATAACTIVEDATA0_0_FRONT_CONST: u64 = 0;
 
-impl SpecCombinator for SpecCustomsecCombinator {
-    type Type = SpecCustomsec;
+pub const DATAPASSIVEDATA_0_FRONT_CONST: u64 = 1;
+
+pub const DATAACTIVEDATAX_0_FRONT_CONST: u64 = 2;
+
+type SpecDataCombinatorAlias1 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecPassiveDataCombinator>, Preceded<Tag<UnsignedLEB128, u64>, SpecActiveDataxCombinator>>;
+type SpecDataCombinatorAlias2 = Choice<Preceded<Tag<UnsignedLEB128, u64>, SpecActiveData0Combinator>, SpecDataCombinatorAlias1>;
+pub struct SpecDataCombinator(pub SpecDataCombinatorAlias);
+
+impl SpecCombinator for SpecDataCombinator {
+    type Type = SpecData;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecCustomsecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecCustomsecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecDataCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDataCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecCustomsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecCustomCombinator>>, CustomsecMapper>;
+pub type SpecDataCombinatorAlias = Mapped<SpecDataCombinatorAlias2, DataMapper>;
 
-pub struct CustomsecCombinator(pub CustomsecCombinatorAlias);
 
-impl View for CustomsecCombinator {
-    type V = SpecCustomsecCombinator;
-    open spec fn view(&self) -> Self::V { SpecCustomsecCombinator(self.0@) }
+
+type DataCombinatorAlias1 = Choice<Preceded<Tag<UnsignedLEB128, u64>, PassiveDataCombinator>, Preceded<Tag<UnsignedLEB128, u64>, ActiveDataxCombinator>>;
+type DataCombinatorAlias2 = Choice<Preceded<Tag<UnsignedLEB128, u64>, ActiveData0Combinator>, DataCombinator1>;
+pub struct DataCombinator1(pub DataCombinatorAlias1);
+impl View for DataCombinator1 {
+    type V = SpecDataCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CustomsecCombinator {
-    type Type = Customsec;
+impl_wrapper_combinator!(DataCombinator1, DataCombinatorAlias1);
+
+pub struct DataCombinator2(pub DataCombinatorAlias2);
+impl View for DataCombinator2 {
+    type V = SpecDataCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(DataCombinator2, DataCombinatorAlias2);
+
+pub struct DataCombinator(pub DataCombinatorAlias);
+
+impl View for DataCombinator {
+    type V = SpecDataCombinator;
+    open spec fn view(&self) -> Self::V { SpecDataCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DataCombinator {
+    type Type = Data<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type CustomsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, CustomCombinator>, CustomsecCont0>, CustomsecMapper>;
-
-
-pub open spec fn spec_customsec() -> SpecCustomsecCombinator {
-    SpecCustomsecCombinator(
-    Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_customsec_cont0(deps)),
-        mapper: CustomsecMapper,
-    })
-}
-
-pub open spec fn spec_customsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecCustomCombinator> {
-    let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_custom())
 }
+pub type DataCombinatorAlias = Mapped<DataCombinator2, DataMapper>;
 
-impl View for CustomsecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecCustomCombinator>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_customsec_cont0(deps)
-        }
-    }
+pub open spec fn spec_data() -> SpecDataCombinator {
+    SpecDataCombinator(Mapped { inner: Choice(Preceded(Tag::spec_new(UnsignedLEB128, DATAACTIVEDATA0_0_FRONT_CONST), spec_active_data0()), Choice(Preceded(Tag::spec_new(UnsignedLEB128, DATAPASSIVEDATA_0_FRONT_CONST), spec_passive_data()), Preceded(Tag::spec_new(UnsignedLEB128, DATAACTIVEDATAX_0_FRONT_CONST), spec_active_datax()))), mapper: DataMapper })
 }
 
                 
-pub fn customsec<'a>() -> (o: CustomsecCombinator)
-    ensures o@ == spec_customsec(),
+pub fn data<'a>() -> (o: DataCombinator)
+    ensures o@ == spec_data(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = CustomsecCombinator(
-    Mapped {
-        inner: Pair::new(UnsignedLEB128, CustomsecCont0),
-        mapper: CustomsecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_customsec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = DataCombinator(Mapped { inner: DataCombinator2(Choice::new(Preceded(Tag::new(UnsignedLEB128, DATAACTIVEDATA0_0_FRONT_CONST), active_data0()), DataCombinator1(Choice::new(Preceded(Tag::new(UnsignedLEB128, DATAPASSIVEDATA_0_FRONT_CONST), passive_data()), Preceded(Tag::new(UnsignedLEB128, DATAACTIVEDATAX_0_FRONT_CONST), active_datax()))))), mapper: DataMapper });
+    // assert({
+    //     &&& combinator@ == spec_data()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_customsec<'a>(input: &'a [u8]) -> (res: PResult<<CustomsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_data<'a>(input: &'a [u8]) -> (res: PResult<<DataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_customsec().spec_parse(input@) == Some((n as int, v@)),
-        spec_customsec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_data().spec_parse(input@) == Some((n as int, v@)),
+        spec_data().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_customsec().spec_parse(input@) is None,
-        spec_customsec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_data().spec_parse(input@) is None,
+        spec_data().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = customsec();
+    let combinator = data();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_customsec<'a>(v: <CustomsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_data<'a>(v: <DataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_customsec().wf(v@),
+        spec_data().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_customsec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_customsec().spec_serialize(v@))
+            &&& n == spec_data().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_data().spec_serialize(v@))
         },
 {
-    let combinator = customsec();
+    let combinator = data();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn customsec_len<'a>(v: <CustomsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn data_len<'a>(v: <DataCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_customsec().wf(v@),
-        spec_customsec().spec_serialize(v@).len() <= usize::MAX,
+        spec_data().wf(v@),
+        spec_data().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_customsec().spec_serialize(v@).len(),
+        serialize_len == spec_data().spec_serialize(v@).len(),
 {
-    let combinator = customsec();
+    let combinator = data();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct CustomsecCont0;
-type CustomsecCont0Type<'a, 'b> = &'b u64;
-type CustomsecCont0SType<'a, 'x> = &'x u64;
-type CustomsecCont0Input<'a, 'b, 'x> = POrSType<CustomsecCont0Type<'a, 'b>, CustomsecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<CustomsecCont0Input<'a, 'b, 'x>> for CustomsecCont0 {
-    type Output = AndThen<bytes::Variable, CustomCombinator>;
-
-    open spec fn requires(&self, deps: CustomsecCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: CustomsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_customsec_cont0(deps@)
-    }
-
-    fn apply(&self, deps: CustomsecCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), custom())
-            }
-            POrSType::S(deps) => {
-                let size = deps;
-                let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), custom())
-            }
-        }
-    }
-}
                 
 
-pub struct SpecTablesec {
-    pub size: u64,
-    pub cont: SpecTablesecContent,
+pub struct SpecDatasecContent {
+    pub l: u64,
+    pub v: Seq<SpecData>,
 }
 
-pub type SpecTablesecInner = (u64, SpecTablesecContent);
+pub type SpecDatasecContentInner = (u64, Seq<SpecData>);
 
 
-impl SpecFrom<SpecTablesec> for SpecTablesecInner {
-    open spec fn spec_from(m: SpecTablesec) -> SpecTablesecInner {
-        (m.size, m.cont)
+impl SpecFrom<SpecDatasecContent> for SpecDatasecContentInner {
+    open spec fn spec_from(m: SpecDatasecContent) -> SpecDatasecContentInner {
+        (m.l, m.v)
     }
 }
 
-impl SpecFrom<SpecTablesecInner> for SpecTablesec {
-    open spec fn spec_from(m: SpecTablesecInner) -> SpecTablesec {
-        let (size, cont) = m;
-        SpecTablesec { size, cont }
+impl SpecFrom<SpecDatasecContentInner> for SpecDatasecContent {
+    open spec fn spec_from(m: SpecDatasecContentInner) -> SpecDatasecContent {
+        let (l, v) = m;
+        SpecDatasecContent { l, v }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Tablesec {
-    pub size: u64,
-    pub cont: TablesecContent,
+pub struct DatasecContent<'a> {
+    pub l: u64,
+    pub v: RepeatResult<Data<'a>>,
 }
 
-impl View for Tablesec {
-    type V = SpecTablesec;
+impl View for DatasecContent<'_> {
+    type V = SpecDatasecContent;
 
     open spec fn view(&self) -> Self::V {
-        SpecTablesec {
-            size: self.size@,
-            cont: self.cont@,
+        SpecDatasecContent {
+            l: self.l@,
+            v: self.v@,
         }
     }
 }
-pub type TablesecInner = (u64, TablesecContent);
+pub type DatasecContentInner<'a> = (u64, RepeatResult<Data<'a>>);
 
-pub type TablesecInnerRef<'a> = (&'a u64, &'a TablesecContent);
-impl<'a> From<&'a Tablesec> for TablesecInnerRef<'a> {
-    fn ex_from(m: &'a Tablesec) -> TablesecInnerRef<'a> {
-        (&m.size, &m.cont)
+pub type DatasecContentInnerRef<'a> = (&'a u64, &'a RepeatResult<Data<'a>>);
+impl<'a> From<&'a DatasecContent<'a>> for DatasecContentInnerRef<'a> {
+    fn ex_from(m: &'a DatasecContent) -> DatasecContentInnerRef<'a> {
+        (&m.l, &m.v)
     }
 }
 
-impl From<TablesecInner> for Tablesec {
-    fn ex_from(m: TablesecInner) -> Tablesec {
-        let (size, cont) = m;
-        Tablesec { size, cont }
+impl<'a> From<DatasecContentInner<'a>> for DatasecContent<'a> {
+    fn ex_from(m: DatasecContentInner) -> DatasecContent {
+        let (l, v) = m;
+        DatasecContent { l, v }
     }
 }
 
-pub struct TablesecMapper;
-impl View for TablesecMapper {
+pub struct DatasecContentMapper;
+impl View for DatasecContentMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for TablesecMapper {
-    type Src = SpecTablesecInner;
-    type Dst = SpecTablesec;
+impl SpecIso for DatasecContentMapper {
+    type Src = SpecDatasecContentInner;
+    type Dst = SpecDatasecContent;
 }
-impl SpecIsoProof for TablesecMapper {
+impl SpecIsoProof for DatasecContentMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -24574,359 +24640,527 @@ impl SpecIsoProof for TablesecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for TablesecMapper {
-    type Src = TablesecInner;
-    type Dst = Tablesec;
-    type RefSrc = TablesecInnerRef<'a>;
+impl<'a> Iso<'a> for DatasecContentMapper {
+    type Src = DatasecContentInner<'a>;
+    type Dst = DatasecContent<'a>;
+    type RefSrc = DatasecContentInnerRef<'a>;
 }
 
-pub struct SpecTablesecCombinator(pub SpecTablesecCombinatorAlias);
+pub struct SpecDatasecContentCombinator(pub SpecDatasecContentCombinatorAlias);
 
-impl SpecCombinator for SpecTablesecCombinator {
-    type Type = SpecTablesec;
+impl SpecCombinator for SpecDatasecContentCombinator {
+    type Type = SpecDatasecContent;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTablesecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTablesecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecDatasecContentCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDatasecContentCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTablesecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecTablesecContentCombinator>>, TablesecMapper>;
+pub type SpecDatasecContentCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, RepeatN<SpecDataCombinator>>, DatasecContentMapper>;
 
-pub struct TablesecCombinator(pub TablesecCombinatorAlias);
+pub struct DatasecContentCombinator(pub DatasecContentCombinatorAlias);
 
-impl View for TablesecCombinator {
-    type V = SpecTablesecCombinator;
-    open spec fn view(&self) -> Self::V { SpecTablesecCombinator(self.0@) }
+impl View for DatasecContentCombinator {
+    type V = SpecDatasecContentCombinator;
+    open spec fn view(&self) -> Self::V { SpecDatasecContentCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TablesecCombinator {
-    type Type = Tablesec;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DatasecContentCombinator {
+    type Type = DatasecContent<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TablesecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, TablesecContentCombinator>, TablesecCont0>, TablesecMapper>;
+}
+pub type DatasecContentCombinatorAlias = Mapped<Pair<UnsignedLEB128, RepeatN<DataCombinator>, DatasecContentCont0>, DatasecContentMapper>;
 
 
-pub open spec fn spec_tablesec() -> SpecTablesecCombinator {
-    SpecTablesecCombinator(
+pub open spec fn spec_datasec_content() -> SpecDatasecContentCombinator {
+    SpecDatasecContentCombinator(
     Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_tablesec_cont0(deps)),
-        mapper: TablesecMapper,
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_datasec_content_cont0(deps)),
+        mapper: DatasecContentMapper,
     })
 }
 
-pub open spec fn spec_tablesec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecTablesecContentCombinator> {
-    let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_tablesec_content())
+pub open spec fn spec_datasec_content_cont0(deps: u64) -> RepeatN<SpecDataCombinator> {
+    let l = deps;
+    RepeatN(spec_data(), (usize::spec_from(l)) as usize)
 }
 
-impl View for TablesecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecTablesecContentCombinator>;
+impl View for DatasecContentCont0 {
+    type V = spec_fn(u64) -> RepeatN<SpecDataCombinator>;
 
     open spec fn view(&self) -> Self::V {
         |deps: u64| {
-            spec_tablesec_cont0(deps)
+            spec_datasec_content_cont0(deps)
         }
     }
 }
 
                 
-pub fn tablesec<'a>() -> (o: TablesecCombinator)
-    ensures o@ == spec_tablesec(),
+pub fn datasec_content<'a>() -> (o: DatasecContentCombinator)
+    ensures o@ == spec_datasec_content(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = TablesecCombinator(
+    let combinator = DatasecContentCombinator(
     Mapped {
-        inner: Pair::new(UnsignedLEB128, TablesecCont0),
-        mapper: TablesecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_tablesec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: Pair::new(UnsignedLEB128, DatasecContentCont0),
+        mapper: DatasecContentMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_datasec_content()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_tablesec<'a>(input: &'a [u8]) -> (res: PResult<<TablesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_datasec_content<'a>(input: &'a [u8]) -> (res: PResult<<DatasecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_tablesec().spec_parse(input@) == Some((n as int, v@)),
-        spec_tablesec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_datasec_content().spec_parse(input@) == Some((n as int, v@)),
+        spec_datasec_content().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_tablesec().spec_parse(input@) is None,
-        spec_tablesec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_datasec_content().spec_parse(input@) is None,
+        spec_datasec_content().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = tablesec();
+    let combinator = datasec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_tablesec<'a>(v: <TablesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_datasec_content<'a>(v: <DatasecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_tablesec().wf(v@),
+        spec_datasec_content().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_tablesec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_tablesec().spec_serialize(v@))
+            &&& n == spec_datasec_content().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_datasec_content().spec_serialize(v@))
         },
 {
-    let combinator = tablesec();
+    let combinator = datasec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn tablesec_len<'a>(v: <TablesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn datasec_content_len<'a>(v: <DatasecContentCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_tablesec().wf(v@),
-        spec_tablesec().spec_serialize(v@).len() <= usize::MAX,
+        spec_datasec_content().wf(v@),
+        spec_datasec_content().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_tablesec().spec_serialize(v@).len(),
+        serialize_len == spec_datasec_content().spec_serialize(v@).len(),
 {
-    let combinator = tablesec();
+    let combinator = datasec_content();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct TablesecCont0;
-type TablesecCont0Type<'a, 'b> = &'b u64;
-type TablesecCont0SType<'a, 'x> = &'x u64;
-type TablesecCont0Input<'a, 'b, 'x> = POrSType<TablesecCont0Type<'a, 'b>, TablesecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<TablesecCont0Input<'a, 'b, 'x>> for TablesecCont0 {
-    type Output = AndThen<bytes::Variable, TablesecContentCombinator>;
+pub struct DatasecContentCont0;
+type DatasecContentCont0Type<'a, 'b> = &'b u64;
+type DatasecContentCont0SType<'a, 'x> = &'x u64;
+type DatasecContentCont0Input<'a, 'b, 'x> = POrSType<DatasecContentCont0Type<'a, 'b>, DatasecContentCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<DatasecContentCont0Input<'a, 'b, 'x>> for DatasecContentCont0 {
+    type Output = RepeatN<DataCombinator>;
 
-    open spec fn requires(&self, deps: TablesecCont0Input<'a, 'b, 'x>) -> bool { true }
+    open spec fn requires(&self, deps: DatasecContentCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
 
-    open spec fn ensures(&self, deps: TablesecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_tablesec_cont0(deps@)
+    open spec fn ensures(&self, deps: DatasecContentCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_datasec_content_cont0(deps@)
     }
 
-    fn apply(&self, deps: TablesecCont0Input<'a, 'b, 'x>) -> Self::Output {
+    fn apply(&self, deps: DatasecContentCont0Input<'a, 'b, 'x>) -> Self::Output {
         match deps {
             POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), tablesec_content())
+                let l = deps;
+                let l = *l;
+                RepeatN(data(), (usize::ex_from(l)) as usize)
             }
             POrSType::S(deps) => {
-                let size = deps;
-                let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), tablesec_content())
+                let l = deps;
+                let l = *l;
+                RepeatN(data(), (usize::ex_from(l)) as usize)
             }
         }
     }
 }
                 
-pub type SpecSigned32 = Seq<u8>;
-pub type Signed32<'a> = &'a [u8];
-pub type Signed32Ref<'a> = &'a &'a [u8];
 
+pub struct SpecDatasec {
+    pub size: u64,
+    pub cont: SpecDatasecContent,
+}
 
-pub struct SpecSigned32Combinator(pub SpecSigned32CombinatorAlias);
+pub type SpecDatasecInner = (u64, SpecDatasecContent);
 
-impl SpecCombinator for SpecSigned32Combinator {
-    type Type = SpecSigned32;
+
+impl SpecFrom<SpecDatasec> for SpecDatasecInner {
+    open spec fn spec_from(m: SpecDatasec) -> SpecDatasecInner {
+        (m.size, m.cont)
+    }
+}
+
+impl SpecFrom<SpecDatasecInner> for SpecDatasec {
+    open spec fn spec_from(m: SpecDatasecInner) -> SpecDatasec {
+        let (size, cont) = m;
+        SpecDatasec { size, cont }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Datasec<'a> {
+    pub size: u64,
+    pub cont: DatasecContent<'a>,
+}
+
+impl View for Datasec<'_> {
+    type V = SpecDatasec;
+
+    open spec fn view(&self) -> Self::V {
+        SpecDatasec {
+            size: self.size@,
+            cont: self.cont@,
+        }
+    }
+}
+pub type DatasecInner<'a> = (u64, DatasecContent<'a>);
+
+pub type DatasecInnerRef<'a> = (&'a u64, &'a DatasecContent<'a>);
+impl<'a> From<&'a Datasec<'a>> for DatasecInnerRef<'a> {
+    fn ex_from(m: &'a Datasec) -> DatasecInnerRef<'a> {
+        (&m.size, &m.cont)
+    }
+}
+
+impl<'a> From<DatasecInner<'a>> for Datasec<'a> {
+    fn ex_from(m: DatasecInner) -> Datasec {
+        let (size, cont) = m;
+        Datasec { size, cont }
+    }
+}
+
+pub struct DatasecMapper;
+impl View for DatasecMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for DatasecMapper {
+    type Src = SpecDatasecInner;
+    type Dst = SpecDatasec;
+}
+impl SpecIsoProof for DatasecMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for DatasecMapper {
+    type Src = DatasecInner<'a>;
+    type Dst = Datasec<'a>;
+    type RefSrc = DatasecInnerRef<'a>;
+}
+
+pub struct SpecDatasecCombinator(pub SpecDatasecCombinatorAlias);
+
+impl SpecCombinator for SpecDatasecCombinator {
+    type Type = SpecDatasec;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecSigned32Combinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecSigned32CombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecDatasecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecDatasecCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecSigned32CombinatorAlias = bytes::Fixed<4>;
+pub type SpecDatasecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecDatasecContentCombinator>>, DatasecMapper>;
 
-pub struct Signed32Combinator(pub Signed32CombinatorAlias);
+pub struct DatasecCombinator(pub DatasecCombinatorAlias);
 
-impl View for Signed32Combinator {
-    type V = SpecSigned32Combinator;
-    open spec fn view(&self) -> Self::V { SpecSigned32Combinator(self.0@) }
+impl View for DatasecCombinator {
+    type V = SpecDatasecCombinator;
+    open spec fn view(&self) -> Self::V { SpecDatasecCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Signed32Combinator {
-    type Type = Signed32<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for DatasecCombinator {
+    type Type = Datasec<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type Signed32CombinatorAlias = bytes::Fixed<4>;
+}
+pub type DatasecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, DatasecContentCombinator>, DatasecCont0>, DatasecMapper>;
 
 
-pub open spec fn spec_signed_32() -> SpecSigned32Combinator {
-    SpecSigned32Combinator(bytes::Fixed::<4>)
+pub open spec fn spec_datasec() -> SpecDatasecCombinator {
+    SpecDatasecCombinator(
+    Mapped {
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_datasec_cont0(deps)),
+        mapper: DatasecMapper,
+    })
+}
+
+pub open spec fn spec_datasec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecDatasecContentCombinator> {
+    let size = deps;
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_datasec_content())
+}
+
+impl View for DatasecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecDatasecContentCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_datasec_cont0(deps)
+        }
+    }
 }
 
                 
-pub fn signed_32<'a>() -> (o: Signed32Combinator)
-    ensures o@ == spec_signed_32(),
+pub fn datasec<'a>() -> (o: DatasecCombinator)
+    ensures o@ == spec_datasec(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = Signed32Combinator(bytes::Fixed::<4>);
-    assert({
-        &&& combinator@ == spec_signed_32()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    let combinator = DatasecCombinator(
+    Mapped {
+        inner: Pair::new(UnsignedLEB128, DatasecCont0),
+        mapper: DatasecMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_datasec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_signed_32<'a>(input: &'a [u8]) -> (res: PResult<<Signed32Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_datasec<'a>(input: &'a [u8]) -> (res: PResult<<DatasecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_signed_32().spec_parse(input@) == Some((n as int, v@)),
-        spec_signed_32().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_datasec().spec_parse(input@) == Some((n as int, v@)),
+        spec_datasec().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_signed_32().spec_parse(input@) is None,
-        spec_signed_32().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_datasec().spec_parse(input@) is None,
+        spec_datasec().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = signed_32();
+    let combinator = datasec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_signed_32<'a>(v: <Signed32Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_datasec<'a>(v: <DatasecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_signed_32().wf(v@),
+        spec_datasec().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_signed_32().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_signed_32().spec_serialize(v@))
+            &&& n == spec_datasec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_datasec().spec_serialize(v@))
         },
 {
-    let combinator = signed_32();
+    let combinator = datasec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn signed_32_len<'a>(v: <Signed32Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn datasec_len<'a>(v: <DatasecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_signed_32().wf(v@),
-        spec_signed_32().spec_serialize(v@).len() <= usize::MAX,
+        spec_datasec().wf(v@),
+        spec_datasec().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_signed_32().spec_serialize(v@).len(),
+        serialize_len == spec_datasec().spec_serialize(v@).len(),
 {
-    let combinator = signed_32();
+    let combinator = datasec();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
+pub struct DatasecCont0;
+type DatasecCont0Type<'a, 'b> = &'b u64;
+type DatasecCont0SType<'a, 'x> = &'x u64;
+type DatasecCont0Input<'a, 'b, 'x> = POrSType<DatasecCont0Type<'a, 'b>, DatasecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<DatasecCont0Input<'a, 'b, 'x>> for DatasecCont0 {
+    type Output = AndThen<bytes::Variable, DatasecContentCombinator>;
+
+    open spec fn requires(&self, deps: DatasecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: DatasecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_datasec_cont0(deps@)
+    }
+
+    fn apply(&self, deps: DatasecCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), datasec_content())
+            }
+            POrSType::S(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), datasec_content())
+            }
+        }
+    }
+}
                 
 
-pub struct SpecTypesec {
-    pub size: u64,
-    pub cont: SpecTypesecContent,
+pub struct SpecModule {
+    pub magic: Seq<u8>,
+    pub version: Seq<u8>,
+    pub types: Option<SpecTypesec>,
+    pub imports: Option<SpecImportsec>,
+    pub typeidxs: Option<SpecFuncsec>,
+    pub tables: Option<SpecTablesec>,
+    pub mems: Option<SpecMemsec>,
+    pub globals: Option<SpecGlobalsec>,
+    pub exports: Option<SpecExportsec>,
+    pub start: Option<SpecStartsec>,
+    pub elems: Option<SpecElemsec>,
+    pub datacount: Option<SpecDatacountsec>,
+    pub codes: Option<SpecCodesec>,
+    pub datas: Option<SpecDatasec>,
 }
 
-pub type SpecTypesecInner = (u64, SpecTypesecContent);
+pub type SpecModuleInner = (Seq<u8>, (Seq<u8>, (Option<SpecTypesec>, (Option<SpecImportsec>, (Option<SpecFuncsec>, (Option<SpecTablesec>, (Option<SpecMemsec>, (Option<SpecGlobalsec>, (Option<SpecExportsec>, (Option<SpecStartsec>, (Option<SpecElemsec>, (Option<SpecDatacountsec>, (Option<SpecCodesec>, Option<SpecDatasec>)))))))))))));
 
 
-impl SpecFrom<SpecTypesec> for SpecTypesecInner {
-    open spec fn spec_from(m: SpecTypesec) -> SpecTypesecInner {
-        (m.size, m.cont)
+impl SpecFrom<SpecModule> for SpecModuleInner {
+    open spec fn spec_from(m: SpecModule) -> SpecModuleInner {
+        (m.magic, (m.version, (m.types, (m.imports, (m.typeidxs, (m.tables, (m.mems, (m.globals, (m.exports, (m.start, (m.elems, (m.datacount, (m.codes, m.datas)))))))))))))
     }
 }
 
-impl SpecFrom<SpecTypesecInner> for SpecTypesec {
-    open spec fn spec_from(m: SpecTypesecInner) -> SpecTypesec {
-        let (size, cont) = m;
-        SpecTypesec { size, cont }
+impl SpecFrom<SpecModuleInner> for SpecModule {
+    open spec fn spec_from(m: SpecModuleInner) -> SpecModule {
+        let (magic, (version, (types, (imports, (typeidxs, (tables, (mems, (globals, (exports, (start, (elems, (datacount, (codes, datas))))))))))))) = m;
+        SpecModule { magic, version, types, imports, typeidxs, tables, mems, globals, exports, start, elems, datacount, codes, datas }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Typesec {
-    pub size: u64,
-    pub cont: TypesecContent,
+pub struct Module<'a> {
+    pub magic: &'a [u8],
+    pub version: &'a [u8],
+    pub types: Optional<Typesec>,
+    pub imports: Optional<Importsec>,
+    pub typeidxs: Optional<Funcsec>,
+    pub tables: Optional<Tablesec>,
+    pub mems: Optional<Memsec>,
+    pub globals: Optional<Globalsec<'a>>,
+    pub exports: Optional<Exportsec>,
+    pub start: Optional<Startsec>,
+    pub elems: Optional<Elemsec<'a>>,
+    pub datacount: Optional<Datacountsec>,
+    pub codes: Optional<Codesec<'a>>,
+    pub datas: Optional<Datasec<'a>>,
 }
 
-impl View for Typesec {
-    type V = SpecTypesec;
+impl View for Module<'_> {
+    type V = SpecModule;
 
     open spec fn view(&self) -> Self::V {
-        SpecTypesec {
-            size: self.size@,
-            cont: self.cont@,
+        SpecModule {
+            magic: self.magic@,
+            version: self.version@,
+            types: self.types@,
+            imports: self.imports@,
+            typeidxs: self.typeidxs@,
+            tables: self.tables@,
+            mems: self.mems@,
+            globals: self.globals@,
+            exports: self.exports@,
+            start: self.start@,
+            elems: self.elems@,
+            datacount: self.datacount@,
+            codes: self.codes@,
+            datas: self.datas@,
         }
     }
 }
-pub type TypesecInner = (u64, TypesecContent);
+pub type ModuleInner<'a> = (&'a [u8], (&'a [u8], (Optional<Typesec>, (Optional<Importsec>, (Optional<Funcsec>, (Optional<Tablesec>, (Optional<Memsec>, (Optional<Globalsec<'a>>, (Optional<Exportsec>, (Optional<Startsec>, (Optional<Elemsec<'a>>, (Optional<Datacountsec>, (Optional<Codesec<'a>>, Optional<Datasec<'a>>)))))))))))));
 
-pub type TypesecInnerRef<'a> = (&'a u64, &'a TypesecContent);
-impl<'a> From<&'a Typesec> for TypesecInnerRef<'a> {
-    fn ex_from(m: &'a Typesec) -> TypesecInnerRef<'a> {
-        (&m.size, &m.cont)
+pub type ModuleInnerRef<'a> = (&'a &'a [u8], (&'a &'a [u8], (&'a Optional<Typesec>, (&'a Optional<Importsec>, (&'a Optional<Funcsec>, (&'a Optional<Tablesec>, (&'a Optional<Memsec>, (&'a Optional<Globalsec<'a>>, (&'a Optional<Exportsec>, (&'a Optional<Startsec>, (&'a Optional<Elemsec<'a>>, (&'a Optional<Datacountsec>, (&'a Optional<Codesec<'a>>, &'a Optional<Datasec<'a>>)))))))))))));
+impl<'a> From<&'a Module<'a>> for ModuleInnerRef<'a> {
+    fn ex_from(m: &'a Module) -> ModuleInnerRef<'a> {
+        (&m.magic, (&m.version, (&m.types, (&m.imports, (&m.typeidxs, (&m.tables, (&m.mems, (&m.globals, (&m.exports, (&m.start, (&m.elems, (&m.datacount, (&m.codes, &m.datas)))))))))))))
     }
 }
 
-impl From<TypesecInner> for Typesec {
-    fn ex_from(m: TypesecInner) -> Typesec {
-        let (size, cont) = m;
-        Typesec { size, cont }
+impl<'a> From<ModuleInner<'a>> for Module<'a> {
+    fn ex_from(m: ModuleInner) -> Module {
+        let (magic, (version, (types, (imports, (typeidxs, (tables, (mems, (globals, (exports, (start, (elems, (datacount, (codes, datas))))))))))))) = m;
+        Module { magic, version, types, imports, typeidxs, tables, mems, globals, exports, start, elems, datacount, codes, datas }
     }
 }
 
-pub struct TypesecMapper;
-impl View for TypesecMapper {
+pub struct ModuleMapper;
+impl View for ModuleMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for TypesecMapper {
-    type Src = SpecTypesecInner;
-    type Dst = SpecTypesec;
+impl SpecIso for ModuleMapper {
+    type Src = SpecModuleInner;
+    type Dst = SpecModule;
 }
-impl SpecIsoProof for TypesecMapper {
+impl SpecIsoProof for ModuleMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -24934,761 +25168,668 @@ impl SpecIsoProof for TypesecMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for TypesecMapper {
-    type Src = TypesecInner;
-    type Dst = Typesec;
-    type RefSrc = TypesecInnerRef<'a>;
+impl<'a> Iso<'a> for ModuleMapper {
+    type Src = ModuleInner<'a>;
+    type Dst = Module<'a>;
+    type RefSrc = ModuleInnerRef<'a>;
 }
+pub spec const SPEC_MODULEMAGIC_CONST: Seq<u8> = seq![0, 97, 115, 109];pub spec const SPEC_MODULEVERSION_CONST: Seq<u8> = seq![1, 0, 0, 0];pub const MODULETYPES_0_FRONT_CONST: u8 = 1;
 
-pub struct SpecTypesecCombinator(pub SpecTypesecCombinatorAlias);
+pub const MODULEIMPORTS_0_FRONT_CONST: u8 = 2;
 
-impl SpecCombinator for SpecTypesecCombinator {
-    type Type = SpecTypesec;
+pub const MODULETYPEIDXS_0_FRONT_CONST: u8 = 3;
+
+pub const MODULETABLES_0_FRONT_CONST: u8 = 4;
+
+pub const MODULEMEMS_0_FRONT_CONST: u8 = 5;
+
+pub const MODULEGLOBALS_0_FRONT_CONST: u8 = 6;
+
+pub const MODULEEXPORTS_0_FRONT_CONST: u8 = 7;
+
+pub const MODULESTART_0_FRONT_CONST: u8 = 8;
+
+pub const MODULEELEMS_0_FRONT_CONST: u8 = 9;
+
+pub const MODULEDATACOUNT_0_FRONT_CONST: u8 = 12;
+
+pub const MODULECODES_0_FRONT_CONST: u8 = 10;
+
+pub const MODULEDATAS_0_FRONT_CONST: u8 = 11;
+
+type SpecModuleCombinatorAlias1 = (Opt<Preceded<Tag<U8, u8>, SpecCodesecCombinator>>, Opt<Preceded<Tag<U8, u8>, SpecDatasecCombinator>>);
+type SpecModuleCombinatorAlias2 = (Opt<Preceded<Tag<U8, u8>, SpecDatacountsecCombinator>>, SpecModuleCombinatorAlias1);
+type SpecModuleCombinatorAlias3 = (Opt<Preceded<Tag<U8, u8>, SpecElemsecCombinator>>, SpecModuleCombinatorAlias2);
+type SpecModuleCombinatorAlias4 = (Opt<Preceded<Tag<U8, u8>, SpecStartsecCombinator>>, SpecModuleCombinatorAlias3);
+type SpecModuleCombinatorAlias5 = (Opt<Preceded<Tag<U8, u8>, SpecExportsecCombinator>>, SpecModuleCombinatorAlias4);
+type SpecModuleCombinatorAlias6 = (Opt<Preceded<Tag<U8, u8>, SpecGlobalsecCombinator>>, SpecModuleCombinatorAlias5);
+type SpecModuleCombinatorAlias7 = (Opt<Preceded<Tag<U8, u8>, SpecMemsecCombinator>>, SpecModuleCombinatorAlias6);
+type SpecModuleCombinatorAlias8 = (Opt<Preceded<Tag<U8, u8>, SpecTablesecCombinator>>, SpecModuleCombinatorAlias7);
+type SpecModuleCombinatorAlias9 = (Opt<Preceded<Tag<U8, u8>, SpecFuncsecCombinator>>, SpecModuleCombinatorAlias8);
+type SpecModuleCombinatorAlias10 = (Opt<Preceded<Tag<U8, u8>, SpecImportsecCombinator>>, SpecModuleCombinatorAlias9);
+type SpecModuleCombinatorAlias11 = (Opt<Preceded<Tag<U8, u8>, SpecTypesecCombinator>>, SpecModuleCombinatorAlias10);
+type SpecModuleCombinatorAlias12 = (Refined<bytes::Fixed<4>, TagPred<Seq<u8>>>, SpecModuleCombinatorAlias11);
+type SpecModuleCombinatorAlias13 = (Refined<bytes::Fixed<4>, TagPred<Seq<u8>>>, SpecModuleCombinatorAlias12);
+pub struct SpecModuleCombinator(pub SpecModuleCombinatorAlias);
+
+impl SpecCombinator for SpecModuleCombinator {
+    type Type = SpecModule;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecTypesecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecTypesecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecModuleCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecModuleCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecTypesecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecTypesecContentCombinator>>, TypesecMapper>;
+pub type SpecModuleCombinatorAlias = Mapped<SpecModuleCombinatorAlias13, ModuleMapper>;
+pub exec static MODULEMAGIC_CONST: [u8; 4]
+    ensures MODULEMAGIC_CONST@ == SPEC_MODULEMAGIC_CONST,
+{
+    let arr: [u8; 4] = [0, 97, 115, 109];
+    assert(arr@ == SPEC_MODULEMAGIC_CONST);
+    arr
+}
+pub exec static MODULEVERSION_CONST: [u8; 4]
+    ensures MODULEVERSION_CONST@ == SPEC_MODULEVERSION_CONST,
+{
+    let arr: [u8; 4] = [1, 0, 0, 0];
+    assert(arr@ == SPEC_MODULEVERSION_CONST);
+    arr
+}
 
-pub struct TypesecCombinator(pub TypesecCombinatorAlias);
 
-impl View for TypesecCombinator {
-    type V = SpecTypesecCombinator;
-    open spec fn view(&self) -> Self::V { SpecTypesecCombinator(self.0@) }
-}
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for TypesecCombinator {
-    type Type = Typesec;
-    type SType = &'a Self::Type;
-    fn length(&self, v: Self::SType) -> usize
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
-    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
-    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
-    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type TypesecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, TypesecContentCombinator>, TypesecCont0>, TypesecMapper>;
 
 
-pub open spec fn spec_typesec() -> SpecTypesecCombinator {
-    SpecTypesecCombinator(
-    Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_typesec_cont0(deps)),
-        mapper: TypesecMapper,
-    })
+
+
+
+
+
+
+
+
+type ModuleCombinatorAlias1 = (Opt<Preceded<Tag<U8, u8>, CodesecCombinator>>, Opt<Preceded<Tag<U8, u8>, DatasecCombinator>>);
+type ModuleCombinatorAlias2 = (Opt<Preceded<Tag<U8, u8>, DatacountsecCombinator>>, ModuleCombinator1);
+type ModuleCombinatorAlias3 = (Opt<Preceded<Tag<U8, u8>, ElemsecCombinator>>, ModuleCombinator2);
+type ModuleCombinatorAlias4 = (Opt<Preceded<Tag<U8, u8>, StartsecCombinator>>, ModuleCombinator3);
+type ModuleCombinatorAlias5 = (Opt<Preceded<Tag<U8, u8>, ExportsecCombinator>>, ModuleCombinator4);
+type ModuleCombinatorAlias6 = (Opt<Preceded<Tag<U8, u8>, GlobalsecCombinator>>, ModuleCombinator5);
+type ModuleCombinatorAlias7 = (Opt<Preceded<Tag<U8, u8>, MemsecCombinator>>, ModuleCombinator6);
+type ModuleCombinatorAlias8 = (Opt<Preceded<Tag<U8, u8>, TablesecCombinator>>, ModuleCombinator7);
+type ModuleCombinatorAlias9 = (Opt<Preceded<Tag<U8, u8>, FuncsecCombinator>>, ModuleCombinator8);
+type ModuleCombinatorAlias10 = (Opt<Preceded<Tag<U8, u8>, ImportsecCombinator>>, ModuleCombinator9);
+type ModuleCombinatorAlias11 = (Opt<Preceded<Tag<U8, u8>, TypesecCombinator>>, ModuleCombinator10);
+type ModuleCombinatorAlias12 = (Refined<bytes::Fixed<4>, TagPred<[u8; 4]>>, ModuleCombinator11);
+type ModuleCombinatorAlias13 = (Refined<bytes::Fixed<4>, TagPred<[u8; 4]>>, ModuleCombinator12);
+pub struct ModuleCombinator1(pub ModuleCombinatorAlias1);
+impl View for ModuleCombinator1 {
+    type V = SpecModuleCombinatorAlias1;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ModuleCombinator1, ModuleCombinatorAlias1);
 
-pub open spec fn spec_typesec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecTypesecContentCombinator> {
-    let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_typesec_content())
+pub struct ModuleCombinator2(pub ModuleCombinatorAlias2);
+impl View for ModuleCombinator2 {
+    type V = SpecModuleCombinatorAlias2;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ModuleCombinator2, ModuleCombinatorAlias2);
 
-impl View for TypesecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecTypesecContentCombinator>;
+pub struct ModuleCombinator3(pub ModuleCombinatorAlias3);
+impl View for ModuleCombinator3 {
+    type V = SpecModuleCombinatorAlias3;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ModuleCombinator3, ModuleCombinatorAlias3);
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_typesec_cont0(deps)
-        }
-    }
+pub struct ModuleCombinator4(pub ModuleCombinatorAlias4);
+impl View for ModuleCombinator4 {
+    type V = SpecModuleCombinatorAlias4;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ModuleCombinator4, ModuleCombinatorAlias4);
 
-                
-pub fn typesec<'a>() -> (o: TypesecCombinator)
-    ensures o@ == spec_typesec(),
-            o@.requires(),
-            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
-{
-    let combinator = TypesecCombinator(
-    Mapped {
-        inner: Pair::new(UnsignedLEB128, TypesecCont0),
-        mapper: TypesecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_typesec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
-    combinator
+pub struct ModuleCombinator5(pub ModuleCombinatorAlias5);
+impl View for ModuleCombinator5 {
+    type V = SpecModuleCombinatorAlias5;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ModuleCombinator5, ModuleCombinatorAlias5);
 
-pub fn parse_typesec<'a>(input: &'a [u8]) -> (res: PResult<<TypesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
-    requires
-        input.len() <= usize::MAX,
-    ensures
-        res matches Ok((n, v)) ==> spec_typesec().spec_parse(input@) == Some((n as int, v@)),
-        spec_typesec().spec_parse(input@) matches Some((n, v))
-            ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_typesec().spec_parse(input@) is None,
-        spec_typesec().spec_parse(input@) is None ==> res is Err,
-{
-    let combinator = typesec();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+pub struct ModuleCombinator6(pub ModuleCombinatorAlias6);
+impl View for ModuleCombinator6 {
+    type V = SpecModuleCombinatorAlias6;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ModuleCombinator6, ModuleCombinatorAlias6);
 
-pub fn serialize_typesec<'a>(v: <TypesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
-    requires
-        pos <= old(data)@.len() <= usize::MAX,
-        spec_typesec().wf(v@),
-    ensures
-        o matches Ok(n) ==> {
-            &&& data@.len() == old(data)@.len()
-            &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_typesec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_typesec().spec_serialize(v@))
-        },
-{
-    let combinator = typesec();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+pub struct ModuleCombinator7(pub ModuleCombinatorAlias7);
+impl View for ModuleCombinator7 {
+    type V = SpecModuleCombinatorAlias7;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ModuleCombinator7, ModuleCombinatorAlias7);
 
-pub fn typesec_len<'a>(v: <TypesecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
-    requires
-        spec_typesec().wf(v@),
-        spec_typesec().spec_serialize(v@).len() <= usize::MAX,
-    ensures
-        serialize_len == spec_typesec().spec_serialize(v@).len(),
-{
-    let combinator = typesec();
-    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+pub struct ModuleCombinator8(pub ModuleCombinatorAlias8);
+impl View for ModuleCombinator8 {
+    type V = SpecModuleCombinatorAlias8;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ModuleCombinator8, ModuleCombinatorAlias8);
 
-pub struct TypesecCont0;
-type TypesecCont0Type<'a, 'b> = &'b u64;
-type TypesecCont0SType<'a, 'x> = &'x u64;
-type TypesecCont0Input<'a, 'b, 'x> = POrSType<TypesecCont0Type<'a, 'b>, TypesecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<TypesecCont0Input<'a, 'b, 'x>> for TypesecCont0 {
-    type Output = AndThen<bytes::Variable, TypesecContentCombinator>;
+pub struct ModuleCombinator9(pub ModuleCombinatorAlias9);
+impl View for ModuleCombinator9 {
+    type V = SpecModuleCombinatorAlias9;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ModuleCombinator9, ModuleCombinatorAlias9);
 
-    open spec fn requires(&self, deps: TypesecCont0Input<'a, 'b, 'x>) -> bool { true }
+pub struct ModuleCombinator10(pub ModuleCombinatorAlias10);
+impl View for ModuleCombinator10 {
+    type V = SpecModuleCombinatorAlias10;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ModuleCombinator10, ModuleCombinatorAlias10);
 
-    open spec fn ensures(&self, deps: TypesecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_typesec_cont0(deps@)
-    }
+pub struct ModuleCombinator11(pub ModuleCombinatorAlias11);
+impl View for ModuleCombinator11 {
+    type V = SpecModuleCombinatorAlias11;
+    open spec fn view(&self) -> Self::V { self.0@ }
+}
+impl_wrapper_combinator!(ModuleCombinator11, ModuleCombinatorAlias11);
 
-    fn apply(&self, deps: TypesecCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), typesec_content())
-            }
-            POrSType::S(deps) => {
-                let size = deps;
-                let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), typesec_content())
-            }
-        }
-    }
+pub struct ModuleCombinator12(pub ModuleCombinatorAlias12);
+impl View for ModuleCombinator12 {
+    type V = SpecModuleCombinatorAlias12;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
-                
+impl_wrapper_combinator!(ModuleCombinator12, ModuleCombinatorAlias12);
 
-pub struct SpecImportsec {
-    pub size: u64,
-    pub cont: SpecImports,
+pub struct ModuleCombinator13(pub ModuleCombinatorAlias13);
+impl View for ModuleCombinator13 {
+    type V = SpecModuleCombinatorAlias13;
+    open spec fn view(&self) -> Self::V { self.0@ }
 }
+impl_wrapper_combinator!(ModuleCombinator13, ModuleCombinatorAlias13);
 
-pub type SpecImportsecInner = (u64, SpecImports);
+pub struct ModuleCombinator(pub ModuleCombinatorAlias);
+
+impl View for ModuleCombinator {
+    type V = SpecModuleCombinator;
+    open spec fn view(&self) -> Self::V { SpecModuleCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ModuleCombinator {
+    type Type = Module<'a>;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type ModuleCombinatorAlias = Mapped<ModuleCombinator13, ModuleMapper>;
 
 
-impl SpecFrom<SpecImportsec> for SpecImportsecInner {
-    open spec fn spec_from(m: SpecImportsec) -> SpecImportsecInner {
-        (m.size, m.cont)
-    }
+pub open spec fn spec_module() -> SpecModuleCombinator {
+    SpecModuleCombinator(
+    Mapped {
+        inner: (Refined { inner: bytes::Fixed::<4>, predicate: TagPred(SPEC_MODULEMAGIC_CONST) }, (Refined { inner: bytes::Fixed::<4>, predicate: TagPred(SPEC_MODULEVERSION_CONST) }, (Opt(Preceded(Tag::spec_new(U8, MODULETYPES_0_FRONT_CONST), spec_typesec())), (Opt(Preceded(Tag::spec_new(U8, MODULEIMPORTS_0_FRONT_CONST), spec_importsec())), (Opt(Preceded(Tag::spec_new(U8, MODULETYPEIDXS_0_FRONT_CONST), spec_funcsec())), (Opt(Preceded(Tag::spec_new(U8, MODULETABLES_0_FRONT_CONST), spec_tablesec())), (Opt(Preceded(Tag::spec_new(U8, MODULEMEMS_0_FRONT_CONST), spec_memsec())), (Opt(Preceded(Tag::spec_new(U8, MODULEGLOBALS_0_FRONT_CONST), spec_globalsec())), (Opt(Preceded(Tag::spec_new(U8, MODULEEXPORTS_0_FRONT_CONST), spec_exportsec())), (Opt(Preceded(Tag::spec_new(U8, MODULESTART_0_FRONT_CONST), spec_startsec())), (Opt(Preceded(Tag::spec_new(U8, MODULEELEMS_0_FRONT_CONST), spec_elemsec())), (Opt(Preceded(Tag::spec_new(U8, MODULEDATACOUNT_0_FRONT_CONST), spec_datacountsec())), (Opt(Preceded(Tag::spec_new(U8, MODULECODES_0_FRONT_CONST), spec_codesec())), Opt(Preceded(Tag::spec_new(U8, MODULEDATAS_0_FRONT_CONST), spec_datasec()))))))))))))))),
+        mapper: ModuleMapper,
+    })
 }
 
-impl SpecFrom<SpecImportsecInner> for SpecImportsec {
-    open spec fn spec_from(m: SpecImportsecInner) -> SpecImportsec {
-        let (size, cont) = m;
-        SpecImportsec { size, cont }
-    }
+                
+pub fn module<'a>() -> (o: ModuleCombinator)
+    ensures o@ == spec_module(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = ModuleCombinator(
+    Mapped {
+        inner: ModuleCombinator13((Refined { inner: bytes::Fixed::<4>, predicate: TagPred(MODULEMAGIC_CONST) }, ModuleCombinator12((Refined { inner: bytes::Fixed::<4>, predicate: TagPred(MODULEVERSION_CONST) }, ModuleCombinator11((Opt::new(Preceded(Tag::new(U8, MODULETYPES_0_FRONT_CONST), typesec())), ModuleCombinator10((Opt::new(Preceded(Tag::new(U8, MODULEIMPORTS_0_FRONT_CONST), importsec())), ModuleCombinator9((Opt::new(Preceded(Tag::new(U8, MODULETYPEIDXS_0_FRONT_CONST), funcsec())), ModuleCombinator8((Opt::new(Preceded(Tag::new(U8, MODULETABLES_0_FRONT_CONST), tablesec())), ModuleCombinator7((Opt::new(Preceded(Tag::new(U8, MODULEMEMS_0_FRONT_CONST), memsec())), ModuleCombinator6((Opt::new(Preceded(Tag::new(U8, MODULEGLOBALS_0_FRONT_CONST), globalsec())), ModuleCombinator5((Opt::new(Preceded(Tag::new(U8, MODULEEXPORTS_0_FRONT_CONST), exportsec())), ModuleCombinator4((Opt::new(Preceded(Tag::new(U8, MODULESTART_0_FRONT_CONST), startsec())), ModuleCombinator3((Opt::new(Preceded(Tag::new(U8, MODULEELEMS_0_FRONT_CONST), elemsec())), ModuleCombinator2((Opt::new(Preceded(Tag::new(U8, MODULEDATACOUNT_0_FRONT_CONST), datacountsec())), ModuleCombinator1((Opt::new(Preceded(Tag::new(U8, MODULECODES_0_FRONT_CONST), codesec())), Opt::new(Preceded(Tag::new(U8, MODULEDATAS_0_FRONT_CONST), datasec())))))))))))))))))))))))))))),
+        mapper: ModuleMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_module()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Importsec {
-    pub size: u64,
-    pub cont: Imports,
+pub fn parse_module<'a>(input: &'a [u8]) -> (res: PResult<<ModuleCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_module().spec_parse(input@) == Some((n as int, v@)),
+        spec_module().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_module().spec_parse(input@) is None,
+        spec_module().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = module();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-impl View for Importsec {
-    type V = SpecImportsec;
-
-    open spec fn view(&self) -> Self::V {
-        SpecImportsec {
-            size: self.size@,
-            cont: self.cont@,
-        }
-    }
+pub fn serialize_module<'a>(v: <ModuleCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_module().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_module().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_module().spec_serialize(v@))
+        },
+{
+    let combinator = module();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
-pub type ImportsecInner = (u64, Imports);
 
-pub type ImportsecInnerRef<'a> = (&'a u64, &'a Imports);
-impl<'a> From<&'a Importsec> for ImportsecInnerRef<'a> {
-    fn ex_from(m: &'a Importsec) -> ImportsecInnerRef<'a> {
-        (&m.size, &m.cont)
-    }
+pub fn module_len<'a>(v: <ModuleCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_module().wf(v@),
+        spec_module().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_module().spec_serialize(v@).len(),
+{
+    let combinator = module();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-impl From<ImportsecInner> for Importsec {
-    fn ex_from(m: ImportsecInner) -> Importsec {
-        let (size, cont) = m;
-        Importsec { size, cont }
-    }
-}
+                
+pub type SpecSigned32 = Seq<u8>;
+pub type Signed32<'a> = &'a [u8];
+pub type Signed32Ref<'a> = &'a &'a [u8];
 
-pub struct ImportsecMapper;
-impl View for ImportsecMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for ImportsecMapper {
-    type Src = SpecImportsecInner;
-    type Dst = SpecImportsec;
-}
-impl SpecIsoProof for ImportsecMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
-}
-impl<'a> Iso<'a> for ImportsecMapper {
-    type Src = ImportsecInner;
-    type Dst = Importsec;
-    type RefSrc = ImportsecInnerRef<'a>;
-}
 
-pub struct SpecImportsecCombinator(pub SpecImportsecCombinatorAlias);
+pub struct SpecSigned32Combinator(pub SpecSigned32CombinatorAlias);
 
-impl SpecCombinator for SpecImportsecCombinator {
-    type Type = SpecImportsec;
+impl SpecCombinator for SpecSigned32Combinator {
+    type Type = SpecSigned32;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecImportsecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecImportsecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecSigned32Combinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecSigned32CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecImportsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecImportsCombinator>>, ImportsecMapper>;
+pub type SpecSigned32CombinatorAlias = bytes::Fixed<4>;
 
-pub struct ImportsecCombinator(pub ImportsecCombinatorAlias);
+pub struct Signed32Combinator(pub Signed32CombinatorAlias);
 
-impl View for ImportsecCombinator {
-    type V = SpecImportsecCombinator;
-    open spec fn view(&self) -> Self::V { SpecImportsecCombinator(self.0@) }
+impl View for Signed32Combinator {
+    type V = SpecSigned32Combinator;
+    open spec fn view(&self) -> Self::V { SpecSigned32Combinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ImportsecCombinator {
-    type Type = Importsec;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Signed32Combinator {
+    type Type = Signed32<'a>;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ImportsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, ImportsCombinator>, ImportsecCont0>, ImportsecMapper>;
-
-
-pub open spec fn spec_importsec() -> SpecImportsecCombinator {
-    SpecImportsecCombinator(
-    Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_importsec_cont0(deps)),
-        mapper: ImportsecMapper,
-    })
-}
-
-pub open spec fn spec_importsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecImportsCombinator> {
-    let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_imports())
 }
+pub type Signed32CombinatorAlias = bytes::Fixed<4>;
 
-impl View for ImportsecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecImportsCombinator>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_importsec_cont0(deps)
-        }
-    }
+pub open spec fn spec_signed_32() -> SpecSigned32Combinator {
+    SpecSigned32Combinator(bytes::Fixed::<4>)
 }
 
                 
-pub fn importsec<'a>() -> (o: ImportsecCombinator)
-    ensures o@ == spec_importsec(),
+pub fn signed_32<'a>() -> (o: Signed32Combinator)
+    ensures o@ == spec_signed_32(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ImportsecCombinator(
-    Mapped {
-        inner: Pair::new(UnsignedLEB128, ImportsecCont0),
-        mapper: ImportsecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_importsec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = Signed32Combinator(bytes::Fixed::<4>);
+    // assert({
+    //     &&& combinator@ == spec_signed_32()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_importsec<'a>(input: &'a [u8]) -> (res: PResult<<ImportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_signed_32<'a>(input: &'a [u8]) -> (res: PResult<<Signed32Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_importsec().spec_parse(input@) == Some((n as int, v@)),
-        spec_importsec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_signed_32().spec_parse(input@) == Some((n as int, v@)),
+        spec_signed_32().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_importsec().spec_parse(input@) is None,
-        spec_importsec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_signed_32().spec_parse(input@) is None,
+        spec_signed_32().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = importsec();
+    let combinator = signed_32();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_importsec<'a>(v: <ImportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_signed_32<'a>(v: <Signed32Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_importsec().wf(v@),
+        spec_signed_32().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_importsec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_importsec().spec_serialize(v@))
+            &&& n == spec_signed_32().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_signed_32().spec_serialize(v@))
         },
 {
-    let combinator = importsec();
+    let combinator = signed_32();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn importsec_len<'a>(v: <ImportsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn signed_32_len<'a>(v: <Signed32Combinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_importsec().wf(v@),
-        spec_importsec().spec_serialize(v@).len() <= usize::MAX,
+        spec_signed_32().wf(v@),
+        spec_signed_32().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_importsec().spec_serialize(v@).len(),
+        serialize_len == spec_signed_32().spec_serialize(v@).len(),
 {
-    let combinator = importsec();
+    let combinator = signed_32();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct ImportsecCont0;
-type ImportsecCont0Type<'a, 'b> = &'b u64;
-type ImportsecCont0SType<'a, 'x> = &'x u64;
-type ImportsecCont0Input<'a, 'b, 'x> = POrSType<ImportsecCont0Type<'a, 'b>, ImportsecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<ImportsecCont0Input<'a, 'b, 'x>> for ImportsecCont0 {
-    type Output = AndThen<bytes::Variable, ImportsCombinator>;
-
-    open spec fn requires(&self, deps: ImportsecCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: ImportsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_importsec_cont0(deps@)
-    }
-
-    fn apply(&self, deps: ImportsecCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), imports())
-            }
-            POrSType::S(deps) => {
-                let size = deps;
-                let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), imports())
-            }
-        }
-    }
-}
                 
+pub type SpecELEMKIND = u8;
+pub type ELEMKIND = u8;
+pub type ELEMKINDRef<'a> = &'a u8;
 
-pub struct SpecStartsec {
-    pub size: u64,
-    pub cont: SpecStart,
-}
-
-pub type SpecStartsecInner = (u64, SpecStart);
-
-
-impl SpecFrom<SpecStartsec> for SpecStartsecInner {
-    open spec fn spec_from(m: SpecStartsec) -> SpecStartsecInner {
-        (m.size, m.cont)
-    }
-}
-
-impl SpecFrom<SpecStartsecInner> for SpecStartsec {
-    open spec fn spec_from(m: SpecStartsecInner) -> SpecStartsec {
-        let (size, cont) = m;
-        SpecStartsec { size, cont }
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-
-pub struct Startsec {
-    pub size: u64,
-    pub cont: Start,
-}
+pub const ELEMKIND_CONST: u8 = 0;
+pub type SpecELEMKINDCombinator = Refined<U8, TagPred<u8>>;
+pub type ELEMKINDCombinator = Refined<U8, TagPred<u8>>;
 
-impl View for Startsec {
-    type V = SpecStartsec;
 
-    open spec fn view(&self) -> Self::V {
-        SpecStartsec {
-            size: self.size@,
-            cont: self.cont@,
-        }
-    }
+pub open spec fn spec_ELEMKIND() -> SpecELEMKINDCombinator {
+    Refined { inner: U8, predicate: TagPred(ELEMKIND_CONST) }
 }
-pub type StartsecInner = (u64, Start);
 
-pub type StartsecInnerRef<'a> = (&'a u64, &'a Start);
-impl<'a> From<&'a Startsec> for StartsecInnerRef<'a> {
-    fn ex_from(m: &'a Startsec) -> StartsecInnerRef<'a> {
-        (&m.size, &m.cont)
-    }
+pub fn ELEMKIND<'a>() -> (o: ELEMKINDCombinator)
+    ensures o@ == spec_ELEMKIND(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = Refined { inner: U8, predicate: TagPred(ELEMKIND_CONST) };
+    // assert({
+    //     &&& combinator@ == spec_ELEMKIND()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
 }
 
-impl From<StartsecInner> for Startsec {
-    fn ex_from(m: StartsecInner) -> Startsec {
-        let (size, cont) = m;
-        Startsec { size, cont }
-    }
+pub fn parse_ELEMKIND<'a>(input: &'a [u8]) -> (res: PResult<<ELEMKINDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_ELEMKIND().spec_parse(input@) == Some((n as int, v@)),
+        spec_ELEMKIND().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_ELEMKIND().spec_parse(input@) is None,
+        spec_ELEMKIND().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = ELEMKIND();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub struct StartsecMapper;
-impl View for StartsecMapper {
-    type V = Self;
-    open spec fn view(&self) -> Self::V {
-        *self
-    }
-}
-impl SpecIso for StartsecMapper {
-    type Src = SpecStartsecInner;
-    type Dst = SpecStartsec;
-}
-impl SpecIsoProof for StartsecMapper {
-    proof fn spec_iso(s: Self::Src) {
-        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
-    }
-    proof fn spec_iso_rev(s: Self::Dst) {
-        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
-    }
+pub fn serialize_ELEMKIND<'a>(v: <ELEMKINDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_ELEMKIND().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_ELEMKIND().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_ELEMKIND().spec_serialize(v@))
+        },
+{
+    let combinator = ELEMKIND();
+    combinator.serialize(v, data, pos)
 }
-impl<'a> Iso<'a> for StartsecMapper {
-    type Src = StartsecInner;
-    type Dst = Startsec;
-    type RefSrc = StartsecInnerRef<'a>;
+
+pub fn ELEMKIND_len<'a>(v: <ELEMKINDCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_ELEMKIND().wf(v@),
+        spec_ELEMKIND().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_ELEMKIND().spec_serialize(v@).len(),
+{
+    let combinator = ELEMKIND();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct SpecStartsecCombinator(pub SpecStartsecCombinatorAlias);
+pub type SpecMyCustomSection = SpecByteVec;
+pub type MyCustomSection = ByteVec;
+pub type MyCustomSectionRef<'a> = &'a ByteVec;
 
-impl SpecCombinator for SpecStartsecCombinator {
-    type Type = SpecStartsec;
+
+pub struct SpecMyCustomSectionCombinator(pub SpecMyCustomSectionCombinatorAlias);
+
+impl SpecCombinator for SpecMyCustomSectionCombinator {
+    type Type = SpecMyCustomSection;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecStartsecCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecStartsecCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecMyCustomSectionCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecMyCustomSectionCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecStartsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecStartCombinator>>, StartsecMapper>;
+pub type SpecMyCustomSectionCombinatorAlias = SpecByteVecCombinator;
 
-pub struct StartsecCombinator(pub StartsecCombinatorAlias);
+pub struct MyCustomSectionCombinator(pub MyCustomSectionCombinatorAlias);
 
-impl View for StartsecCombinator {
-    type V = SpecStartsecCombinator;
-    open spec fn view(&self) -> Self::V { SpecStartsecCombinator(self.0@) }
+impl View for MyCustomSectionCombinator {
+    type V = SpecMyCustomSectionCombinator;
+    open spec fn view(&self) -> Self::V { SpecMyCustomSectionCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for StartsecCombinator {
-    type Type = Startsec;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for MyCustomSectionCombinator {
+    type Type = MyCustomSection;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type StartsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, StartCombinator>, StartsecCont0>, StartsecMapper>;
-
-
-pub open spec fn spec_startsec() -> SpecStartsecCombinator {
-    SpecStartsecCombinator(
-    Mapped {
-        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_startsec_cont0(deps)),
-        mapper: StartsecMapper,
-    })
-}
-
-pub open spec fn spec_startsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecStartCombinator> {
-    let size = deps;
-    AndThen(bytes::Variable(size.spec_into()), spec_start())
 }
+pub type MyCustomSectionCombinatorAlias = ByteVecCombinator;
 
-impl View for StartsecCont0 {
-    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecStartCombinator>;
 
-    open spec fn view(&self) -> Self::V {
-        |deps: u64| {
-            spec_startsec_cont0(deps)
-        }
-    }
+pub open spec fn spec_my_custom_section() -> SpecMyCustomSectionCombinator {
+    SpecMyCustomSectionCombinator(spec_byte_vec())
 }
 
                 
-pub fn startsec<'a>() -> (o: StartsecCombinator)
-    ensures o@ == spec_startsec(),
+pub fn my_custom_section<'a>() -> (o: MyCustomSectionCombinator)
+    ensures o@ == spec_my_custom_section(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = StartsecCombinator(
-    Mapped {
-        inner: Pair::new(UnsignedLEB128, StartsecCont0),
-        mapper: StartsecMapper,
-    });
-    assert({
-        &&& combinator@ == spec_startsec()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    let combinator = MyCustomSectionCombinator(byte_vec());
+    // assert({
+    //     &&& combinator@ == spec_my_custom_section()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_startsec<'a>(input: &'a [u8]) -> (res: PResult<<StartsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_my_custom_section<'a>(input: &'a [u8]) -> (res: PResult<<MyCustomSectionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_startsec().spec_parse(input@) == Some((n as int, v@)),
-        spec_startsec().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_my_custom_section().spec_parse(input@) == Some((n as int, v@)),
+        spec_my_custom_section().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_startsec().spec_parse(input@) is None,
-        spec_startsec().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_my_custom_section().spec_parse(input@) is None,
+        spec_my_custom_section().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = startsec();
+    let combinator = my_custom_section();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_startsec<'a>(v: <StartsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_my_custom_section<'a>(v: <MyCustomSectionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_startsec().wf(v@),
+        spec_my_custom_section().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_startsec().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_startsec().spec_serialize(v@))
+            &&& n == spec_my_custom_section().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_my_custom_section().spec_serialize(v@))
         },
 {
-    let combinator = startsec();
+    let combinator = my_custom_section();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn startsec_len<'a>(v: <StartsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn my_custom_section_len<'a>(v: <MyCustomSectionCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_startsec().wf(v@),
-        spec_startsec().spec_serialize(v@).len() <= usize::MAX,
+        spec_my_custom_section().wf(v@),
+        spec_my_custom_section().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_startsec().spec_serialize(v@).len(),
+        serialize_len == spec_my_custom_section().spec_serialize(v@).len(),
 {
-    let combinator = startsec();
+    let combinator = my_custom_section();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
-pub struct StartsecCont0;
-type StartsecCont0Type<'a, 'b> = &'b u64;
-type StartsecCont0SType<'a, 'x> = &'x u64;
-type StartsecCont0Input<'a, 'b, 'x> = POrSType<StartsecCont0Type<'a, 'b>, StartsecCont0SType<'a, 'x>>;
-impl<'a, 'b, 'x> Continuation<StartsecCont0Input<'a, 'b, 'x>> for StartsecCont0 {
-    type Output = AndThen<bytes::Variable, StartCombinator>;
-
-    open spec fn requires(&self, deps: StartsecCont0Input<'a, 'b, 'x>) -> bool { true }
-
-    open spec fn ensures(&self, deps: StartsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
-        o@ == spec_startsec_cont0(deps@)
-    }
-
-    fn apply(&self, deps: StartsecCont0Input<'a, 'b, 'x>) -> Self::Output {
-        match deps {
-            POrSType::P(deps) => {
-                let size = *deps;
-                AndThen(bytes::Variable(size.ex_into()), start())
-            }
-            POrSType::S(deps) => {
-                let size = deps;
-                let size = *size;
-                AndThen(bytes::Variable(size.ex_into()), start())
-            }
-        }
-    }
-}
                 
 
-pub struct SpecModule {
-    pub magic: Seq<u8>,
-    pub version: Seq<u8>,
-    pub types: Option<SpecTypesec>,
-    pub imports: Option<SpecImportsec>,
-    pub typeidxs: Option<SpecFuncsec>,
-    pub tables: Option<SpecTablesec>,
-    pub mems: Option<SpecMemsec>,
-    pub globals: Option<SpecGlobalsec>,
-    pub exports: Option<SpecExportsec>,
-    pub start: Option<SpecStartsec>,
-    pub elems: Option<SpecElemsec>,
-    pub datacount: Option<SpecDatacountsec>,
-    pub codes: Option<SpecCodesec>,
-    pub datas: Option<SpecDatasec>,
+pub struct SpecCustom {
+    pub name: SpecName,
+    pub data: SpecMyCustomSection,
 }
 
-pub type SpecModuleInner = (Seq<u8>, (Seq<u8>, (Option<SpecTypesec>, (Option<SpecImportsec>, (Option<SpecFuncsec>, (Option<SpecTablesec>, (Option<SpecMemsec>, (Option<SpecGlobalsec>, (Option<SpecExportsec>, (Option<SpecStartsec>, (Option<SpecElemsec>, (Option<SpecDatacountsec>, (Option<SpecCodesec>, Option<SpecDatasec>)))))))))))));
+pub type SpecCustomInner = (SpecName, SpecMyCustomSection);
 
 
-impl SpecFrom<SpecModule> for SpecModuleInner {
-    open spec fn spec_from(m: SpecModule) -> SpecModuleInner {
-        (m.magic, (m.version, (m.types, (m.imports, (m.typeidxs, (m.tables, (m.mems, (m.globals, (m.exports, (m.start, (m.elems, (m.datacount, (m.codes, m.datas)))))))))))))
+impl SpecFrom<SpecCustom> for SpecCustomInner {
+    open spec fn spec_from(m: SpecCustom) -> SpecCustomInner {
+        (m.name, m.data)
     }
 }
 
-impl SpecFrom<SpecModuleInner> for SpecModule {
-    open spec fn spec_from(m: SpecModuleInner) -> SpecModule {
-        let (magic, (version, (types, (imports, (typeidxs, (tables, (mems, (globals, (exports, (start, (elems, (datacount, (codes, datas))))))))))))) = m;
-        SpecModule { magic, version, types, imports, typeidxs, tables, mems, globals, exports, start, elems, datacount, codes, datas }
+impl SpecFrom<SpecCustomInner> for SpecCustom {
+    open spec fn spec_from(m: SpecCustomInner) -> SpecCustom {
+        let (name, data) = m;
+        SpecCustom { name, data }
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq)]
 
-pub struct Module<'a> {
-    pub magic: &'a [u8],
-    pub version: &'a [u8],
-    pub types: Optional<Typesec>,
-    pub imports: Optional<Importsec>,
-    pub typeidxs: Optional<Funcsec>,
-    pub tables: Optional<Tablesec>,
-    pub mems: Optional<Memsec>,
-    pub globals: Optional<Globalsec<'a>>,
-    pub exports: Optional<Exportsec>,
-    pub start: Optional<Startsec>,
-    pub elems: Optional<Elemsec<'a>>,
-    pub datacount: Optional<Datacountsec>,
-    pub codes: Optional<Codesec<'a>>,
-    pub datas: Optional<Datasec<'a>>,
+pub struct Custom {
+    pub name: Name,
+    pub data: MyCustomSection,
 }
 
-impl View for Module<'_> {
-    type V = SpecModule;
+impl View for Custom {
+    type V = SpecCustom;
 
     open spec fn view(&self) -> Self::V {
-        SpecModule {
-            magic: self.magic@,
-            version: self.version@,
-            types: self.types@,
-            imports: self.imports@,
-            typeidxs: self.typeidxs@,
-            tables: self.tables@,
-            mems: self.mems@,
-            globals: self.globals@,
-            exports: self.exports@,
-            start: self.start@,
-            elems: self.elems@,
-            datacount: self.datacount@,
-            codes: self.codes@,
-            datas: self.datas@,
+        SpecCustom {
+            name: self.name@,
+            data: self.data@,
         }
     }
 }
-pub type ModuleInner<'a> = (&'a [u8], (&'a [u8], (Optional<Typesec>, (Optional<Importsec>, (Optional<Funcsec>, (Optional<Tablesec>, (Optional<Memsec>, (Optional<Globalsec<'a>>, (Optional<Exportsec>, (Optional<Startsec>, (Optional<Elemsec<'a>>, (Optional<Datacountsec>, (Optional<Codesec<'a>>, Optional<Datasec<'a>>)))))))))))));
+pub type CustomInner = (Name, MyCustomSection);
 
-pub type ModuleInnerRef<'a> = (&'a &'a [u8], (&'a &'a [u8], (&'a Optional<Typesec>, (&'a Optional<Importsec>, (&'a Optional<Funcsec>, (&'a Optional<Tablesec>, (&'a Optional<Memsec>, (&'a Optional<Globalsec<'a>>, (&'a Optional<Exportsec>, (&'a Optional<Startsec>, (&'a Optional<Elemsec<'a>>, (&'a Optional<Datacountsec>, (&'a Optional<Codesec<'a>>, &'a Optional<Datasec<'a>>)))))))))))));
-impl<'a> From<&'a Module<'a>> for ModuleInnerRef<'a> {
-    fn ex_from(m: &'a Module) -> ModuleInnerRef<'a> {
-        (&m.magic, (&m.version, (&m.types, (&m.imports, (&m.typeidxs, (&m.tables, (&m.mems, (&m.globals, (&m.exports, (&m.start, (&m.elems, (&m.datacount, (&m.codes, &m.datas)))))))))))))
+pub type CustomInnerRef<'a> = (&'a Name, &'a MyCustomSection);
+impl<'a> From<&'a Custom> for CustomInnerRef<'a> {
+    fn ex_from(m: &'a Custom) -> CustomInnerRef<'a> {
+        (&m.name, &m.data)
     }
 }
 
-impl<'a> From<ModuleInner<'a>> for Module<'a> {
-    fn ex_from(m: ModuleInner) -> Module {
-        let (magic, (version, (types, (imports, (typeidxs, (tables, (mems, (globals, (exports, (start, (elems, (datacount, (codes, datas))))))))))))) = m;
-        Module { magic, version, types, imports, typeidxs, tables, mems, globals, exports, start, elems, datacount, codes, datas }
+impl From<CustomInner> for Custom {
+    fn ex_from(m: CustomInner) -> Custom {
+        let (name, data) = m;
+        Custom { name, data }
     }
 }
 
-pub struct ModuleMapper;
-impl View for ModuleMapper {
+pub struct CustomMapper;
+impl View for CustomMapper {
     type V = Self;
     open spec fn view(&self) -> Self::V {
         *self
     }
 }
-impl SpecIso for ModuleMapper {
-    type Src = SpecModuleInner;
-    type Dst = SpecModule;
+impl SpecIso for CustomMapper {
+    type Src = SpecCustomInner;
+    type Dst = SpecCustom;
 }
-impl SpecIsoProof for ModuleMapper {
+impl SpecIsoProof for CustomMapper {
     proof fn spec_iso(s: Self::Src) {
         assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
     }
@@ -25696,294 +25837,136 @@ impl SpecIsoProof for ModuleMapper {
         assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
     }
 }
-impl<'a> Iso<'a> for ModuleMapper {
-    type Src = ModuleInner<'a>;
-    type Dst = Module<'a>;
-    type RefSrc = ModuleInnerRef<'a>;
+impl<'a> Iso<'a> for CustomMapper {
+    type Src = CustomInner;
+    type Dst = Custom;
+    type RefSrc = CustomInnerRef<'a>;
 }
-pub spec const SPEC_MODULEMAGIC_CONST: Seq<u8> = seq![0, 97, 115, 109];pub spec const SPEC_MODULEVERSION_CONST: Seq<u8> = seq![1, 0, 0, 0];pub const MODULETYPES_0_FRONT_CONST: u8 = 1;
-
-pub const MODULEIMPORTS_0_FRONT_CONST: u8 = 2;
-
-pub const MODULETYPEIDXS_0_FRONT_CONST: u8 = 3;
-
-pub const MODULETABLES_0_FRONT_CONST: u8 = 4;
-
-pub const MODULEMEMS_0_FRONT_CONST: u8 = 5;
-
-pub const MODULEGLOBALS_0_FRONT_CONST: u8 = 6;
-
-pub const MODULEEXPORTS_0_FRONT_CONST: u8 = 7;
-
-pub const MODULESTART_0_FRONT_CONST: u8 = 8;
-
-pub const MODULEELEMS_0_FRONT_CONST: u8 = 9;
-
-pub const MODULEDATACOUNT_0_FRONT_CONST: u8 = 12;
-
-pub const MODULECODES_0_FRONT_CONST: u8 = 10;
-
-pub const MODULEDATAS_0_FRONT_CONST: u8 = 11;
-
-type SpecModuleCombinatorAlias1 = (Opt<Preceded<Tag<U8, u8>, SpecCodesecCombinator>>, Opt<Preceded<Tag<U8, u8>, SpecDatasecCombinator>>);
-type SpecModuleCombinatorAlias2 = (Opt<Preceded<Tag<U8, u8>, SpecDatacountsecCombinator>>, SpecModuleCombinatorAlias1);
-type SpecModuleCombinatorAlias3 = (Opt<Preceded<Tag<U8, u8>, SpecElemsecCombinator>>, SpecModuleCombinatorAlias2);
-type SpecModuleCombinatorAlias4 = (Opt<Preceded<Tag<U8, u8>, SpecStartsecCombinator>>, SpecModuleCombinatorAlias3);
-type SpecModuleCombinatorAlias5 = (Opt<Preceded<Tag<U8, u8>, SpecExportsecCombinator>>, SpecModuleCombinatorAlias4);
-type SpecModuleCombinatorAlias6 = (Opt<Preceded<Tag<U8, u8>, SpecGlobalsecCombinator>>, SpecModuleCombinatorAlias5);
-type SpecModuleCombinatorAlias7 = (Opt<Preceded<Tag<U8, u8>, SpecMemsecCombinator>>, SpecModuleCombinatorAlias6);
-type SpecModuleCombinatorAlias8 = (Opt<Preceded<Tag<U8, u8>, SpecTablesecCombinator>>, SpecModuleCombinatorAlias7);
-type SpecModuleCombinatorAlias9 = (Opt<Preceded<Tag<U8, u8>, SpecFuncsecCombinator>>, SpecModuleCombinatorAlias8);
-type SpecModuleCombinatorAlias10 = (Opt<Preceded<Tag<U8, u8>, SpecImportsecCombinator>>, SpecModuleCombinatorAlias9);
-type SpecModuleCombinatorAlias11 = (Opt<Preceded<Tag<U8, u8>, SpecTypesecCombinator>>, SpecModuleCombinatorAlias10);
-type SpecModuleCombinatorAlias12 = (Refined<bytes::Fixed<4>, TagPred<Seq<u8>>>, SpecModuleCombinatorAlias11);
-type SpecModuleCombinatorAlias13 = (Refined<bytes::Fixed<4>, TagPred<Seq<u8>>>, SpecModuleCombinatorAlias12);
-pub struct SpecModuleCombinator(pub SpecModuleCombinatorAlias);
+type SpecCustomCombinatorAlias1 = (SpecNameCombinator, SpecMyCustomSectionCombinator);
+pub struct SpecCustomCombinator(pub SpecCustomCombinatorAlias);
 
-impl SpecCombinator for SpecModuleCombinator {
-    type Type = SpecModule;
+impl SpecCombinator for SpecCustomCombinator {
+    type Type = SpecCustom;
     open spec fn requires(&self) -> bool
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
-impl SecureSpecCombinator for SpecModuleCombinator {
-    open spec fn is_prefix_secure() -> bool 
-    { SpecModuleCombinatorAlias::is_prefix_secure() }
+impl SecureSpecCombinator for SpecCustomCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCustomCombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
     proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
-pub type SpecModuleCombinatorAlias = Mapped<SpecModuleCombinatorAlias13, ModuleMapper>;
-pub exec static MODULEMAGIC_CONST: [u8; 4]
-    ensures MODULEMAGIC_CONST@ == SPEC_MODULEMAGIC_CONST,
-{
-    let arr: [u8; 4] = [0, 97, 115, 109];
-    assert(arr@ == SPEC_MODULEMAGIC_CONST);
-    arr
-}
-pub exec static MODULEVERSION_CONST: [u8; 4]
-    ensures MODULEVERSION_CONST@ == SPEC_MODULEVERSION_CONST,
-{
-    let arr: [u8; 4] = [1, 0, 0, 0];
-    assert(arr@ == SPEC_MODULEVERSION_CONST);
-    arr
-}
-
-
-
-
-
-
-
-
-
-
-
-
-type ModuleCombinatorAlias1 = (Opt<Preceded<Tag<U8, u8>, CodesecCombinator>>, Opt<Preceded<Tag<U8, u8>, DatasecCombinator>>);
-type ModuleCombinatorAlias2 = (Opt<Preceded<Tag<U8, u8>, DatacountsecCombinator>>, ModuleCombinator1);
-type ModuleCombinatorAlias3 = (Opt<Preceded<Tag<U8, u8>, ElemsecCombinator>>, ModuleCombinator2);
-type ModuleCombinatorAlias4 = (Opt<Preceded<Tag<U8, u8>, StartsecCombinator>>, ModuleCombinator3);
-type ModuleCombinatorAlias5 = (Opt<Preceded<Tag<U8, u8>, ExportsecCombinator>>, ModuleCombinator4);
-type ModuleCombinatorAlias6 = (Opt<Preceded<Tag<U8, u8>, GlobalsecCombinator>>, ModuleCombinator5);
-type ModuleCombinatorAlias7 = (Opt<Preceded<Tag<U8, u8>, MemsecCombinator>>, ModuleCombinator6);
-type ModuleCombinatorAlias8 = (Opt<Preceded<Tag<U8, u8>, TablesecCombinator>>, ModuleCombinator7);
-type ModuleCombinatorAlias9 = (Opt<Preceded<Tag<U8, u8>, FuncsecCombinator>>, ModuleCombinator8);
-type ModuleCombinatorAlias10 = (Opt<Preceded<Tag<U8, u8>, ImportsecCombinator>>, ModuleCombinator9);
-type ModuleCombinatorAlias11 = (Opt<Preceded<Tag<U8, u8>, TypesecCombinator>>, ModuleCombinator10);
-type ModuleCombinatorAlias12 = (Refined<bytes::Fixed<4>, TagPred<[u8; 4]>>, ModuleCombinator11);
-type ModuleCombinatorAlias13 = (Refined<bytes::Fixed<4>, TagPred<[u8; 4]>>, ModuleCombinator12);
-pub struct ModuleCombinator1(pub ModuleCombinatorAlias1);
-impl View for ModuleCombinator1 {
-    type V = SpecModuleCombinatorAlias1;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator1, ModuleCombinatorAlias1);
-
-pub struct ModuleCombinator2(pub ModuleCombinatorAlias2);
-impl View for ModuleCombinator2 {
-    type V = SpecModuleCombinatorAlias2;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator2, ModuleCombinatorAlias2);
-
-pub struct ModuleCombinator3(pub ModuleCombinatorAlias3);
-impl View for ModuleCombinator3 {
-    type V = SpecModuleCombinatorAlias3;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator3, ModuleCombinatorAlias3);
-
-pub struct ModuleCombinator4(pub ModuleCombinatorAlias4);
-impl View for ModuleCombinator4 {
-    type V = SpecModuleCombinatorAlias4;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator4, ModuleCombinatorAlias4);
-
-pub struct ModuleCombinator5(pub ModuleCombinatorAlias5);
-impl View for ModuleCombinator5 {
-    type V = SpecModuleCombinatorAlias5;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator5, ModuleCombinatorAlias5);
-
-pub struct ModuleCombinator6(pub ModuleCombinatorAlias6);
-impl View for ModuleCombinator6 {
-    type V = SpecModuleCombinatorAlias6;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator6, ModuleCombinatorAlias6);
-
-pub struct ModuleCombinator7(pub ModuleCombinatorAlias7);
-impl View for ModuleCombinator7 {
-    type V = SpecModuleCombinatorAlias7;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator7, ModuleCombinatorAlias7);
-
-pub struct ModuleCombinator8(pub ModuleCombinatorAlias8);
-impl View for ModuleCombinator8 {
-    type V = SpecModuleCombinatorAlias8;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator8, ModuleCombinatorAlias8);
-
-pub struct ModuleCombinator9(pub ModuleCombinatorAlias9);
-impl View for ModuleCombinator9 {
-    type V = SpecModuleCombinatorAlias9;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator9, ModuleCombinatorAlias9);
-
-pub struct ModuleCombinator10(pub ModuleCombinatorAlias10);
-impl View for ModuleCombinator10 {
-    type V = SpecModuleCombinatorAlias10;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator10, ModuleCombinatorAlias10);
-
-pub struct ModuleCombinator11(pub ModuleCombinatorAlias11);
-impl View for ModuleCombinator11 {
-    type V = SpecModuleCombinatorAlias11;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator11, ModuleCombinatorAlias11);
-
-pub struct ModuleCombinator12(pub ModuleCombinatorAlias12);
-impl View for ModuleCombinator12 {
-    type V = SpecModuleCombinatorAlias12;
-    open spec fn view(&self) -> Self::V { self.0@ }
-}
-impl_wrapper_combinator!(ModuleCombinator12, ModuleCombinatorAlias12);
-
-pub struct ModuleCombinator13(pub ModuleCombinatorAlias13);
-impl View for ModuleCombinator13 {
-    type V = SpecModuleCombinatorAlias13;
+pub type SpecCustomCombinatorAlias = Mapped<SpecCustomCombinatorAlias1, CustomMapper>;
+type CustomCombinatorAlias1 = (NameCombinator, MyCustomSectionCombinator);
+pub struct CustomCombinator1(pub CustomCombinatorAlias1);
+impl View for CustomCombinator1 {
+    type V = SpecCustomCombinatorAlias1;
     open spec fn view(&self) -> Self::V { self.0@ }
 }
-impl_wrapper_combinator!(ModuleCombinator13, ModuleCombinatorAlias13);
+impl_wrapper_combinator!(CustomCombinator1, CustomCombinatorAlias1);
 
-pub struct ModuleCombinator(pub ModuleCombinatorAlias);
+pub struct CustomCombinator(pub CustomCombinatorAlias);
 
-impl View for ModuleCombinator {
-    type V = SpecModuleCombinator;
-    open spec fn view(&self) -> Self::V { SpecModuleCombinator(self.0@) }
+impl View for CustomCombinator {
+    type V = SpecCustomCombinator;
+    open spec fn view(&self) -> Self::V { SpecCustomCombinator(self.0@) }
 }
-impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for ModuleCombinator {
-    type Type = Module<'a>;
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CustomCombinator {
+    type Type = Custom;
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
-pub type ModuleCombinatorAlias = Mapped<ModuleCombinator13, ModuleMapper>;
+}
+pub type CustomCombinatorAlias = Mapped<CustomCombinator1, CustomMapper>;
 
 
-pub open spec fn spec_module() -> SpecModuleCombinator {
-    SpecModuleCombinator(
+pub open spec fn spec_custom() -> SpecCustomCombinator {
+    SpecCustomCombinator(
     Mapped {
-        inner: (Refined { inner: bytes::Fixed::<4>, predicate: TagPred(SPEC_MODULEMAGIC_CONST) }, (Refined { inner: bytes::Fixed::<4>, predicate: TagPred(SPEC_MODULEVERSION_CONST) }, (Opt(Preceded(Tag::spec_new(U8, MODULETYPES_0_FRONT_CONST), spec_typesec())), (Opt(Preceded(Tag::spec_new(U8, MODULEIMPORTS_0_FRONT_CONST), spec_importsec())), (Opt(Preceded(Tag::spec_new(U8, MODULETYPEIDXS_0_FRONT_CONST), spec_funcsec())), (Opt(Preceded(Tag::spec_new(U8, MODULETABLES_0_FRONT_CONST), spec_tablesec())), (Opt(Preceded(Tag::spec_new(U8, MODULEMEMS_0_FRONT_CONST), spec_memsec())), (Opt(Preceded(Tag::spec_new(U8, MODULEGLOBALS_0_FRONT_CONST), spec_globalsec())), (Opt(Preceded(Tag::spec_new(U8, MODULEEXPORTS_0_FRONT_CONST), spec_exportsec())), (Opt(Preceded(Tag::spec_new(U8, MODULESTART_0_FRONT_CONST), spec_startsec())), (Opt(Preceded(Tag::spec_new(U8, MODULEELEMS_0_FRONT_CONST), spec_elemsec())), (Opt(Preceded(Tag::spec_new(U8, MODULEDATACOUNT_0_FRONT_CONST), spec_datacountsec())), (Opt(Preceded(Tag::spec_new(U8, MODULECODES_0_FRONT_CONST), spec_codesec())), Opt(Preceded(Tag::spec_new(U8, MODULEDATAS_0_FRONT_CONST), spec_datasec()))))))))))))))),
-        mapper: ModuleMapper,
+        inner: (spec_name(), spec_my_custom_section()),
+        mapper: CustomMapper,
     })
 }
 
                 
-pub fn module<'a>() -> (o: ModuleCombinator)
-    ensures o@ == spec_module(),
+pub fn custom<'a>() -> (o: CustomCombinator)
+    ensures o@ == spec_custom(),
             o@.requires(),
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
-    let combinator = ModuleCombinator(
+    let combinator = CustomCombinator(
     Mapped {
-        inner: ModuleCombinator13((Refined { inner: bytes::Fixed::<4>, predicate: TagPred(MODULEMAGIC_CONST) }, ModuleCombinator12((Refined { inner: bytes::Fixed::<4>, predicate: TagPred(MODULEVERSION_CONST) }, ModuleCombinator11((Opt::new(Preceded(Tag::new(U8, MODULETYPES_0_FRONT_CONST), typesec())), ModuleCombinator10((Opt::new(Preceded(Tag::new(U8, MODULEIMPORTS_0_FRONT_CONST), importsec())), ModuleCombinator9((Opt::new(Preceded(Tag::new(U8, MODULETYPEIDXS_0_FRONT_CONST), funcsec())), ModuleCombinator8((Opt::new(Preceded(Tag::new(U8, MODULETABLES_0_FRONT_CONST), tablesec())), ModuleCombinator7((Opt::new(Preceded(Tag::new(U8, MODULEMEMS_0_FRONT_CONST), memsec())), ModuleCombinator6((Opt::new(Preceded(Tag::new(U8, MODULEGLOBALS_0_FRONT_CONST), globalsec())), ModuleCombinator5((Opt::new(Preceded(Tag::new(U8, MODULEEXPORTS_0_FRONT_CONST), exportsec())), ModuleCombinator4((Opt::new(Preceded(Tag::new(U8, MODULESTART_0_FRONT_CONST), startsec())), ModuleCombinator3((Opt::new(Preceded(Tag::new(U8, MODULEELEMS_0_FRONT_CONST), elemsec())), ModuleCombinator2((Opt::new(Preceded(Tag::new(U8, MODULEDATACOUNT_0_FRONT_CONST), datacountsec())), ModuleCombinator1((Opt::new(Preceded(Tag::new(U8, MODULECODES_0_FRONT_CONST), codesec())), Opt::new(Preceded(Tag::new(U8, MODULEDATAS_0_FRONT_CONST), datasec())))))))))))))))))))))))))))),
-        mapper: ModuleMapper,
-    });
-    assert({
-        &&& combinator@ == spec_module()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+        inner: CustomCombinator1((name(), my_custom_section())),
+        mapper: CustomMapper,
     });
+    // assert({
+    //     &&& combinator@ == spec_custom()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
-pub fn parse_module<'a>(input: &'a [u8]) -> (res: PResult<<ModuleCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+pub fn parse_custom<'a>(input: &'a [u8]) -> (res: PResult<<CustomCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
     requires
         input.len() <= usize::MAX,
     ensures
-        res matches Ok((n, v)) ==> spec_module().spec_parse(input@) == Some((n as int, v@)),
-        spec_module().spec_parse(input@) matches Some((n, v))
+        res matches Ok((n, v)) ==> spec_custom().spec_parse(input@) == Some((n as int, v@)),
+        spec_custom().spec_parse(input@) matches Some((n, v))
             ==> res matches Ok((m, u)) && m == n && v == u@,
-        res is Err ==> spec_module().spec_parse(input@) is None,
-        spec_module().spec_parse(input@) is None ==> res is Err,
+        res is Err ==> spec_custom().spec_parse(input@) is None,
+        spec_custom().spec_parse(input@) is None ==> res is Err,
 {
-    let combinator = module();
+    let combinator = custom();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
 }
 
-pub fn serialize_module<'a>(v: <ModuleCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+pub fn serialize_custom<'a>(v: <CustomCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
     requires
         pos <= old(data)@.len() <= usize::MAX,
-        spec_module().wf(v@),
+        spec_custom().wf(v@),
     ensures
         o matches Ok(n) ==> {
             &&& data@.len() == old(data)@.len()
             &&& pos <= usize::MAX - n && pos + n <= data@.len()
-            &&& n == spec_module().spec_serialize(v@).len()
-            &&& data@ == seq_splice(old(data)@, pos, spec_module().spec_serialize(v@))
+            &&& n == spec_custom().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_custom().spec_serialize(v@))
         },
 {
-    let combinator = module();
+    let combinator = custom();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
 }
 
-pub fn module_len<'a>(v: <ModuleCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+pub fn custom_len<'a>(v: <CustomCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
     requires
-        spec_module().wf(v@),
-        spec_module().spec_serialize(v@).len() <= usize::MAX,
+        spec_custom().wf(v@),
+        spec_custom().spec_serialize(v@).len() <= usize::MAX,
     ensures
-        serialize_len == spec_module().spec_serialize(v@).len(),
+        serialize_len == spec_custom().spec_serialize(v@).len(),
 {
-    let combinator = module();
+    let combinator = custom();
     <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
 }
 
@@ -26001,13 +25984,13 @@ impl SpecCombinator for SpecSigned64Combinator {
     { self.0.requires() }
     open spec fn wf(&self, v: Self::Type) -> bool
     { self.0.wf(v) }
-    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> 
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
     { self.0.spec_parse(s) }
-    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> 
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
     { self.0.spec_serialize(v) }
 }
 impl SecureSpecCombinator for SpecSigned64Combinator {
-    open spec fn is_prefix_secure() -> bool 
+    open spec fn is_prefix_secure() -> bool
     { SpecSigned64CombinatorAlias::is_prefix_secure() }
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
     { self.0.theorem_serialize_parse_roundtrip(v) }
@@ -26015,11 +25998,11 @@ impl SecureSpecCombinator for SpecSigned64Combinator {
     { self.0.theorem_parse_serialize_roundtrip(buf) }
     proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
     { self.0.lemma_prefix_secure(s1, s2) }
-    proof fn lemma_parse_length(&self, s: Seq<u8>) 
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
     { self.0.lemma_parse_length(s) }
-    open spec fn is_productive(&self) -> bool 
+    open spec fn is_productive(&self) -> bool
     { self.0.is_productive() }
-    proof fn lemma_parse_productive(&self, s: Seq<u8>) 
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
     { self.0.lemma_parse_productive(s) }
 }
 pub type SpecSigned64CombinatorAlias = bytes::Fixed<8>;
@@ -26035,13 +26018,13 @@ impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for Signed64Combinator {
     type SType = &'a Self::Type;
     fn length(&self, v: Self::SType) -> usize
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
-    open spec fn ex_requires(&self) -> bool 
+    open spec fn ex_requires(&self) -> bool
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
-    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>) 
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
     { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
     fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
     { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
-} 
+}
 pub type Signed64CombinatorAlias = bytes::Fixed<8>;
 
 
@@ -26056,11 +26039,11 @@ pub fn signed_64<'a>() -> (o: Signed64Combinator)
             <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
 {
     let combinator = Signed64Combinator(bytes::Fixed::<8>);
-    assert({
-        &&& combinator@ == spec_signed_64()
-        &&& combinator@.requires()
-        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
-    });
+    // assert({
+    //     &&& combinator@ == spec_signed_64()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
     combinator
 }
 
@@ -26107,4 +26090,250 @@ pub fn signed_64_len<'a>(v: <Signed64Combinator as Combinator<'a, &'a [u8], Vec<
 
                 
 
+pub struct SpecCustomsec {
+    pub size: u64,
+    pub cont: SpecCustom,
+}
+
+pub type SpecCustomsecInner = (u64, SpecCustom);
+
+
+impl SpecFrom<SpecCustomsec> for SpecCustomsecInner {
+    open spec fn spec_from(m: SpecCustomsec) -> SpecCustomsecInner {
+        (m.size, m.cont)
+    }
+}
+
+impl SpecFrom<SpecCustomsecInner> for SpecCustomsec {
+    open spec fn spec_from(m: SpecCustomsecInner) -> SpecCustomsec {
+        let (size, cont) = m;
+        SpecCustomsec { size, cont }
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+
+pub struct Customsec {
+    pub size: u64,
+    pub cont: Custom,
+}
+
+impl View for Customsec {
+    type V = SpecCustomsec;
+
+    open spec fn view(&self) -> Self::V {
+        SpecCustomsec {
+            size: self.size@,
+            cont: self.cont@,
+        }
+    }
+}
+pub type CustomsecInner = (u64, Custom);
+
+pub type CustomsecInnerRef<'a> = (&'a u64, &'a Custom);
+impl<'a> From<&'a Customsec> for CustomsecInnerRef<'a> {
+    fn ex_from(m: &'a Customsec) -> CustomsecInnerRef<'a> {
+        (&m.size, &m.cont)
+    }
+}
+
+impl From<CustomsecInner> for Customsec {
+    fn ex_from(m: CustomsecInner) -> Customsec {
+        let (size, cont) = m;
+        Customsec { size, cont }
+    }
+}
+
+pub struct CustomsecMapper;
+impl View for CustomsecMapper {
+    type V = Self;
+    open spec fn view(&self) -> Self::V {
+        *self
+    }
+}
+impl SpecIso for CustomsecMapper {
+    type Src = SpecCustomsecInner;
+    type Dst = SpecCustomsec;
+}
+impl SpecIsoProof for CustomsecMapper {
+    proof fn spec_iso(s: Self::Src) {
+        assert(Self::Src::spec_from(Self::Dst::spec_from(s)) == s);
+    }
+    proof fn spec_iso_rev(s: Self::Dst) {
+        assert(Self::Dst::spec_from(Self::Src::spec_from(s)) == s);
+    }
+}
+impl<'a> Iso<'a> for CustomsecMapper {
+    type Src = CustomsecInner;
+    type Dst = Customsec;
+    type RefSrc = CustomsecInnerRef<'a>;
+}
+
+pub struct SpecCustomsecCombinator(pub SpecCustomsecCombinatorAlias);
+
+impl SpecCombinator for SpecCustomsecCombinator {
+    type Type = SpecCustomsec;
+    open spec fn requires(&self) -> bool
+    { self.0.requires() }
+    open spec fn wf(&self, v: Self::Type) -> bool
+    { self.0.wf(v) }
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)>
+    { self.0.spec_parse(s) }
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8>
+    { self.0.spec_serialize(v) }
+}
+impl SecureSpecCombinator for SpecCustomsecCombinator {
+    open spec fn is_prefix_secure() -> bool
+    { SpecCustomsecCombinatorAlias::is_prefix_secure() }
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type)
+    { self.0.theorem_serialize_parse_roundtrip(v) }
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>)
+    { self.0.theorem_parse_serialize_roundtrip(buf) }
+    proof fn lemma_prefix_secure(&self, s1: Seq<u8>, s2: Seq<u8>)
+    { self.0.lemma_prefix_secure(s1, s2) }
+    proof fn lemma_parse_length(&self, s: Seq<u8>)
+    { self.0.lemma_parse_length(s) }
+    open spec fn is_productive(&self) -> bool
+    { self.0.is_productive() }
+    proof fn lemma_parse_productive(&self, s: Seq<u8>)
+    { self.0.lemma_parse_productive(s) }
+}
+pub type SpecCustomsecCombinatorAlias = Mapped<SpecPair<UnsignedLEB128, AndThen<bytes::Variable, SpecCustomCombinator>>, CustomsecMapper>;
+
+pub struct CustomsecCombinator(pub CustomsecCombinatorAlias);
+
+impl View for CustomsecCombinator {
+    type V = SpecCustomsecCombinator;
+    open spec fn view(&self) -> Self::V { SpecCustomsecCombinator(self.0@) }
+}
+impl<'a> Combinator<'a, &'a [u8], Vec<u8>> for CustomsecCombinator {
+    type Type = Customsec;
+    type SType = &'a Self::Type;
+    fn length(&self, v: Self::SType) -> usize
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&self.0, v) }
+    open spec fn ex_requires(&self) -> bool
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&self.0) }
+    fn parse(&self, s: &'a [u8]) -> (res: Result<(usize, Self::Type), ParseError>)
+    { <_ as Combinator<'a, &'a [u8],Vec<u8>>>::parse(&self.0, s) }
+    fn serialize(&self, v: Self::SType, data: &mut Vec<u8>, pos: usize) -> (o: Result<usize, SerializeError>)
+    { <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&self.0, v, data, pos) }
+}
+pub type CustomsecCombinatorAlias = Mapped<Pair<UnsignedLEB128, AndThen<bytes::Variable, CustomCombinator>, CustomsecCont0>, CustomsecMapper>;
+
+
+pub open spec fn spec_customsec() -> SpecCustomsecCombinator {
+    SpecCustomsecCombinator(
+    Mapped {
+        inner: Pair::spec_new(UnsignedLEB128, |deps| spec_customsec_cont0(deps)),
+        mapper: CustomsecMapper,
+    })
+}
+
+pub open spec fn spec_customsec_cont0(deps: u64) -> AndThen<bytes::Variable, SpecCustomCombinator> {
+    let size = deps;
+    AndThen(bytes::Variable((usize::spec_from(size)) as usize), spec_custom())
+}
+
+impl View for CustomsecCont0 {
+    type V = spec_fn(u64) -> AndThen<bytes::Variable, SpecCustomCombinator>;
+
+    open spec fn view(&self) -> Self::V {
+        |deps: u64| {
+            spec_customsec_cont0(deps)
+        }
+    }
+}
+
+                
+pub fn customsec<'a>() -> (o: CustomsecCombinator)
+    ensures o@ == spec_customsec(),
+            o@.requires(),
+            <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o),
+{
+    let combinator = CustomsecCombinator(
+    Mapped {
+        inner: Pair::new(UnsignedLEB128, CustomsecCont0),
+        mapper: CustomsecMapper,
+    });
+    // assert({
+    //     &&& combinator@ == spec_customsec()
+    //     &&& combinator@.requires()
+    //     &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&combinator)
+    // });
+    combinator
+}
+
+pub fn parse_customsec<'a>(input: &'a [u8]) -> (res: PResult<<CustomsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::Type, ParseError>)
+    requires
+        input.len() <= usize::MAX,
+    ensures
+        res matches Ok((n, v)) ==> spec_customsec().spec_parse(input@) == Some((n as int, v@)),
+        spec_customsec().spec_parse(input@) matches Some((n, v))
+            ==> res matches Ok((m, u)) && m == n && v == u@,
+        res is Err ==> spec_customsec().spec_parse(input@) is None,
+        spec_customsec().spec_parse(input@) is None ==> res is Err,
+{
+    let combinator = customsec();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::parse(&combinator, input)
+}
+
+pub fn serialize_customsec<'a>(v: <CustomsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType, data: &mut Vec<u8>, pos: usize) -> (o: SResult<usize, SerializeError>)
+    requires
+        pos <= old(data)@.len() <= usize::MAX,
+        spec_customsec().wf(v@),
+    ensures
+        o matches Ok(n) ==> {
+            &&& data@.len() == old(data)@.len()
+            &&& pos <= usize::MAX - n && pos + n <= data@.len()
+            &&& n == spec_customsec().spec_serialize(v@).len()
+            &&& data@ == seq_splice(old(data)@, pos, spec_customsec().spec_serialize(v@))
+        },
+{
+    let combinator = customsec();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::serialize(&combinator, v, data, pos)
+}
+
+pub fn customsec_len<'a>(v: <CustomsecCombinator as Combinator<'a, &'a [u8], Vec<u8>>>::SType) -> (serialize_len: usize)
+    requires
+        spec_customsec().wf(v@),
+        spec_customsec().spec_serialize(v@).len() <= usize::MAX,
+    ensures
+        serialize_len == spec_customsec().spec_serialize(v@).len(),
+{
+    let combinator = customsec();
+    <_ as Combinator<'a, &'a [u8], Vec<u8>>>::length(&combinator, v)
+}
+
+pub struct CustomsecCont0;
+type CustomsecCont0Type<'a, 'b> = &'b u64;
+type CustomsecCont0SType<'a, 'x> = &'x u64;
+type CustomsecCont0Input<'a, 'b, 'x> = POrSType<CustomsecCont0Type<'a, 'b>, CustomsecCont0SType<'a, 'x>>;
+impl<'a, 'b, 'x> Continuation<CustomsecCont0Input<'a, 'b, 'x>> for CustomsecCont0 {
+    type Output = AndThen<bytes::Variable, CustomCombinator>;
+
+    open spec fn requires(&self, deps: CustomsecCont0Input<'a, 'b, 'x>) -> bool {
+        &&& (UnsignedLEB128).wf(deps@)
+        }
+
+    open spec fn ensures(&self, deps: CustomsecCont0Input<'a, 'b, 'x>, o: Self::Output) -> bool {
+        &&& <_ as Combinator<'a, &'a [u8], Vec<u8>>>::ex_requires(&o)
+        &&& o@ == spec_customsec_cont0(deps@)
+    }
+
+    fn apply(&self, deps: CustomsecCont0Input<'a, 'b, 'x>) -> Self::Output {
+        match deps {
+            POrSType::P(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), custom())
+            }
+            POrSType::S(deps) => {
+                let size = deps;
+                let size = *size;
+                AndThen(bytes::Variable((usize::ex_from(size)) as usize), custom())
+            }
+        }
+    }
+}
+                
+
 }
diff --git a/vest-examples/Cargo.toml b/vest-examples/Cargo.toml
index 55bdce53..739ce7d3 100644
--- a/vest-examples/Cargo.toml
+++ b/vest-examples/Cargo.toml
@@ -23,7 +23,7 @@ version = "0.1.0"
 edition = "2021"
 
 [workspace.dependencies]
-vstd = "0.0.0-2026-03-01-0109"
+vstd = "0.0.0-2026-03-17-2326"
 # verus_builtin = "=0.0.0-2026-01-11-0057"
 # verus_builtin_macros = "0.0.0-2025-12-07-0054"
 #verus_builtin = { git = "https://github.com/verus-lang/verus", branch = "main" }
diff --git a/vest/Cargo.toml b/vest/Cargo.toml
index 050ad2f4..059e089f 100644
--- a/vest/Cargo.toml
+++ b/vest/Cargo.toml
@@ -17,7 +17,7 @@ default = ["std"]
 std = []
 
 [dependencies]
-vstd = "0.0.0-2026-03-01-0109"
+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/regular/disjoint.rs b/vest/src/regular/disjoint.rs
index cbdf89bf..e6595ae6 100644
--- a/vest/src/regular/disjoint.rs
+++ b/vest/src/regular/disjoint.rs
@@ -55,6 +55,42 @@ impl<U1, U2, V1, V2> DisjointFrom<(U2, V2)> for (U1, V1) where
     }
 }
 
+
+// if `U1` and `Refined<Inner2, P2>` are disjoint, then `Pair(U1, V1)` is also disjoint
+// from `Refined<Inner2, P2)`.
+impl<U1, Inner2, P2, V1> DisjointFrom<Refined<Inner2, P2>> for SpecPair<U1, V1> where
+    U1: DisjointFrom<Refined<Inner2, P2>>,
+    U1: SecureSpecCombinator,
+    Inner2: SpecCombinator,
+    P2: SpecPred<Inner2::Type>,
+    V1: SpecCombinator,
+ {
+    open spec fn disjoint_from(&self, other: &Refined<Inner2, P2>) -> bool {
+        self.fst.disjoint_from(other)
+    }
+
+    proof fn parse_disjoint_on(&self, other: &Refined<Inner2, P2>, buf: Seq<u8>) {
+        self.fst.parse_disjoint_on(other, buf)
+    }
+}
+
+// if `U1` and `U2` are disjoint, then `Pair(U1, V1)` and `(U2, V2)` are disjoint
+impl<U1, U2, V1, V2> DisjointFrom<(U2, V2)> for SpecPair<U1, V1> where
+    U1: DisjointFrom<U2>,
+    U1: SecureSpecCombinator,
+    U2: SecureSpecCombinator,
+    V1: SpecCombinator,
+    V2: SpecCombinator,
+ {
+    open spec fn disjoint_from(&self, other: &(U2, V2)) -> bool {
+        self.fst.disjoint_from(&other.0)
+    }
+
+    proof fn parse_disjoint_on(&self, other: &(U2, V2), buf: Seq<u8>) {
+        self.fst.parse_disjoint_on(&other.0, buf)
+    }
+}
+
 // if `U1` and `U2` are disjoint, then `preceded(U1, V1)` and `preceded(U2, V2)` are disjoint
 impl<U1, U2, V1, V2> DisjointFrom<Preceded<U2, V2>> for Preceded<U1, V1> where
     U1: DisjointFrom<U2>,
diff --git a/vest/src/regular/modifier.rs b/vest/src/regular/modifier.rs
index 0f1658f2..3cc1cdf2 100644
--- a/vest/src/regular/modifier.rs
+++ b/vest/src/regular/modifier.rs
@@ -2,7 +2,7 @@
 use crate::properties::*;
 use vstd::prelude::*;
 
-use super::bytes::Variable;
+use super::bytes::{Tail, Variable};
 
 verus! {
 
@@ -814,6 +814,39 @@ impl<Next: SpecCombinator> SpecCombinator for AndThen<Variable, Next> {
     }
 }
 
+impl<Next: SpecCombinator> SpecCombinator for AndThen<Tail, Next> {
+    type Type = Next::Type;
+
+    open spec fn requires(&self) -> bool {
+        self.0.requires() && self.1.requires()
+    }
+
+    open spec fn wf(&self, v: Self::Type) -> bool {
+        self.1.wf(v) && self.0.wf(self.1.spec_serialize(v))
+    }
+
+    open spec fn spec_parse(&self, s: Seq<u8>) -> Option<(int, Self::Type)> {
+        if let Some((n, v1)) = self.0.spec_parse(s) {
+            if let Some((m, v2)) = self.1.spec_parse(v1) {
+                if m == n {
+                    Some((n, v2))
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
+    open spec fn spec_serialize(&self, v: Self::Type) -> Seq<u8> {
+        let buf1 = self.1.spec_serialize(v);
+        self.0.spec_serialize(buf1)
+    }
+}
+
 impl<Next: SecureSpecCombinator> SecureSpecCombinator for AndThen<Variable, Next> {
     proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type) {
         let buf1 = self.1.spec_serialize(v);
@@ -858,6 +891,48 @@ impl<Next: SecureSpecCombinator> SecureSpecCombinator for AndThen<Variable, Next
     }
 }
 
+impl<Next: SecureSpecCombinator> SecureSpecCombinator for AndThen<Tail, Next> {
+    proof fn theorem_serialize_parse_roundtrip(&self, v: Self::Type) {
+        let buf1 = self.1.spec_serialize(v);
+        self.1.theorem_serialize_parse_roundtrip(v);
+        self.0.theorem_serialize_parse_roundtrip(buf1);
+    }
+
+    proof fn theorem_parse_serialize_roundtrip(&self, buf: Seq<u8>) {
+        if let Some((n, v1)) = self.0.spec_parse(buf) {
+            if let Some((m, v2)) = self.1.spec_parse(v1) {
+                self.0.theorem_parse_serialize_roundtrip(buf);
+                self.1.theorem_parse_serialize_roundtrip(v1);
+                if m == n {
+                    let buf2 = self.1.spec_serialize(v2);
+                    let buf1 = self.0.spec_serialize(buf2);
+                    assert(buf1 == buf.subrange(0, n as int));
+                }
+            }
+        }
+    }
+
+    open spec fn is_prefix_secure() -> bool {
+        Tail::is_prefix_secure()
+    }
+
+    proof fn lemma_prefix_secure(&self, _buf: Seq<u8>, _s2: Seq<u8>) {
+    }
+
+    proof fn lemma_parse_length(&self, s: Seq<u8>) {
+        if let Some((_, v1)) = self.0.spec_parse(s) {
+            self.1.lemma_parse_length(v1);
+        }
+    }
+
+    open spec fn is_productive(&self) -> bool {
+        self.0.is_productive()
+    }
+
+    proof fn lemma_parse_productive(&self, _s: Seq<u8>) {
+    }
+}
+
 impl<'x, I, O, Next: Combinator<'x, I, O>> Combinator<'x, I, O> for AndThen<Variable, Next> where
     I: VestInput,
     O: VestOutput<I>,
@@ -893,4 +968,37 @@ impl<'x, I, O, Next: Combinator<'x, I, O>> Combinator<'x, I, O> for AndThen<Vari
     }
 }
 
+impl<'x, I, O, Next: Combinator<'x, I, O>> Combinator<'x, I, O> for AndThen<Tail, Next> where
+    I: VestInput,
+    O: VestOutput<I>,
+    Next::V: SecureSpecCombinator<Type = <Next::Type as View>::V>,
+ {
+    type Type = Next::Type;
+
+    type SType = Next::SType;
+
+    fn length(&self, v: Self::SType) -> usize {
+        self.1.length(v)
+    }
+
+    open spec fn ex_requires(&self) -> bool {
+        self.1.ex_requires()
+    }
+
+    fn parse(&self, s: I) -> Result<(usize, Self::Type), ParseError> {
+        let (n, v1) = <_ as Combinator<I, O>>::parse(&self.0, s)?;
+        let (m, v2) = self.1.parse(v1)?;
+        if m == n {
+            Ok((n, v2))
+        } else {
+            Err(ParseError::AndThenUnusedBytes)
+        }
+    }
+
+    fn serialize(&self, v: Self::SType, data: &mut O, pos: usize) -> Result<usize, SerializeError> {
+        let n = self.1.serialize(v, data, pos)?;
+        Ok(n)
+    }
+}
+
 } // verus!
diff --git a/vest/src/regular/sequence.rs b/vest/src/regular/sequence.rs
index 6cbb1249..8184bddc 100644
--- a/vest/src/regular/sequence.rs
+++ b/vest/src/regular/sequence.rs
@@ -18,7 +18,7 @@ impl<Fst, Snd> SpecCombinator for SpecPair<Fst, Snd> where
     open spec fn requires(&self) -> bool {
         &&& Fst::is_prefix_secure()
         &&& self.fst.requires()
-        &&& forall|i: Fst::Type| #[trigger] (self.snd)(i).requires()
+        &&& forall|i: Fst::Type| self.fst.wf(i) ==> #[trigger] (self.snd)(i).requires()
     }
 
     open spec fn wf(&self, v: Self::Type) -> bool {
@@ -57,7 +57,10 @@ impl<Fst, Snd> SecureSpecCombinator for SpecPair<Fst, Snd> where
         let buf1 = (self.snd)(v.0).spec_serialize(v.1);
         self.fst.theorem_serialize_parse_roundtrip(v.0);
         self.fst.lemma_prefix_secure(buf0, buf1);
-        (self.snd)(v.0).theorem_serialize_parse_roundtrip(v.1);
+        if self.wf(v) {
+            assert(self.fst.wf(v.0));
+            (self.snd)(v.0).theorem_serialize_parse_roundtrip(v.1);
+        }
         assert((buf0 + buf1).subrange(buf0.len() as int, buf.len() as int) == buf1);
     }
 
@@ -69,6 +72,7 @@ impl<Fst, Snd> SecureSpecCombinator for SpecPair<Fst, Snd> where
             let buf1 = buf.skip(n);
             assert(buf == buf0 + buf1);
             self.fst.theorem_parse_serialize_roundtrip(buf);
+            assert(self.fst.wf(v0));
             let (m, v1_) = (self.snd)(v0).spec_parse(buf1).unwrap();
             (self.snd)(v0).theorem_parse_serialize_roundtrip(buf1);
             (self.snd)(v0).lemma_parse_length(buf1);
@@ -92,6 +96,8 @@ impl<Fst, Snd> SecureSpecCombinator for SpecPair<Fst, Snd> where
                 self.fst.lemma_prefix_secure(buf0, buf1);
                 self.fst.lemma_prefix_secure(buf0, buf1.add(s2));
                 self.fst.lemma_prefix_secure(buf, s2);
+                self.fst.theorem_parse_serialize_roundtrip(buf);
+                assert(self.fst.wf(v0));
                 let snd = (self.snd)(v0);
                 let (m, v1_) = snd.spec_parse(buf1).unwrap();
                 assert(buf.add(s2).subrange(0, n as int) == buf0);
@@ -105,6 +111,8 @@ impl<Fst, Snd> SecureSpecCombinator for SpecPair<Fst, Snd> where
 
     proof fn lemma_parse_length(&self, s: Seq<u8>) {
         if let Some((n, v1)) = self.fst.spec_parse(s) {
+            self.fst.theorem_parse_serialize_roundtrip(s);
+            assert(self.fst.wf(v1));
             let snd = (self.snd)(v1);
             if let Some((m, v2)) = snd.spec_parse(s.subrange(n as int, s.len() as int)) {
                 self.fst.lemma_parse_length(s);
@@ -115,11 +123,13 @@ impl<Fst, Snd> SecureSpecCombinator for SpecPair<Fst, Snd> where
 
     open spec fn is_productive(&self) -> bool {
         ||| self.fst.is_productive()
-        ||| forall|v1| #[trigger] ((self.snd)(v1)).is_productive()
+        ||| forall|v1| self.fst.wf(v1) ==> #[trigger] ((self.snd)(v1)).is_productive()
     }
 
     proof fn lemma_parse_productive(&self, s: Seq<u8>) {
         if let Some((n, v1)) = self.fst.spec_parse(s) {
+            self.fst.theorem_parse_serialize_roundtrip(s);
+            assert(self.fst.wf(v1));
             let snd = (self.snd)(v1);
             if let Some((m, v2)) = snd.spec_parse(s.skip(n as int)) {
                 self.fst.lemma_parse_productive(s);
@@ -247,6 +257,9 @@ impl<'x, I, O, Fst, Snd, Cont> Combinator<'x, I, O> for Pair<Fst, Snd, Cont> whe
     type SType = (Fst::SType, Snd::SType);
 
     fn length(&self, v: Self::SType) -> usize {
+        proof {
+            assert(self.fst@.wf(v.0@));
+        }
         let snd = self.snd.apply(POrSType::S(v.0));
         self.fst.length(v.0) + snd.length(v.1)
     }
@@ -254,15 +267,19 @@ impl<'x, I, O, Fst, Snd, Cont> Combinator<'x, I, O> for Pair<Fst, Snd, Cont> whe
     open spec fn ex_requires(&self) -> bool {
         let spec_snd_dep = self.snd@;
         &&& self.fst.ex_requires()
-        &&& forall|i| #[trigger] self.snd.requires(i)
-        &&& forall|i, snd| #[trigger]
-            self.snd.ensures(i, snd) ==> snd.ex_requires() && snd@ == spec_snd_dep(i@)
+        &&& forall|i: POrSType<&Fst::Type, Fst::SType>|
+            self.fst@.wf(i@) ==> #[trigger] self.snd.requires(i)
+        &&& forall|i: POrSType<&Fst::Type, Fst::SType>, snd: Snd|
+            self.snd.requires(i) && #[trigger] self.snd.ensures(i, snd) ==> snd.ex_requires()
+                && snd@ == spec_snd_dep(i@)
     }
 
     fn parse(&self, s: I) -> (res: Result<(usize, Self::Type), ParseError>) {
         let (n, v1) = self.fst.parse(s.clone())?;
         proof {
             self@.fst.lemma_parse_length(s@);
+            self@.fst.theorem_parse_serialize_roundtrip(s@);
+            assert(self@.fst.wf(v1@));
         }
         let s_ = s.subrange(n, s.len());
         let snd = self.snd.apply(POrSType::P(&v1));
@@ -277,6 +294,9 @@ impl<'x, I, O, Fst, Snd, Cont> Combinator<'x, I, O> for Pair<Fst, Snd, Cont> whe
         usize,
         SerializeError,
     >) {
+        proof {
+            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)?;
@@ -348,6 +368,9 @@ impl<'x, Fst, Snd, I, O> Combinator<'x, I, O> for (Fst, Snd) where
     type SType = (Fst::SType, Snd::SType);
 
     fn length(&self, v: Self::SType) -> usize {
+        proof {
+            assert(self.0@.wf(v.0@));
+        }
         self.0.length(v.0) + self.1.length(v.1)
     }
 
@@ -359,6 +382,8 @@ impl<'x, Fst, Snd, I, O> Combinator<'x, I, O> for (Fst, Snd) where
         let (n, v1) = self.0.parse(s.clone())?;
         proof {
             self@.0.lemma_parse_length(s@);
+            self@.0.theorem_parse_serialize_roundtrip(s@);
+            assert(self@.0.wf(v1@));
         }
         let s_ = s.subrange(n, s.len());
         let (m, v2) = self.1.parse(s_)?;
@@ -372,6 +397,9 @@ impl<'x, Fst, Snd, I, O> Combinator<'x, I, O> for (Fst, Snd) where
         usize,
         SerializeError,
     >) {
+        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)?;
         assert(data@ == seq_splice(old(data)@, pos, self@.spec_serialize(v@)));